Update app.py

app.py

@@ -3,12 +3,16 @@ import streamlit as st
 import cv2
 import numpy as np
 import re
-import pandas as pd
 from PIL import Image
-from paddleocr import PaddleOCR
 import io
 import math
 
+# Try import PaddleOCR with graceful failure message inside app
+try:
+    from paddleocr import PaddleOCR
+except Exception:
+    PaddleOCR = None
+
 # -----------------------
 # CONFIG
 # -----------------------
@@ -32,90 +36,64 @@ KEYS = {
 # UTILITIES
 # -----------------------
 def safe_parse_number(s: str) -> float:
-    """
-    Robust parse of numbers that may use comma or dot for decimals, or thousand separators.
-    Examples:
-      "1,234.56" -> 1234.56
-      "1.234,56" -> 1234.56
-      "12,34" -> 12.34 (assume comma decimal if no dot)
-      "(12.3)" -> -12.3
-      "—" or "" -> 0.0
-    """
     if s is None:
         return 0.0
     s = str(s).strip()
     if s == "":
         return 0.0
-    # remove parentheses -> negative
     is_negative = False
     if s.startswith("(") and s.endswith(")"):
         is_negative = True
         s = s[1:-1].strip()
-    # strip non numeric except . and , and - and /
     s = re.sub(r"[^\d\.,\-\/]", "", s)
     if s == "" or s in ["-", ".", ","]:
         return 0.0
-    # handle fractions like 1/2
     if "/" in s and not any(c.isalpha() for c in s):
         try:
-            num, den = s.split("/", 1)
-            val = float(num) / float(den)
+            a, b = s.split("/", 1)
+            val = float(a) / float(b)
             return -val if is_negative else val
         except:
             pass
-    # if both dot and comma present, infer thousand/decimal by which appears last
     if "." in s and "," in s:
         if s.rfind(".") > s.rfind(","):
-            # dot decimal, comma thousands -> remove commas
             s = s.replace(",", "")
         else:
-            # comma decimal, dot thousands -> remove dots, replace comma with dot
             s = s.replace(".", "").replace(",", ".")
     else:
-        # only comma present -> treat comma as decimal if format small (e.g. "12,34")
         if "," in s and "." not in s:
-            # if multiple commas, remove thousands commas except last
             parts = s.split(",")
-            if len(parts[-1]) in (1,2,3):  # likely decimal
+            if len(parts[-1]) in (1,2,3):
                 s = s.replace(",", ".")
             else:
                 s = s.replace(",", "")
-    # finally convert
     try:
         val = float(s)
         return -val if is_negative else val
     except:
-        # fallback: extract digits and first decimal-like
         m = re.search(r"-?\d+([.,]\d+)?", s)
         if m:
             return float(m.group(0).replace(",", "."))
     return 0.0
 
 def preprocess_for_ocr(img: np.ndarray, max_dim=1600):
-    """Resize, denoise, and convert to RGB for OCR. Returns RGB image."""
-    # if grayscale convert to BGR
     if len(img.shape) == 2:
         img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
-    # downscale if too large (keep aspect)
     h, w = img.shape[:2]
-    scale = 1.0
     if max(h, w) > max_dim:
         scale = max_dim / max(h, w)
         img = cv2.resize(img, (int(w*scale), int(h*scale)), interpolation=cv2.INTER_AREA)
-    # denoise
-    img = cv2.fastNlMeansDenoisingColored(img, None, 10, 10, 7, 21)
-    # convert to RGB
+    try:
+        img = cv2.fastNlMeansDenoisingColored(img, None, 10, 10, 7, 21)
+    except Exception:
+        pass
     img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
     return img_rgb
 
 def try_ocr_variants(ocr, img_rgb):
-    """
-    Try several rotations and small scalings, return best text and details.
-    Score: number of numeric tokens found + sum(confidences).
-    """
     variants = []
     rotations = [0, 90, 180, 270]
-    scales = [1.0, 1.5, 0.8]  # try scaled variants if text small
+    scales = [1.0, 1.5, 0.8]
     for rot in rotations:
         if rot != 0:
             M = cv2.getRotationMatrix2D((img_rgb.shape[1]/2, img_rgb.shape[0]/2), rot, 1.0)
@@ -128,7 +106,7 @@ def try_ocr_variants(ocr, img_rgb):
             else:
                 imgrs = imgr
             try:
-                ocr_res = ocr.ocr(imgrs, cls=True)  # list of lines
+                ocr_res = ocr.ocr(imgrs, cls=True)
             except Exception:
                 try:
                     ocr_res = ocr.ocr(imgrs)
@@ -138,19 +116,9 @@ def try_ocr_variants(ocr, img_rgb):
             conf_sum = 0.0
             num_tokens = 0
             if ocr_res:
-                # PaddleOCR format varies: sometimes outer list contains pages
-                # Try to flatten
-                flat = []
-                if isinstance(ocr_res, list) and len(ocr_res) > 0 and isinstance(ocr_res[0], list):
-                    # typical: list of lines
-                    flat = ocr_res
-                elif isinstance(ocr_res, dict) and "text" in ocr_res:
-                    flat = ocr_res["text"]
-                else:
-                    flat = ocr_res
+                flat = ocr_res
                 for item in flat:
                     try:
-                        # item example: [box, (text, prob)]
                         entry = item[1] if isinstance(item, (list, tuple)) and len(item) > 1 else item
                         if isinstance(entry, (list, tuple)):
                             txt = entry[0]
@@ -165,44 +133,31 @@ def try_ocr_variants(ocr, img_rgb):
                         txt = str(item)
                         prob = 0.0
                     text_lines.append(txt)
-                    conf_sum += prob
-                    # count numeric tokens
+                    try:
+                        conf_sum += float(prob)
+                    except:
+                        pass
                     num_tokens += len(re.findall(r"[\d]+", txt))
             joined = " ".join(text_lines)
-            # scoring heuristics
             score = num_tokens + conf_sum
             variants.append({"rot": rot, "scale": s, "score": score, "text": joined, "raw": ocr_res})
-    # pick best
     variants = sorted(variants, key=lambda x: x["score"], reverse=True)
-    best = variants[0] if variants else {"text": ""}
-    return best
+    return variants[0] if variants else {"text": ""}
 
 def extract_nutrition_info(full_text: str) -> dict:
-    """
-    Try to extract serving size, sugar, saturated fat, and units.
-    Returns dict with keys: serving_value, serving_unit, sugar_value, sugar_unit, fat_value, fat_unit, per100_flag.
-    """
-    txt = full_text.lower()
-    # normalize common words
-    txt = txt.replace("sangat", " ")
-    # patterns for numbers with optional unit
-    num_pat = r"[-+]?\d{1,3}(?:[.,]\d{3})*(?:[.,]\d+)?(?:\s*(?:g|mg|ml|serving|sajian|tsp|tbsp))?"
-    # serving patterns
+    txt = (full_text or "").lower()
     serving = None
     serving_unit = None
     m = re.search(r"(takaran saj(?:i|a)|serving size|serving)[^\d]{0,10}([-\d\.,\/ ]{1,20})", txt)
     if m:
         serving = m.group(2).strip()
     else:
-        # try "per serving: 250 ml" or "1 bottle (330 ml)"
         m2 = re.search(r"(\d{1,3}(?:[.,]\d+)?)(?:\s*)(ml|g)\b", txt)
         if m2:
             serving = m2.group(1)
             serving_unit = m2.group(2)
-    # sugar patterns - try per 100 or per serving labels
     sugar = None
     sugar_unit = None
-    # common labels
     sugar_patterns = [
         r"(gula|sugar)[^\d\-\,\.\d]{0,6}([-\d\.,\/ ]{1,20})",
         r"sugars?[^\d]{0,6}([-\d\.,\/ ]{1,20})",
@@ -212,7 +167,6 @@ def extract_nutrition_info(full_text: str) -> dict:
         if m:
             sugar = m.group(2).strip()
             break
-    # fat (saturated)
     fat = None
     fat_unit = None
     fat_patterns = [
@@ -224,22 +178,17 @@ def extract_nutrition_info(full_text: str) -> dict:
         if m:
             fat = m.group(2).strip()
             break
-    # detect if values are per 100g/ml by presence of 'per 100' 'per 100g' 'per 100 ml' or '/100g'
     per100 = False
     if re.search(r"(per 100|per 100g|per 100 ml|/100g|/100 ml|/100ml|/100g)", txt):
         per100 = True
-
-    # fallback: extract any standalone numbers that might be table columns (first numeric cluster)
     if not sugar or sugar == "":
         nums = re.findall(r"[-+]?\d{1,3}(?:[.,]\d{3})*(?:[.,]\d+)?", txt)
         if nums:
-            # heuristics: pick numbers that are plausible (0-100)
             for n in nums:
                 v = safe_parse_number(n)
                 if 0 <= v <= 100:
                     sugar = n
                     break
-    # return
     return {
         "serving_raw": serving or "",
         "serving_unit": serving_unit or "",
@@ -251,27 +200,22 @@ def extract_nutrition_info(full_text: str) -> dict:
     }
 
 def normalize_to_per_100(value_raw: str, unit_raw: str, serving_size: float, values_are_per100: bool) -> float:
-    """Return value normalized to per 100g/ml. If already per100 flag true, parse and return."""
     if value_raw is None or str(value_raw).strip() == "":
         return 0.0
-    # strip unit words if any
-    s = str(value_raw).lower().replace("g", "").replace("mg", "").replace("ml", "").strip()
+    s = str(value_raw).lower()
+    s = re.sub(r"(g|mg|ml)\b", "", s)
     val = safe_parse_number(s)
-    # if values_are_per100, return val
     if values_are_per100:
         return val
-    # Otherwise assume value corresponds to per serving. Normalize by serving_size -> per 100.
     if serving_size and serving_size > 0:
-        per100 = (val / serving_size) * 100.0
-        return per100
-    # fallback: return val
+        try:
+            per100 = (val / serving_size) * 100.0
+            return per100
+        except Exception:
+            return val
     return val
 
 def get_grade_from_value(value: float, thresholds: dict) -> str:
-    """
-    thresholds expected in ascending order: {"A": xA, "B": xB, "C": xC}
-    smaller value => better (A)
-    """
     try:
         v = float(value)
     except:
@@ -294,7 +238,6 @@ def get_grade_color(grade: str):
     return colors.get(grade, ("#bdc3c7", "black"))
 
 def nutrition_advice_rule_based(final_grade: str, sugar_per100: float, fat_per100: float):
-    """Simple offline rule-based suggestions in Indonesian."""
     adv = []
     if final_grade == "Grade A":
         adv.append("Produk tergolong baik. Konsumsi sesuai porsi.")
@@ -317,33 +260,39 @@ def nutrition_advice_rule_based(final_grade: str, sugar_per100: float, fat_per10
 # -----------------------
 @st.cache_resource
 def init_ocr_model():
+    if PaddleOCR is None:
+        return None
     try:
-        # use_gpu False for compatibility in many Spaces; cls True to detect orientation
         return PaddleOCR(lang="en", use_angle_cls=True, use_gpu=False)
-    except Exception as e:
-        st.error(f"Gagal inisialisasi PaddleOCR: {e}")
+    except Exception:
         return None
 
 ocr_model = init_ocr_model()
-if ocr_model is None:
-    st.stop()
 
 # -----------------------
 # UI
 # -----------------------
 st.title("🥗 Nutri-Grade Detection & Grade Calculator (No AI Chatbot)")
-st.caption("Analisis gizi berdasarkan data pada label. Bisa menyesuaikan bila OCR keliru — selalu verifikasi hasil.")
+st.caption("Analisis gizi berdasarkan data pada label. Koreksi manual selalu disarankan.")
 
 with st.expander("📋 Petunjuk"):
     st.markdown(
         """
         1. Upload gambar tabel gizi (jpg/png).  
-        2. Klik **Analisis OCR**. Sistem akan mencoba beberapa rotasi/skalasi.  
+        2. Klik **Analisis OCR** (butuh PaddleOCR terinstall).  
         3. Koreksi hasil jika perlu.  
         4. Klik **Hitung Grade**.  
         """
     )
 
+if PaddleOCR is None:
+    st.error("PaddleOCR tidak ditemukan. Pastikan package `paddleocr` (dan `paddlepaddle`) telah terinstall di environment Anda.")
+    st.stop()
+
+if ocr_model is None:
+    st.error("Gagal inisialisasi model OCR. Jika di Spaces atau Docker, pastikan dependency paddle telah terpasang dengan benar.")
+    st.stop()
+
 st.header("1. Upload Gambar")
 uploaded = st.file_uploader("Pilih gambar (jpg, jpeg, png)", type=["jpg","jpeg","png"])
 
@@ -353,7 +302,6 @@ def reset_state():
             del st.session_state[v]
 
 if uploaded:
-    # read image
     file_bytes = np.asarray(bytearray(uploaded.read()), dtype=np.uint8)
     img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
     st.image(cv2.cvtColor(img, cv2.COLOR_BGR2RGB), caption="Preview", use_column_width=False, width=350)
@@ -364,7 +312,6 @@ if uploaded:
                 img_rgb = preprocess_for_ocr(img)
                 best = try_ocr_variants(ocr_model, img_rgb)
                 extracted = extract_nutrition_info(best.get("text", ""))
-                # store
                 st.session_state[KEYS["ocr_done"]] = True
                 st.session_state[KEYS["ocr_text"]] = best.get("text", "")
                 st.session_state[KEYS["data"]] = extracted
@@ -372,7 +319,6 @@ if uploaded:
             except Exception as e:
                 st.error(f"Gagal menjalankan OCR: {e}")
 
-# manual correction & calculation
 if st.session_state.get(KEYS["ocr_done"], False):
     st.header("2. Koreksi & Hitung Grade")
     d = st.session_state.get(KEYS["data"], {})
@@ -383,8 +329,6 @@ if st.session_state.get(KEYS["ocr_done"], False):
         values_are_per100 = st.checkbox("Nilai yang terdeteksi sudah per 100g/ml", value=d.get("values_are_per100", False))
         submitted = st.form_submit_button("Hitung Grade")
     if submitted:
-        # parse serving
-        # try extract number and unit
         m = re.search(r"(\d{1,4}(?:[.,]\d+)?)\s*(ml|g)?", serving_raw.lower())
         serving_size = 0.0
         serving_unit = ""
@@ -392,24 +336,19 @@ if st.session_state.get(KEYS["ocr_done"], False):
             serving_size = safe_parse_number(m.group(1))
             serving_unit = (m.group(2) or "").lower()
         else:
-            # fallback: raw number parse
             serving_size = safe_parse_number(serving_raw)
-        # normalize sugar/fat to per100
         sugar_per100 = normalize_to_per_100(sugar_raw, "", serving_size, values_are_per100)
         fat_per100 = normalize_to_per_100(fat_raw, "", serving_size, values_are_per100)
-        # store
         st.session_state[KEYS["calc"]] = {"serving_size": serving_size, "serving_unit": serving_unit, "sugar_per100": sugar_per100, "fat_per100": fat_per100}
         st.session_state[KEYS["calculated"]] = True
 
 if st.session_state.get(KEYS["calculated"], False):
     st.header("3. Hasil Grading & Saran")
     c = st.session_state[KEYS["calc"]]
-    # thresholds (example singapura nutri-grade style per100)
-    sugar_thresholds = {"A": 5.0, "B": 12.5, "C": 22.5}  # example values; sesuaikan jika ada standar resmi
-    fat_thresholds = {"A": 1.0, "B": 3.0, "C": 5.0}     # contoh
+    sugar_thresholds = {"A": 5.0, "B": 12.5, "C": 22.5}
+    fat_thresholds = {"A": 1.0, "B": 3.0, "C": 5.0}
     gs = get_grade_from_value(c["sugar_per100"], sugar_thresholds)
     gf = get_grade_from_value(c["fat_per100"], fat_thresholds)
-    # final grade: worst of the two (higher letter = worse)
     order = ["Grade A", "Grade B", "Grade C", "Grade D"]
     final = max([gs, gf], key=lambda x: order.index(x))
 
@@ -437,7 +376,6 @@ if st.session_state.get(KEYS["calculated"], False):
 
     st.markdown("**Catatan:** Hasil tergantung akurasi OCR dan input. Jika nilai terlihat aneh, koreksi secara manual pada langkah 2 lalu hitung ulang.")
 
-# Footer and reset
 st.markdown("---")
 st.write("Nutri-Grade App (improved). Pastikan memeriksa manual hasil OCR sebelum mengambil keputusan.")
 if st.button("Reset Aplikasi"):