Update app.py

app.py

@@ -178,7 +178,15 @@ def _run_inference(image: Image.Image, max_new_tokens: int) -> str:
             "role": "user",
             "content": [
                 {"type": "image"},
-                {"type": "text", "text": "Analyze this food image for ingredients and calories."},
+                {
+                    "type": "text",
+                    "text": (
+                        "Look at this food photo and tell me: "
+                        "1) What food or dish do you see? "
+                        "2) List all visible ingredients. "
+                        "Start your answer with: 'Ingredients detected:'"
+                    ),
+                },
             ],
         }
     ]
@@ -193,9 +201,7 @@ def _run_inference(image: Image.Image, max_new_tokens: int) -> str:
     )
     device = next(_model.parameters()).device
     if "pixel_values" in inputs and inputs["pixel_values"] is not None:
-        inputs["pixel_values"] = inputs["pixel_values"].to(
-            torch.bfloat16 if torch.cuda.is_available() else torch.float32
-        )
+        inputs["pixel_values"] = inputs["pixel_values"].to(torch.float32)
     inputs = {k: v.to(device) for k, v in inputs.items()}
 
     with torch.inference_mode():
@@ -210,39 +216,65 @@ def _run_inference(image: Image.Image, max_new_tokens: int) -> str:
     return _processor.batch_decode(new_tokens, skip_special_tokens=True)[0].strip()
 
 
+def _get_nutrition_from_api(ingredients_text: str) -> dict:
+    """Nutrition lookup — Open Food Facts + hardcoded fallback table."""
+
+    # ── Hardcoded fallback for 30 common foods ─────────────────────────────
+    NUTRITION_TABLE = {
+        "banana":      {"calories": 89,  "protein_g": 1.1, "carbs_g": 23.0, "fat_g": 0.3, "fibre_g": 2.6},
+        "apple":       {"calories": 72,  "protein_g": 0.4, "carbs_g": 19.0, "fat_g": 0.2, "fibre_g": 2.4},
+        "orange":      {"calories": 62,  "protein_g": 1.2, "carbs_g": 15.4, "fat_g": 0.2, "fibre_g": 3.1},
+        "mango":       {"calories": 99,  "protein_g": 1.4, "carbs_g": 25.0, "fat_g": 0.6, "fibre_g": 2.6},
+        "grape":       {"calories": 69,  "protein_g": 0.7, "carbs_g": 18.1, "fat_g": 0.2, "fibre_g": 0.9},
+        "strawberry":  {"calories": 32,  "protein_g": 0.7, "carbs_g": 7.7,  "fat_g": 0.3, "fibre_g": 2.0},
+        "watermelon":  {"calories": 30,  "protein_g": 0.6, "carbs_g": 7.6,  "fat_g": 0.2, "fibre_g": 0.4},
+        "rice":        {"calories": 206, "protein_g": 4.3, "carbs_g": 45.0, "fat_g": 0.4, "fibre_g": 0.6},
+        "chicken":     {"calories": 239, "protein_g": 27.0,"carbs_g": 0.0,  "fat_g": 14.0,"fibre_g": 0.0},
+        "egg":         {"calories": 155, "protein_g": 13.0,"carbs_g": 1.1,  "fat_g": 11.0,"fibre_g": 0.0},
+        "bread":       {"calories": 265, "protein_g": 9.0, "carbs_g": 49.0, "fat_g": 3.2, "fibre_g": 2.7},
+        "milk":        {"calories": 61,  "protein_g": 3.2, "carbs_g": 4.8,  "fat_g": 3.3, "fibre_g": 0.0},
+        "cheese":      {"calories": 402, "protein_g": 25.0,"carbs_g": 1.3,  "fat_g": 33.0,"fibre_g": 0.0},
+        "pizza":       {"calories": 266, "protein_g": 11.0,"carbs_g": 33.0, "fat_g": 10.0,"fibre_g": 2.3},
+        "burger":      {"calories": 295, "protein_g": 17.0,"carbs_g": 24.0, "fat_g": 14.0,"fibre_g": 1.3},
+        "pasta":       {"calories": 220, "protein_g": 8.1, "carbs_g": 43.0, "fat_g": 1.3, "fibre_g": 2.5},
+        "fish":        {"calories": 136, "protein_g": 20.0,"carbs_g": 0.0,  "fat_g": 6.0, "fibre_g": 0.0},
+        "potato":      {"calories": 77,  "protein_g": 2.0, "carbs_g": 17.0, "fat_g": 0.1, "fibre_g": 2.2},
+        "broccoli":    {"calories": 34,  "protein_g": 2.8, "carbs_g": 6.6,  "fat_g": 0.4, "fibre_g": 2.6},
+        "carrot":      {"calories": 41,  "protein_g": 0.9, "carbs_g": 10.0, "fat_g": 0.2, "fibre_g": 2.8},
+        "tomato":      {"calories": 18,  "protein_g": 0.9, "carbs_g": 3.9,  "fat_g": 0.2, "fibre_g": 1.2},
+        "salad":       {"calories": 20,  "protein_g": 1.8, "carbs_g": 3.6,  "fat_g": 0.3, "fibre_g": 2.0},
+        "sandwich":    {"calories": 250, "protein_g": 12.0,"carbs_g": 33.0, "fat_g": 7.0, "fibre_g": 2.5},
+        "soup":        {"calories": 71,  "protein_g": 3.8, "carbs_g": 8.0,  "fat_g": 2.0, "fibre_g": 1.5},
+        "chocolate":   {"calories": 546, "protein_g": 5.0, "carbs_g": 60.0, "fat_g": 31.0,"fibre_g": 7.0},
+        "cake":        {"calories": 347, "protein_g": 5.0, "carbs_g": 55.0, "fat_g": 12.0,"fibre_g": 1.0},
+        "dal":         {"calories": 116, "protein_g": 9.0, "carbs_g": 20.0, "fat_g": 0.4, "fibre_g": 8.0},
+        "roti":        {"calories": 297, "protein_g": 9.9, "carbs_g": 61.0, "fat_g": 1.7, "fibre_g": 1.9},
+        "biryani":     {"calories": 200, "protein_g": 8.0, "carbs_g": 30.0, "fat_g": 6.0, "fibre_g": 1.5},
+        "paneer":      {"calories": 265, "protein_g": 18.0,"carbs_g": 3.4,  "fat_g": 20.0,"fibre_g": 0.0},
+        "idli":        {"calories": 58,  "protein_g": 2.0, "carbs_g": 12.0, "fat_g": 0.4, "fibre_g": 0.5},
+        "dosa":        {"calories": 168, "protein_g": 3.7, "carbs_g": 30.0, "fat_g": 3.7, "fibre_g": 1.5},
+        "samosa":      {"calories": 262, "protein_g": 3.5, "carbs_g": 28.0, "fat_g": 15.0,"fibre_g": 2.0},
+        "noodle":      {"calories": 138, "protein_g": 4.5, "carbs_g": 25.0, "fat_g": 2.0, "fibre_g": 1.8},
+        "coffee":      {"calories": 2,   "protein_g": 0.3, "carbs_g": 0.0,  "fat_g": 0.0, "fibre_g": 0.0},
+        "omelette":    {"calories": 154, "protein_g": 11.0,"carbs_g": 0.4,  "fat_g": 12.0,"fibre_g": 0.0},
+        "yogurt":      {"calories": 59,  "protein_g": 10.0,"carbs_g": 3.6,  "fat_g": 0.4, "fibre_g": 0.0},
+    }
 
