Update app.py

app.py

@@ -1,334 +1,572 @@
-import os, re, json, math, base64
-from io import BytesIO
-from typing import Any, Dict, List, Optional, Tuple
+import os, io, math, re, base64, traceback
+from typing import List, Dict, Any, Tuple, Optional
 
 import httpx
-import gradio as gr
 import pandas as pd
+import gradio as gr
 from PIL import Image
 
 # =========================
-# Config
+# Конфиг (HF + OFF)
 # =========================
-HF_TOKEN = os.getenv("HF_TOKEN")  # Space → Settings → Repository secrets (Read)
-OFF_BASE = "https://world.openfoodfacts.org"
+HF_TOKEN = os.getenv("HF_TOKEN")  # Space → Settings → Repository secrets (scope: Read)
+ENV_HF_MODEL = (os.getenv("HF_MODEL") or "").strip()
 
-# Vision-LLM candidates (Inference API). Ще пробваме по ред:
-VLLM_MODELS = [
-    os.getenv("HF_VISION_LLM", "").strip() or "llava-hf/llava-1.5-7b-hf",
-    "llava-hf/llava-1.5-13b-hf",
-    "Qwen/Qwen2-VL-7B-Instruct",
+# Zero-shot multi-label (ако има достъп; иначе падаме към fallback)
+ZSL_CHAIN = [
+    os.getenv("HF_ZSL_MODEL", "").strip() or "openai/clip-vit-base-patch32",
+    "openai/clip-vit-large-patch14",
+    "laion/CLIP-ViT-B-32-laion2B-s34B-b79K",
 ]
 
-# Показни имена (EN→BG)
-EN_BG = {
-    "chicken breast": "пилешко филе","beef":"говеждо","steak":"пържола","pork":"свинско","turkey":"пуешко","lamb":"агнешко",
-    "bacon":"бекон","ham":"шунка","sausage":"наденица","prosciutto":"прошуто",
-    "salmon":"сьомга","tuna":"тон","shrimp":"скариди","prawn":"скариди","fish":"риба",
-    "egg":"яйце","egg yolk":"жълтък","egg white":"белтък","tofu":"тофу","tempeh":"темпе",
-    "rice":"ориз","white rice":"бял ориз","brown rice":"кафяв ориз","pasta":"паста","spaghetti":"спагети","noodles":"нудли",
-    "bread":"хляб","bun":"питка","tortilla":"тортила","potato":"картоф","fries":"пържени картофи",
-    "tomato":"домати","onion":"лук","red onion":"червен лук","garlic":"чесън","bell pepper":"чушка","cucumber":"краставица",
-    "lettuce":"маруля","spinach":"спанак","mushroom":"гъби","broccoli":"броколи","carrot":"морков","corn":"царевица",
-    "peas":"грах","eggplant":"патладжан","zucchini":"тиквичка","cabbage":"зеле","pickle":"краставички",
-    "mozzarella":"моцарела","cheddar":"чедър","parmesan":"пармезан","feta":"фета","yogurt":"кисело мляко","milk":"прясно мляко",
-    "butter":"масло","cream":"сметана","mayonnaise":"майонеза","ketchup":"кетчуп","mustard":"горчица",
-    "tomato sauce":"доматен сос","pesto":"песто","soy sauce":"соев сос","olive":"маслина","olive oil":"зехтин",
-    "sunflower oil":"олио","sirene":"сирене","kashkaval":"кашкавал","lyutenitsa":"лютеница","olives":"маслини"
-}
+# Single-label за разпознаване на ястието
+DISH_CHAIN = [
+    ENV_HF_MODEL or "nateraw/food101",
+    "microsoft/resnet-50",
+    "google/vit-base-patch16-224",
+]
 
-EMPTY_DF = pd.DataFrame(columns=["Съставка","Грамаж (g)","Ккал","Белтъчини (g)","Въглехидрати (g)","Мазнини (g)"])
+OFF_BASE = "https://world.openfoodfacts.org"
 
-# =========================
-# Helpers
-# =========================
-def _num(v: Any) -> float:
-    try:
-        x = float(v);  return x if math.isfinite(x) else 0.0
-    except Exception:
-        return 0.0
-
-def _kcal_from_macros_per100(p100: float, c100: float, f100: float) -> float:
-    return p100*4 + c100*4 + f100*9
-
-def _scale_per100_to_grams(per100: Dict[str,float], grams: float) -> Dict[str,float]:
-    f = grams/100.0
-    k = per100.get("kcal100",0.0)
-    p = per100.get("protein100",0.0)
-    c = per100.get("carbs100",0.0)
-    fa= per100.get("fat100",0.0)
-    if not k and (p or c or fa): k = _kcal_from_macros_per100(p,c,fa)
-    return {
-        "ккал": round(k*f,1) if k else 0.0,
-        "белтъчини": round(p*f,1) if p else 0.0,
-        "въглехидрати": round(c*f,1) if c else 0.0,
-        "мазнини": round(fa*f,1) if fa else 0.0,
-    }
+# Кандидат-съставки за zero-shot
+CANDIDATE_INGREDIENTS = [
+    # протеини
+    "chicken breast","chicken thigh","beef","steak","pork","pork belly","turkey","lamb",
+    "salami","bacon","ham","sausage","prosciutto",
+    "salmon","tuna","shrimp","prawn","white fish","sardines",
+    "egg","egg yolk","egg white",
+    "tofu","tempeh",
+    # млечни
+    "mozzarella","cheddar","parmesan","feta","goat cheese","yogurt","milk","butter","cream","sour cream",
+    # зърнени/нишестени
+    "rice","white rice","brown rice","pasta","spaghetti","noodles","tortilla","bread","bun","potato","sweet potato","couscous","quinoa",
+    # зеленчуци
+    "tomato","onion","red onion","garlic","bell pepper","cucumber","lettuce","spinach","mushroom","broccoli","carrot","corn","peas","eggplant","zucchini","cabbage",
+    # масла/сосове
+    "olive oil","sunflower oil","mayonnaise","ketchup","mustard","tomato sauce","pesto","soy sauce",
+    # други
+    "sugar","salt","black pepper","beans","lentils","chickpeas","olives",
+    # български популярни
+    "sirene","kashkaval","lyutenitsa","kyufte","kebapche","banitsa","tarator","shopska salad"
+]
 
-def _b64_image(img: Image.Image) -> str:
-    buf = BytesIO(); img.save(buf, format="PNG")
-    return "data:image/png;base64," + base64.b64encode(buf.getvalue()).decode("ascii")
+# Рецептни правила (dish → ingredients), EN/BG ключови думи
+DISH_RULES: Dict[str, List[str]] = {
+    # Пица
+    "pizza": ["mozzarella","tomato sauce","olive oil","basil","flour","yeast","salt"],
+    "margherita": ["mozzarella","tomato sauce","olive oil","basil","flour","yeast","salt"],
+    "пица": ["mozzarella","tomato sauce","olive oil","basil","flour","yeast","salt"],
+    # Паста
+    "pasta": ["pasta","olive oil","parmesan","tomato sauce","garlic","salt"],
+    "spaghetti": ["spaghetti","olive oil","parmesan","tomato sauce","garlic","salt"],
+    "макарони": ["pasta","olive oil","parmesan","tomato sauce","garlic","salt"],
+    # Бургер/сандвич
+    "burger": ["bun","beef","cheddar","lettuce","tomato","onion","mayonnaise","ketchup"],
+    "бургер": ["bun","beef","cheddar","lettuce","tomato","onion","mayonnaise","ketchup"],
+    "sandwich": ["bread","ham","cheddar","tomato","lettuce","butter"],
+    "сандвич": ["bread","ham","cheddar","tomato","lettuce","butter"],
+    # Салати
+    "salad": ["lettuce","tomato","cucumber","onion","olive oil","salt"],
+    "shopska": ["tomato","cucumber","onion","sirene","olive oil","salt"],
+    "шопска": ["tomato","cucumber","onion","sirene","olive oil","salt"],
+    # Месо
+    "steak": ["beef","olive oil","salt","black pepper"],
+    "chicken": ["chicken breast","olive oil","salt","black pepper"],
+    "пържола": ["beef","olive oil","salt","black pepper"],
+    "пилешко": ["chicken breast","olive oil","salt","black pepper"],
+    # BG класики
+    "кифтета": ["kyufte","onion","salt","black pepper","sunflower oil","bread"],
+    "кюфте": ["kyufte","onion","salt","black pepper","sunflower oil","bread"],
+    "кебапче": ["kebapche","salt","black pepper","sunflower oil","bread"],
+    "баница": ["flour","sirene","eggs","yogurt","sunflower oil","butter"],
+    "тарaтор": ["yogurt","cucumber","garlic","dill","walnuts","salt"],
+    "tarator": ["yogurt","cucumber","garlic","dill","walnuts","salt"],
+}
+
+EMPTY_TABLE = pd.DataFrame(columns=[
+    "Съставка","Грамаж (g)","ккал/100g","Белтъчини/100g","Въглехидрати/100g","Мазнини/100g","ккал"
+])
 
-def _hf_url(model_id: str) -> str:
-    return f"https://api-inference.huggingface.co/models/{model_id}"
+def hf_url(mid: str) -> str:
+    return f"https://api-inference.huggingface.co/models/{mid}"
 
 # =========================
-# Vision LLM (robust callers; try multiple payload shapes)
+# HF helpers
 # =========================
-SYSTEM_PROMPT = (
-    "You are a culinary vision assistant. "
-    "Given an image, extract: (1) DISH name (short), (2) INGREDIENTS list. "
-    "Return STRICT JSON with this schema:\n"
-    "{\"dish\": \"...\", \"ingredients\": [{\"name\": \"...\"}, ...]}\n"
-    "Rules: use common food terms in EN; avoid brand names; 3-12 concise ingredients; "
-    "no commentary, JSON only."
-)
-
-def _payloads_for_model(b64_img: str, user_prompt: str) -> List[Dict[str, Any]]:
-    # 1) LLaVA-style
-    p1 = {
-        "inputs": {
-            "prompt": f"USER: <image>\n{user_prompt}\nASSISTANT:",
-            "image": b64_img
-        },
-        "parameters": {"max_new_tokens": 256}
-    }
-    # 2) Messages (Qwen2-VL style)
-    p2 = {
-        "inputs": [
-            {"role":"system","content":[{"type":"text","text":SYSTEM_PROMPT}]},
-            {"role":"user","content":[{"type":"image","image":b64_img},{"type":"text","text":user_prompt}]}
-        ],
-        "parameters": {"max_new_tokens": 256}
-    }
-    # 3) Generic {image, text}
-    p3 = {
-        "inputs": {"image": b64_img, "text": user_prompt},
-        "parameters": {"max_new_tokens": 256}
-    }
-    return [p1, p2, p3]
+def _img_to_data_url(img: Image.Image) -> str:
+    buf = io.BytesIO()
+    img.save(buf, format="PNG")
+    b64 = base64.b64encode(buf.getvalue()).decode("ascii")
+    return f"data:image/png;base64,{b64}"
 
-def _parse_llm_json(text: str) -> Tuple[str, List[str]]:
-    """Parse {"dish": "...", "ingredients":[{"name":"..."}, ...]}."""
-    try:
-        # pick first {...} block to avoid stray tokens
-        m = re.search(r"\{.*\}", text, re.S)
-        js = json.loads(m.group(0) if m else text)
-        dish = str(js.get("dish") or "").strip()
-        ings = []
-        for it in js.get("ingredients") or []:
-            name = str(it.get("name") or "").strip()
-            if name: ings.append(name)
-        # fallback: if ingredients is a list of strings
-        if not ings and isinstance(js.get("ingredients"), list):
-            ings = [str(x).strip() for x in js["ingredients"] if str(x).strip()]
-        return dish, ings
-    except Exception:
-        return "", []
-
-async def vllm_extract(image: Image.Image) -> Tuple[str, List[str], str]:
-    """
-    Returns (dish, ingredients[], used_model). Never raises.
-    """
+async def zeroshot_multilabel(img: Image.Image, labels: List[str], score_thresh: float = 0.12, top_k: int = 8
+) -> Tuple[List[str], Optional[str], Optional[str]]:
+    """Zero-shot multi-label (ако моделите са налични)."""
     if not HF_TOKEN:
-        return "", [], ""
-    b64 = _b64_image(image)
+        return [], None, "Липсва HF_TOKEN."
+    payload_img = _img_to_data_url(img)
     headers = {
         "Authorization": f"Bearer {HF_TOKEN}",
         "Accept": "application/json",
         "Content-Type": "application/json",
     }
-    prompt = SYSTEM_PROMPT  # baked in system; also send as user
-    tried = []
+    body = {
+        "inputs": {"image": payload_img, "candidate_labels": labels},
+        "parameters": {"multi_label": True}
+    }
+    tried: List[str] = []
     async with httpx.AsyncClient(timeout=90) as client:
-        for mid in VLLM_MODELS:
-            if not mid: continue
+        for mid in ZSL_CHAIN:
+            if not mid:
+                continue
+            url = hf_url(mid)
             tried.append(mid)
-            url = _hf_url(mid)
-            for body in _payloads_for_model(b64, SYSTEM_PROMPT):
-                try:
-                    r = await client.post(url, headers=headers, json=body)
-                    if r.status_code != 200:
-                        continue
-                    data = r.json()
-                    # try typical response shapes:
-                    if isinstance(data, list):
-                        # LLaVA often returns [{"generated_text":"..."}]
-                        if data and isinstance(data[0], dict) and "generated_text" in data[0]:
-                            dish, ings = _parse_llm_json(str(data[0]["generated_text"]))
-                        else:
-                            dish, ings = _parse_llm_json(json.dumps(data))
-                    elif isinstance(data, dict):
-                        txt = ""
-                        if "generated_text" in data: txt = str(data["generated_text"])
-                        elif "choices" in data: txt = json.dumps(data["choices"])
-                        else: txt = json.dumps(data)
-                        dish, ings = _parse_llm_json(txt)
-                    else:
-                        dish, ings = _parse_llm_json(str(data))
-                    if dish or ings:
-                        return dish, ings, mid
-                except Exception:
+            try:
+                r = await client.post(url, headers=headers, json=body)
+                if r.status_code != 200:
                     continue
-    # failed:
-    return "", [], ""
+                data = r.json()
+                cand_scores: List[Tuple[str, float]] = []
+                if isinstance(data, dict) and "labels" in data and "scores" in data:
+                    for lab, sc in zip(data.get("labels") or [], data.get("scores") or []):
+                        try:
+                            cand_scores.append((str(lab), float(sc)))
+                        except Exception:
+                            pass
+                elif isinstance(data, list):
+                    for it in data:
+                        try:
+                            cand_scores.append((str(it.get("label")), float(it.get("score") or 0)))
+                        except Exception:
+                            pass
+                cand_scores = [(l, s) for (l, s) in cand_scores if l]
+                cand_scores.sort(key=lambda x: x[1], reverse=True)
+                picked = [l for (l, s) in cand_scores if s >= score_thresh][:top_k]
+                if not picked and cand_scores:
+                    picked = [l for (l, _) in cand_scores[:3]]
+                return picked, mid, None
+            except Exception:
+                continue
+    warn = f"Zero-shot неуспешно. Пробвани: {', '.join(tried)}."
+    return [], None, warn
+
+async def classify_dish(img: Image.Image, k: int = 5) -> Tuple[List[str], Optional[str], Optional[str]]:
+    """Single-label класификация (за етикет на ястие) — връща топ етикети (dish candidates)."""
+    if not HF_TOKEN:
+        return [], None, "Липсва HF_TOKEN."
+    buf = io.BytesIO()
+    img.save(buf, format="PNG")
+    body = buf.getvalue()
+    headers = {
+        "Authorization": f"Bearer {HF_TOKEN}",
+        "Accept": "application/json",
+        "X-Wait-For-Model": "true",
+    }
+    tried: List[str] = []
+    async with httpx.AsyncClient(timeout=75) as client:
+        for mid in DISH_CHAIN:
+            if not mid:
+                continue
+            tried.append(mid)
+            try:
+                r = await client.post(hf_url(mid), headers=headers, content=body)
+                if r.status_code != 200:
+                    continue
+                data = r.json()
+                preds = data if isinstance(data, list) else data[0]
+                labs: List[str] = []
+                for p in (preds or [])[:k]:
+                    lab = str(p.get("label") or p.get("class") or p.get("className") or "").strip()
+                    if lab:
+                        labs.append(lab)
+                if labs:
+                    return labs, mid, None
+            except Exception:
+                continue
+    warn = f"Dish класификация неуспешна. Пробвани: {', '.join(tried)}."
+    return [], None, warn
 
 # =========================
-# Open Food Facts
+# OFF helpers
 # =========================
 async def off_search_first(query: str) -> Optional[Dict[str, Any]]:
-    if not query: return None
+    if not query:
+        return None
+    params = {
+        "search_terms": query,
+        "search_simple": "1",
+        "action": "process",
+        "json": "1",
+        "page_size": "5",
+        "lc": "bg",
+        "fields": ",".join([
+            "product_name","product_name_bg","generic_name","generic_name_bg","brands",
+            "nutriments","image_front_url"
+        ])
+    }
+    async with httpx.AsyncClient(timeout=25) as client:
+        r = await client.get(f"{OFF_BASE}/cgi/search.pl", params=params)
+    if r.status_code != 200:
+        return None
+    js = r.json()
+    prods = js.get("products") or []
+    return prods[0] if prods else None
+
+async def off_suggest(term: str) -> List[str]:
+    if not term:
+        return []
+    params = { "search_terms": term, "json": "1" }
+    async with httpx.AsyncClient(timeout=10) as client:
+        r = await client.get(f"{OFF_BASE}/cgi/suggest.pl", params=params)
+    if r.status_code != 200:
+        return []
     try:
-        params = {
-            "search_terms": query,
-            "search_simple": "1",
-            "action": "process",
-            "json": "1",
-            "page_size": "5",
-            "lc": "bg",
-            "fields": ",".join([
-                "product_name","product_name_bg","generic_name","generic_name_bg","brands",
-                "nutriments","image_front_url","url"
-            ])
-        }
-        async with httpx.AsyncClient(timeout=25) as client:
-            r = await client.get(f"{OFF_BASE}/cgi/search.pl", params=params)
-        if r.status_code != 200:
-            return None
-        js = r.json()
-        prods = js.get("products") or []
-        return prods[0] if prods else None
+        data = r.json()
+        if isinstance(data, list):
+            return [str(x) for x in data][:20]
     except Exception:
-        return None
+        pass
+    return []
+
+def extract_kcal_macros_100(nutriments: Optional[Dict[str, Any]]) -> Dict[str, float]:
+    n = nutriments or {}
+    def num(v):
+        try:
+            x = float(v)
+            return x if math.isfinite(x) else 0.0
+        except Exception:
+            return 0.0
+    p = num(n.get("proteins_100g"))
+    c = num(n.get("carbohydrates_100g"))
+    f = num(n.get("fat_100g"))
+    kcal = num(n.get("energy-kcal_100g"))
+    if not kcal and (p or c or f):
+        kcal = p*4 + c*4 + f*9
+    return {"kcal100": round(kcal,1) if kcal else 0.0,
+            "p100": round(p,1) if p else 0.0,
+            "c100": round(c,1) if c else 0.0,
+            "f100": round(f,1) if f else 0.0}
+
+# =========================
+# Калкулации
+# =========================
+EMPTY_TABLE = pd.DataFrame(columns=[
+    "Съставка","Грамаж (g)","ккал/100g","Белтъчини/100g","Въглехидрати/100g","Мазнини/100g","ккал"
+])
+
+def row_kcal(grams: float, kcal100: float, p100: float, c100: float, f100: float) -> float:
+    base = kcal100 if kcal100 else (p100*4 + c100*4 + f100*9)
+    return round((grams/100.0) * base, 1) if base else 0.0
+
+def recompute_df(df: pd.DataFrame) -> Tuple[pd.DataFrame, Dict[str, float]]:
+    cols = ["Съставка","Грамаж (g)","ккал/100g","Белтъчини/100g","Въглехидрати/100g","Мазнини/100g","ккал"]
+    if df is None or df.empty:
+        return EMPTY_TABLE.copy(), {"sum_kcal":0.0,"sum_p":0.0,"sum_c":0.0,"sum_f":0.0}
+    for c in cols:
+        if c not in df.columns:
+            df[c] = 0.0 if c != "Съставка" else ""
+    df = df[cols].copy()
+    for c in ["Грамаж (g)","ккал/100g","Белтъчини/100g","Въглехидрати/100g","Мазнини/100g"]:
+        df[c] = pd.to_numeric(df[c], errors="coerce").fillna(0.0)
+    df["ккал"] = [
+        row_kcal(g, k, p, c, f)
+        for g, k, p, c, f in zip(
+            df["Грамаж (g)"], df["ккал/100g"], df["Белтъчини/100g"], df["Въглехидрати/100g"], df["Мазнини/100g"]
+        )
+    ]
+    factor = (df["Грамаж (g)"] / 100.0).astype(float)
+    sum_p = float((factor * df["Белтъчини/100g"]).sum().round(1))
+    sum_c = float((factor * df["Въглехидрати/100g"]).sum().round(1))
+    sum_f = float((factor * df["Мазнини/100g"]).sum().round(1))
+    sum_kcal = float(df["ккал"].sum().round(1))
+    return df, {"sum_kcal":sum_kcal,"sum_p":sum_p,"sum_c":sum_c,"sum_f":sum_f}
 
-def off_per100(prod: Optional[Dict[str, Any]]) -> Dict[str,float]:
-    n = (prod or {}).get("nutriments") or {}
-    p = _num(n.get("proteins_100g"))
-    c = _num(n.get("carbohydrates_100g"))
-    f = _num(n.get("fat_100g"))
-    k = _num(n.get("energy-kcal_100g"))
-    if not k and (p or c or f): k = _kcal_from_macros_per100(p,c,f)
-    return {"kcal100":k,"protein100":p,"carbs100":c,"fat100":f}
+# =========================
+# Генериране на съставки от ястие (fallback логика)
+# =========================
+def tokenize(s: str) -> List[str]:
+    s = (s or "").lower()
+    s = re.sub(r"[^a-zA-Zа-яА-Я0-9\s\-]", " ", s)
+    toks = re.split(r"\s+", s)
+    return [t for t in toks if t]
+
+def infer_ingredients_from_dish(dish_label: str, alt_labels: List[str]) -> List[str]:
+    # 1) Рецептни правила по ключова дума
+    dish_text = " ".join([dish_label] + alt_labels).lower()
+    for key, ings in DISH_RULES.items():
+        if key in dish_text:
+            return list(dict.fromkeys(ings))[:8]  # уникални, до 8 бр
+
+    # 2) Токенизация на етикетите → отсекаме очевидни съставки
+    stops = set(["with","and","of","the","a","an","на","с","от","и"])
+    toks = [t for t in tokenize(dish_text) if t not in stops]
+    # mapping някои токени към по-точни съставки
+    map_tok = {
+        "mozzarella":"mozzarella","parmesan":"parmesan","feta":"feta","sirene":"sirene","kashkaval":"kashkaval",
+        "chicken":"chicken breast","beef":"beef","pork":"pork","turkey":"turkey","lamb":"lamb",
+        "egg":"egg","eggs":"egg","tomato":"tomato","onion":"onion","garlic":"garlic","mushroom":"mushroom",
+        "pepper":"bell pepper","bread":"bread","bun":"bun","pasta":"pasta","spaghetti":"spaghetti",
+        "rice":"rice","noodles":"noodles","salmon":"salmon","tuna":"tuna","shrimp":"shrimp","prawn":"prawn",
+        "olive":"olive oil","oil":"olive oil","ketchup":"ketchup","mayonnaise":"mayonnaise","mustard":"mustard",
+        "sauce":"tomato sauce","lyutenitsa":"lyutenitsa"
+    }
+    found: List[str] = []
+    for t in toks:
+        if t in map_tok:
+            found.append(map_tok[t])
+        elif t in CANDIDATE_INGREDIENTS:
+            found.append(t)
+        elif t in ("pizza","пица","burger","бургер","sandwich","сандвич","pasta","спагети","spaghetti","salad","салата"):
+            continue
+    if found:
+        # докомплектовай с базови
+        if any(x in dish_text for x in ["pizza","пица"]):
+            found += ["flour","yeast","salt","olive oil","tomato sauce","mozzarella"]
+        if any(x in dish_text for x in ["pasta","spaghetti","макарони","спагети"]):
+            found += ["pasta","olive oil","parmesan"]
+        return list(dict.fromkeys(found))[:8]
+
+    # 3) Накрая — fallback: върни самите етикети като „съставки“
+    base = [dish_label] + alt_labels
+    # изчисти очевидни шумове
+    cleaned = [re.sub(r"[^a-zA-Zа-яА-Я0-9\s\-]", "", x).strip().lower() for x in base]
+    cleaned = [x for x in cleaned if x]
+    return list(dict.fromkeys(cleaned))[:5]
 
 # =========================
-# Rows & totals
+# Таблични редове от OFF
 # =========================
-async def rows_from_names(names: List[str], default_grams: float) -> pd.DataFrame:
-    rows: List[List[Any]] = []
+async def rows_from_names(names: List[str], default_grams: float = 100.0) -> pd.DataFrame:
+    rows = []
     for name in names:
         prod = await off_search_first(name)
-        per100 = off_per100(prod)
-        scaled = _scale_per100_to_grams(per100, float(default_grams))
-        show = EN_BG.get(name, name)
-        rows.append([show, float(default_grams), scaled["ккал"], scaled["белтъчини"], scaled["въглехидрати"], scaled["мазнини"]])
-    return pd.DataFrame(rows, columns=EMPTY_DF.columns) if rows else EMPTY_DF.copy()
-
-def totals(df: pd.DataFrame) -> Tuple[float,float,float,float]:
-    if df is None or df.empty: return (0.0,0.0,0.0,0.0)
-    return (
-        float(_num(df["Ккал"].sum())),
-        float(_num(df["Белтъчини (g)"].sum())),
-        float(_num(df["Въглехидрати (g)"].sum())),
-        float(_num(df["Мазнини (g)"].sum())),
-    )
+        vals = extract_kcal_macros_100((prod or {}).get("nutriments"))
+        rows.append([name, default_grams, vals["kcal100"], vals["p100"], vals["c100"], vals["f100"], 0.0])
+    df = pd.DataFrame(rows, columns=EMPTY_TABLE.columns)
+    df, _ = recompute_df(df)
+    return df
 
 # =========================
-# Main callback
+# Gradio callbacks
 # =========================
-async def analyze(
-    image: Image.Image,
-    grams_default: int,
-    manual_df: pd.DataFrame
-):
+async def analyze_photo(image: Image.Image, grams_default: int, zsl_thresh: float, zsl_topk: int):
     """
-    1) Vision LLM → dish + ingredients (JSON).
-    2) OFF нутриенти за всеки.
-    3) Обединява с ръчната таблица (ако има валидни редове).
+    Стъпки:
+    1) Разпознай ястието (top-1 + алтернативи).
+    2) Опитай zero-shot multi-label върху речник от съставки (ако налично).
+    3) Ако няма — извлечи съставки по правила/токени/alt labels.
+    4) OFF за всяка съставка → таблица + тотали.
     """
-    messages: List[str] = []
-    auto_df = EMPTY_DF.copy()
-
-    if image is not None:
-        dish, ings, used = await vllm_extract(image)
-        if used: messages.append(f"Vision LLM: {used}")
-        if dish: messages.append(f"Ястие (LLM): {dish}")
-        if ings:
-            auto_df = await rows_from_names(ings[:12], float(grams_default))
-            messages.append("Съставки (LLM): " + ", ".join(ings[:8]) + ("..." if len(ings)>8 else ""))
-        else:
-            messages.append("LLM не върна разпознаваеми съставки — ползвай ръчните редове отдолу.")
-
-    # Manual rows
-    manual_rows: List[List[Any]] = []
     try:
-        if manual_df is not None and not manual_df.empty:
-            # очакваме колони ["Съставка","Грамаж (g)"] или пълната форма; нормализирай
-            cols = [c.lower() for c in manual_df.columns]
-            if "съставка" in cols and "грамаж (g)" in cols:
-                name_col = manual_df.columns[cols.index("съставка")]
-                g_col = manual_df.columns[cols.index("грамаж (g)")]
-                for _, row in manual_df.iterrows():
-                    name = str(row.get(name_col) or "").strip()
-                    grams = _num(row.get(g_col))
-                    if name and grams>0:
-                        prod = await off_search_first(name)
-                        per100 = off_per100(prod)
-                        scaled = _scale_per100_to_grams(per100, grams)
-                        manual_rows.append([name, grams, scaled["ккал"], scaled["белтъчини"], scaled["въглехидрати"], scaled["мазнини"]])
+        if image is None:
+            return "Качи снимка.", EMPTY_TABLE.copy(), 0.0, 0.0, 0.0, 0.0
+
+        info: List[str] = []
+
+        # 1) dish labels
+        dish_labels, used_dish_model, warn_dish = await classify_dish(image, k=5)
+        if used_dish_model:
+            info.append(f"Dish модел: {used_dish_model}")
+        if warn_dish:
+            info.append(warn_dish)
+        dish_main = dish_labels[0] if dish_labels else ""
+
+        # 2) zero-shot multi-label ingredients
+        picked, used_zsl, warn_zsl = await zeroshot_multilabel(
+            image, CANDIDATE_INGREDIENTS, score_thresh=float(zsl_thresh), top_k=int(zsl_topk)
+        )
+        if used_zsl:
+            info.append(f"Zero-shot модел: {used_zsl}")
+        if warn_zsl:
+            info.append(warn_zsl)
+
+        # 3) ако няма zero-shot резултати → derive от dish + alt labels
+        if not picked:
+            picked = infer_ingredients_from_dish(dish_main, dish_labels[1:])
+
+        if not picked:
+            msg = ("Няма разпознати съставки. "
+                   "Можеш да добавиш ръчно от полето по-долу и да попълниш стойности.")
+            info.insert(0, f"Ястие: {dish_main or '—'}")
+            return "\n".join(info + [msg]), EMPTY_TABLE.copy(), 0.0, 0.0, 0.0, 0.0
+
+        # 4) OFF → таблица
+        df = await rows_from_names(picked, float(grams_default))
+        df, totals = recompute_df(df)
+
+        info.insert(0, f"Ястие: {dish_main or '—'}")
+        if picked:
+            info.append(f"Съставки: {', '.join(picked)}")
+
+        return "\n".join(info), df, totals["sum_kcal"], totals["sum_p"], totals["sum_c"], totals["sum_f"]
+    except Exception as e:
+        tb = traceback.format_exc(limit=2)
+        return f"Грешка при анализ: {e}\n{tb}", EMPTY_TABLE.copy(), 0.0, 0.0, 0.0, 0.0
+
+async def apply_names(text_area: str, df: pd.DataFrame, grams_default: int):
+    """
+    Бързо добавяне: редове 'име[, грамаж]'.
+    """
+    try:
+        names: List[str] = []
+        grams_map: Dict[str, float] = {}
+        for raw in (text_area or "").splitlines():
+            line = raw.strip()
+            if not line:
+                continue
+            if "," in line:
+                name, gr = line.split(",", 1)
+                name = name.strip()
+                try:
+                    grams_map[name] = float(gr.strip())
+                except Exception:
+                    grams_map[name] = float(grams_default)
+                names.append(name)
             else:
-                # ако потребителят вече е добавял пълни колони — просто ги вземи
-                expected = ["Съставка","Грамаж (g)","Ккал","Белтъчини (g)","Въглехидрати (g)","Мазнини (g)"]
-                ok = all(c in manual_df.columns for c in expected)
-                manual_rows = manual_df[expected].values.tolist() if ok else []
+                names.append(line)
+
+        if not names:
+            df2, totals2 = recompute_df(df or EMPTY_TABLE.copy())
+            return df2, totals2["sum_kcal"], totals2["sum_p"], totals2["sum_c"], totals2["sum_f"]
+
+        add_df = await rows_from_names(names, float(grams_default))
+        for i, row in add_df.iterrows():
+            n = row["Съставка"]
+            if n in grams_map:
+                add_df.loc[i, "Грамаж (g)"] = grams_map[n]
+
+        merged = add_df if (df is None or df.empty) else pd.concat([df, add_df], ignore_index=True)
+        merged, totals = recompute_df(merged)
+        return merged, totals["sum_kcal"], totals["sum_p"], totals["sum_c"], totals["sum_f"]
     except Exception:
-        messages.append("⚠️ Някои ръчни редове бяха невалидни и са пропуснати.")
+        df2, totals2 = recompute_df(EMPTY_TABLE.copy())
+        return df2, totals2["sum_kcal"], totals2["sum_p"], totals2["sum_c"], totals2["sum_f"]
 
-    manual_out = pd.DataFrame(manual_rows, columns=EMPTY_DF.columns) if manual_rows else EMPTY_DF.copy()
+async def refresh_nutrients(df: pd.DataFrame):
+    """
+    Попълва ккал/100g и макроси/100g от OFF за редове, където липсват (0),
+    удобно след като промениш името на съставка.
+    """
+    try:
+        if df is None or df.empty:
+            return EMPTY_TABLE.copy(), 0.0, 0.0, 0.0, 0.0
+        df = df.copy()
+        for i, row in df.iterrows():
+            name = str(row.get("Съставка") or "").strip()
+            has_any = any([
+                float(row.get("ккал/100g") or 0),
+                float(row.get("Белтъчини/100g") or 0),
+                float(row.get("Въглехидрати/100g") or 0),
+                float(row.get("Мазнини/100g") or 0),
+            ])
+            if name and not has_any:
+                prod = await off_search_first(name)
+                vals = extract_kcal_macros_100((prod or {}).get("nutriments"))
+                df.loc[i, "ккал/100g"] = vals["kcal100"]
+                df.loc[i, "Белтъчини/100g"] = vals["p100"]
+                df.loc[i, "Въглехидрати/100g"] = vals["c100"]
+                df.loc[i, "Мазнини/100g"] = vals["f100"]
+        df2, totals = recompute_df(df)
+        return df2, totals["sum_kcal"], totals["sum_p"], totals["sum_c"], totals["sum_f"]
+    except Exception:
+        df2, totals2 = recompute_df(EMPTY_TABLE.copy())
+        return df2, totals2["sum_kcal"], totals2["sum_p"], totals2["sum_c"], totals2["sum_f"]
 
-    out_df = pd.concat([auto_df, manual_out], ignore_index=True) if not auto_df.empty or not manual_out.empty else EMPTY_DF.copy()
-    K,P,C,F = totals(out_df)
-    return out_df, K, P, C, F, ("\n".join(messages) if messages else "Готово.")
+async def recalc(df: pd.DataFrame):
+    """Пресмята от текущата таблица след ръчни редакции."""
+    try:
+        df2, totals = recompute_df(df)
+        return df2, totals["sum_kcal"], totals["sum_p"], totals["sum_c"], totals["sum_f"]
+    except Exception:
+        df2, totals2 = recompute_df(EMPTY_TABLE.copy())
+        return df2, totals2["sum_kcal"], totals2["sum_p"], totals2["sum_c"], totals2["sum_f"]
+
+async def suggest(term: str) -> List[str]:
+    try:
+        return await off_suggest(term)
+    except Exception:
+        return []
 
 # =========================
 # UI (BG)
 # =========================
-with gr.Blocks(title="Калории от снимка — Vision LLM + OFF") as demo:
+with gr.Blocks(title="CalorieCam — Ястие → Съставки (OFF only)") as demo:
     gr.Markdown(
-        "## 📸 Калории от снимка (Vision LLM) или ръчни съставки\n"
-        "• Използваме Vision LLM (LLaVA/Qwen2-VL) за **име на ястие + съставки** (EN), после смятаме нутриенти от **Open Food Facts**.\n"
-        "• Ако моделът е недостъпен/ограничен, просто ползвай таблицата отдолу — UI не се чупи."
+        "## 📸 CalorieCam — Разпознаване на ястие и съставки (Open Food Facts)\n"
+        "• Първо разпознаваме ястието; после извличаме съставки (zero-shot ако е налично, иначе правила/етикети).\n"
+        "• Таблицата е изцяло редактирана; добавяй редове, попълвай липсващи стойности от OFF и пресмятай."
     )
 
     with gr.Row():
         with gr.Column():
             img = gr.Image(type="pil", label="Снимка", height=320)
-            grams_default = gr.Slider(10, 300, value=100, step=10, label="Начален грамаж за автоматичните съставки (g)")
+            grams_default = gr.Slider(10, 300, value=100, step=10, label="Начален грамаж за всяка съставка (g)")
+            zsl_thresh = gr.Slider(0.05, 0.4, value=0.12, step=0.01, label="Праг за zero-shot (ако е наличен)")
+            zsl_topk = gr.Slider(1, 12, value=8, step=1, label="Максимум съставки от снимка")
+            analyze_btn = gr.Button("🔍 Анализирай снимката", variant="primary")
         with gr.Column():
-            info = gr.Textbox(label="Съобщения", lines=8)
-
-    gr.Markdown("### 🧾 Ръчни съставки (редактируема таблица)")
-    manual = gr.Dataframe(
-        headers=["Съставка","Грамаж (g)"],
-        datatype=["str","number"],
-        value=[["",0]],
-        row_count=(1,"dynamic"),
-        label="Добавяй редове тук (например: chicken breast, 150)"
+            info = gr.Textbox(label="Резюме", lines=10)
+
+    gr.Markdown("### 🧾 Таблица със съставки (редактируема)")
+    df = gr.Dataframe(
+        headers=["Съставка","Грамаж (g)","ккал/100g","Белтъчини/100g","Въглехидрати/100g","Мазнини/100g","ккал"],
+        value=EMPTY_TABLE.copy(),
+        row_count=(1, "dynamic"),
+        datatype=["str","number","number","number","number","number","number"],
+        interactive=True,
+        wrap=True,
+        label="Добавяй/редактирай редове тук"
     )
 
-    analyze_btn = gr.Button("🔍 Анализирай", variant="primary")
+    gr.Markdown("#### ➕ Бързо добавяне (по един ред: `име[, грамаж]`)")
+    with gr.Row():
+        quick = gr.Textbox(label="Списък със съставки", placeholder="rice, 150\negg, 60\nolive oil, 10")
+        quick_btn = gr.Button("➕ Добави към таблицата")
+    with gr.Row():
+        add_term = gr.Textbox(label="Автодопълване (OFF)", placeholder="chicken breast / домати")
+        add_choices = gr.Dropdown(label="Предложения", choices=[], interactive=True)
+        add_apply = gr.Button("Добави избраната")
 
-    out_df = gr.Dataframe(label="Детайли по съставки", interactive=True, wrap=True)
-    total_kcal = gr.Number(label="Общо ккал", value=0.0, precision=1)
-    total_p = gr.Number(label="Общо белтъчини (g)", value=0.0, precision=1)
-    total_c = gr.Number(label="Общо въглехидрати (g)", value=0.0, precision=1)
-    total_f = gr.Number(label="Общо мазнини (g)", value=0.0, precision=1)
+    with gr.Row():
+        fill_btn = gr.Button("🧪 Попълни липсващи нутриенти от OFF (по името)")
+        recalc_btn = gr.Button("🧮 Пресметни калориите от таблицата")
+    with gr.Row():
+        total_kcal = gr.Number(label="Общо ккал", value=0.0, precision=1)
+        total_p = gr.Number(label="Общо белтъчини (g)", value=0.0, precision=1)
+        total_c = gr.Number(label="Общо въглехидрати (g)", value=0.0, precision=1)
+        total_f = gr.Number(label="Общо мазнини (g)", value=0.0, precision=1)
 
+    # Свързване
     analyze_btn.click(
-        analyze,
-        inputs=[img, grams_default, manual],
-        outputs=[out_df, total_kcal, total_p, total_c, total_f, info]
+        analyze_photo,
+        inputs=[img, grams_default, zsl_thresh, zsl_topk],
+        outputs=[info, df, total_kcal, total_p, total_c, total_f]
     )
 
+    quick_btn.click(
+        apply_names,
+        inputs=[quick, df, grams_default],
+        outputs=[df, total_kcal, total_p, total_c, total_f]
+    )
+
+    add_term.change(suggest, inputs=[add_term], outputs=[add_choices])
+
+    def _add_choice(current_df: pd.DataFrame, term: str, choice: str, grams_default: int):
+        name = (choice or term or "").strip()
+        if not name:
+            return current_df or EMPTY_TABLE.copy()
+        if current_df is None or current_df.empty:
+            current_df = EMPTY_TABLE.copy()
+        new_row = pd.DataFrame([[name, float(grams_default), 0.0, 0.0, 0.0, 0.0, 0.0]], columns=current_df.columns)
+        merged = pd.concat([current_df, new_row], ignore_index=True)
+        merged, _ = recompute_df(merged)
+        return merged
+
+    add_apply.click(_add_choice, inputs=[df, add_term, add_choices, grams_default], outputs=[df])
+
+    fill_btn.click(refresh_nutrients, inputs=[df], outputs=[df, total_kcal, total_p, total_c, total_f])
+    recalc_btn.click(recalc, inputs=[df], outputs=[df, total_kcal, total_p, total_c, total_f])
+
 demo.queue()
 
 if __name__ == "__main__":