+    text_lower = ingredients_text.lower()
 
-def _get_nutrition_from_api(ingredients_text: str) -> dict:
+    # ── Step 1: Try Open Food Facts API ───────────────────────────────────
     try:
-        # Extract the most important food word from the description
-        import re
-        # Common food words to search for
-        food_keywords = [
-            "banana", "apple", "orange", "mango", "rice", "chicken", "egg",
-            "bread", "milk", "yogurt", "cheese", "pizza", "burger", "salad",
-            "pasta", "fish", "beef", "pork", "potato", "tomato", "onion",
-            "carrot", "broccoli", "spinach", "lemon", "grape", "strawberry",
-            "chocolate", "cake", "cookie", "coffee", "tea", "juice", "soup",
-            "sandwich", "taco", "noodle", "tofu", "paneer", "dal", "roti",
-            "biryani", "curry", "samosa", "idli", "dosa"
-        ]
-        
-        text_lower = ingredients_text.lower()
+        import re as _re
         food_query = None
-        
-        # Find first matching food keyword
-        for keyword in food_keywords:
+        for keyword in NUTRITION_TABLE.keys():
             if keyword in text_lower:
                 food_query = keyword
                 break
-        
-        # If no keyword matched, use first 2 words of description
         if not food_query:
-            words = re.findall(r'\b[a-zA-Z]{4,}\b', ingredients_text)
+            words = _re.findall(r'\b[a-zA-Z]{4,}\b', ingredients_text)
             food_query = words[0] if words else ingredients_text[:20]
 
-        logger.info(f"Searching nutrition for: {food_query}")
-
+        logger.info(f"OpenFoodFacts query: {food_query}")
         response = req_lib.get(
             "https://world.openfoodfacts.org/cgi/search.pl",
             params={
@@ -250,62 +282,66 @@ def _get_nutrition_from_api(ingredients_text: str) -> dict:
                 "search_simple": 1,
                 "action": "process",
                 "json": 1,
-                "page_size": 3,
+                "page_size": 5,
                 "fields": "product_name,nutriments",
             },
-            timeout=10,
+            timeout=8,
         )
         response.raise_for_status()
-        data     = response.json()
-        products = data.get("products", [])
-
-        if not products:
-            logger.warning(f"No products found for: {food_query}")
-            return {}
+        products = response.json().get("products", [])
 
-        # Find first product with complete nutrition data
         for product in products:
-            nutriments = product.get("nutriments", {})
-            calories   = nutriments.get("energy-kcal_100g", 0)
-            if calories and calories > 0:
+            n   = product.get("nutriments", {})
+            cal = n.get("energy-kcal_100g") or n.get("energy-kcal") or 0
+            try:
+                cal = float(cal)
+            except (TypeError, ValueError):
+                cal = 0
+            if cal > 0:
+                logger.info(f"OpenFoodFacts found: {product.get('product_name')} = {cal} kcal")
                 return {
-                    "calories":  round(float(calories), 1),
-                    "protein_g": round(float(nutriments.get("proteins_100g",        0) or 0), 1),
-                    "carbs_g":   round(float(nutriments.get("carbohydrates_100g",   0) or 0), 1),
-                    "fat_g":     round(float(nutriments.get("fat_100g",             0) or 0), 1),
-                    "fibre_g":   round(float(nutriments.get("fiber_100g",           0) or 0), 1),
+                    "calories":  round(cal, 1),
+                    "protein_g": round(float(n.get("proteins_100g",      0) or 0), 1),
+                    "carbs_g":   round(float(n.get("carbohydrates_100g", 0) or 0), 1),
+                    "fat_g":     round(float(n.get("fat_100g",           0) or 0), 1),
+                    "fibre_g":   round(float(n.get("fiber_100g",         0) or 0), 1),
                 }
-
-        return {}
-
     except Exception as e:
-        logger.warning(f"Nutrition API failed: {e}")
-        return {}
+        logger.warning(f"OpenFoodFacts failed: {e}")
 
+    # ── Step 2: Hardcoded table fallback ──────────────────────────────────
+    for food, values in NUTRITION_TABLE.items():
+        if food in text_lower:
+            logger.info(f"Using hardcoded nutrition for: {food}")
+            return values
+
+    logger.warning("No nutrition data found from any source")
+    return {}
 
 
 def _parse_response(raw: str) -> dict:
-    # FIX: pre-initialize all nutrition keys to None so KeyError never happens
     result = {
-        "ingredients":  "",
+        "ingredients":   "",
         "portion_notes": "",
-        "raw_text":     raw,
-        "calories":     None,   # ← these were missing
-        "protein_g":    None,
-        "carbs_g":      None,
-        "fat_g":        None,
-        "fibre_g":      None,
+        "raw_text":      raw,
+        "calories":      None,
+        "protein_g":     None,
+        "carbs_g":       None,
+        "fat_g":         None,
+        "fibre_g":       None,
     }
 
-    # Try structured CaLoRAify format first
+    # Try structured format
     if "Ingredients detected:" in raw:
         ing_start = raw.index("Ingredients detected:") + len("Ingredients detected:")
-        ing_end   = raw.index(".", ing_start) if "." in raw[ing_start:] else len(raw)
+        ing_end   = raw.find(".", ing_start)
+        ing_end   = ing_end if ing_end != -1 else len(raw)
         result["ingredients"] = raw[ing_start:ing_end].strip()
 
     if "Portion Analysis:" in raw:
         pa_start = raw.index("Portion Analysis:") + len("Portion Analysis:")
-        pa_end   = raw.index(".", pa_start) if "." in raw[pa_start:] else len(raw)
+        pa_end   = raw.find(".", pa_start)
+        pa_end   = pa_end if pa_end != -1 else len(raw)
         result["portion_notes"] = raw[pa_start:pa_end].strip()
 
     if "JSON Summary:" in raw:
@@ -326,21 +362,20 @@ def _parse_response(raw: str) -> dict:
             except json.JSONDecodeError:
                 pass
 
-    # Fallback: model gave plain description
+    # Fallback: use entire raw text as ingredient description
     if not result["ingredients"]:
-        result["ingredients"]   = raw.strip()[:200]
+        result["ingredients"]   = raw.strip()[:300]
         result["portion_notes"] = "Portion estimated from image."
 
-    # If no calories yet, call Nutritionix/OpenFoodFacts
+    # Call nutrition API if no calories yet
     if result["calories"] is None and result["ingredients"]:
-        logger.info(f"Calling nutrition API for: {result['ingredients'][:80]}")
+        logger.info(f"Looking up nutrition for: {result['ingredients'][:80]}")
         nutrition = _get_nutrition_from_api(result["ingredients"])
         if nutrition:
             result.update(nutrition)
 
     return result
 
-
 # ── Endpoints ─────────────────────────────────────────────────────────────────
 @app.get("/health")
 def health():