Update app.py

app.py

@@ -1,50 +1,62 @@
 import gradio as gr
 import cv2
 import numpy as np
-import requests
 from PIL import Image
-from autogen import AssistantAgent, GroupChat, GroupChatManager
+from ultralytics import YOLO
+import requests
 import os
 import time
-#import openai
-from ultralytics import YOLO
+from autogen import AssistantAgent, GroupChat, GroupChatManager
 
+# Initialize YOLOv8 for multi-label food detection
 model = YOLO("yolov8n.pt")  # Nano model for speed, fine-tune on food data later
 
-# Agent Functions
+# Agent Functions (registered with AutoGen)
 def recognize_foods(image):
     start = time.time()
-    # Resize to 640x640 (YOLO default)
+    # Check if image is valid (not all 255s or empty)
+    if image is None or np.all(image == 255):
+        print("Warning: Invalid or empty image detected.")
+        return []  # Return empty list for invalid images
+    # Resize to 640x640 (YOLO default) to reduce load and match model input
     pil_image = Image.fromarray(image).resize((640, 640))
     results = model(pil_image)
     foods = []
     for result in results:
         for cls in result.boxes.cls:
             label = model.names[int(cls)]
-            if "food" in label.lower() or label in ["pasta", "rice", "tomato", "potato", "bread"]:  # Expand this list
+            if "food" in label.lower() or label in ["pasta", "rice", "tomato", "potato", "bread", "curry"]:  # Expand this list
                 conf = result.boxes.conf[result.boxes.cls == cls].item()
                 foods.append((label, conf))
-    print(f"Recognition took {time.time() - start:.2f}s")
+    print(f"Recognition took {time.time() - start:.2f}s: Found foods {foods}")
     return list(set(foods))  # Remove duplicates
 
 def estimate_sizes(image, foods):
     start = time.time()
-    img_cv = cv2.cvtColor(image, cv2.COLOR_RGB2BGR).resize((640, 640))  # Match YOLO size
+    if not foods:
+        print("Warning: No foods to estimate sizes for.")
+        return {}
+    # Resize to match YOLO output for consistency
+    img_cv = cv2.cvtColor(image, cv2.COLOR_RGB2BGR).resize((640, 640))
     sizes = {}
     total_area = img_cv.shape[0] * img_cv.shape[1]
     for food, _ in foods:
-        # Dummy: assume area proportion (refine with food-specific weights later)
+        # Dummy: assume area proportion (refine with food-specific weights or bounding boxes later)
         area = total_area / len(foods)  # Even split for now
-        grams = min(500, int(area / (640 * 640) * 100))  # 100g per ~640k pixels
+        grams = min(500, int(area / (640 * 640) * 100))  # 100g per ~640k pixels, capped at 500g
         sizes[food] = grams
-    print(f"Size estimation took {time.time() - start:.2f}s")
+    print(f"Size estimation took {time.time() - start:.2f}s: Estimated sizes {sizes}")
     return sizes
 
 def fetch_nutrition(foods_with_sizes, nutritionix_key):
+    start = time.time()
     if not nutritionix_key:
+        print("Warning: No Nutritionix API key provided.")
         return "Please provide a Nutritionix API key for nutrition data."
+    if not foods_with_sizes:
+        print("Warning: No foods to fetch nutrition for.")
+        return {}
     
-    start = time.time()
     url = "https://trackapi.nutritionix.com/v2/natural/nutrients"
     headers = {
         "x-app-id": os.getenv("NUTRITIONIX_APP_ID"),  # From HF Secrets
@@ -58,6 +70,7 @@ def fetch_nutrition(foods_with_sizes, nutritionix_key):
     try:
         response = requests.post(url, headers=headers, json=body, timeout=10)
         if response.status_code != 200:
+            print(f"Nutritionix API error: {response.text}")
             return f"Nutritionix API error: {response.text}"
         
         data = response.json().get("foods", [])
@@ -70,78 +83,56 @@ def fetch_nutrition(foods_with_sizes, nutritionix_key):
                 "fat": item.get("nf_total_fat", 0),
                 "carbs": item.get("nf_total_carbohydrate", 0)
             }
-        print(f"Nutrition fetch took {time.time() - start:.2f}s")
+        print(f"Nutrition fetch took {time.time() - start:.2f}s: Fetched nutrition {nutrition_data}")
         return nutrition_data
     except requests.Timeout:
+        print("Nutritionix API timed out.")
         return "Nutritionix API timed out."
     except Exception as e:
+        print(f"Nutritionix error: {str(e)}")
         return f"Nutritionix error: {str(e)}"
 
-#def get_nutrition_advice(nutrition_data, llm_key):
-#    if not llm_key:
-#        return "No OpenAI/Grok key provided—skipping advice."
-#    try:
-#        openai.api_key = llm_key
-#        prompt = "Given this nutritional data, suggest a dietary tip:\n"
-#        for food, data in nutrition_data.items():
-#            prompt += f"- {food}: {data['calories']} cal, {data['protein']}g protein, {data['fat']}g fat, {data['carbs']}g carbs\n"
-#        
-#        response = openai.Completion.create(
-#            model="text-davinci-003",  # Swap for Grok if xAI API is available
-#            prompt=prompt,
-#            max_tokens=50
-#        )
-#        return response.choices[0].text.strip()
-#    except Exception as e:
-#        return f"Error with LLM key: {str(e)}"
-
-
 # AutoGen Agent Definitions
 food_recognizer = AssistantAgent(
     name="FoodRecognizer",
-    system_message="Identify all food items in the image and return a list of (label, probability) pairs.",
+    system_message="Identify all food items in the image and return a list of (label, probability) pairs. Call recognize_foods with the image.",
     function_map={"recognize_foods": recognize_foods}
 )
 
 size_estimator = AssistantAgent(
     name="SizeEstimator",
-    system_message="Estimate portion sizes in grams for each recognized food based on the image.",
+    system_message="Estimate portion sizes in grams for each recognized food based on the image. Call estimate_sizes with the image and list of foods.",
     function_map={"estimate_sizes": estimate_sizes}
 )
 
 nutrition_fetcher = AssistantAgent(
     name="NutritionFetcher",
-    system_message="Fetch nutritional data from the Nutritionix API using the user's key.",
+    system_message="Fetch nutritional data from the Nutritionix API using the user's key. Call fetch_nutrition with the foods and sizes dictionary and Nutritionix key.",
     function_map={"fetch_nutrition": fetch_nutrition}
 )
 
-##advice_agent = AssistantAgent(
-##    name="NutritionAdvisor",
-##    system_message="Provide basic nutrition advice using the user's OpenAI/Grok key."
-##)
-
 orchestrator = AssistantAgent(
     name="Orchestrator",
-    system_message="Coordinate the workflow, format the output, and return the final result as text.",
+    system_message="Coordinate the workflow, format the output, and return the final result as text. Start by asking FoodRecognizer to process the image, then SizeEstimator, then NutritionFetcher, and finally format the results.",
     function_map={}
 )
 
-# Custom speaker selection function (no LLM needed)
+# Custom speaker selection function (no LLM needed, updated for AutoGen 0.7.6)
 def custom_select_speaker(last_speaker, groupchat):
     """Select the next speaker in a fixed order: FoodRecognizer → SizeEstimator → NutritionFetcher → Orchestrator."""
     if last_speaker is None:
-        return "FoodRecognizer"  # Start with FoodRecognizer
+        return food_recognizer  # Return the Agent object, not the name
     order = [food_recognizer, size_estimator, nutrition_fetcher, orchestrator]
     current_index = order.index(last_speaker)
     next_index = (current_index + 1) % len(order)
     return order[next_index]
 
-# Group Chat for Agent Coordination (no LLM, custom speaker selection)
+# Group Chat for Agent Coordination (no LLM, custom speaker selection method)
 group_chat = GroupChat(
     agents=[food_recognizer, size_estimator, nutrition_fetcher, orchestrator],
     messages=[],
-    max_round=4,
-    speaker_selection_method=custom_select_speaker  # Use custom speaker selection instead of LLM
+    max_round=4,  # Limit rounds to match agent order
+    speaker_selection_method=custom_select_speaker  # Use correct parameter for AutoGen 0.7.6
 )
 manager = GroupChatManager(groupchat=group_chat)
 
@@ -157,7 +148,7 @@ def orchestrate_workflow(image, nutritionix_key):
         max_turns=10
     )
     
-# Extract and format the final response from the ChatResult
+    # Extract and format the final response from the ChatResult
     if hasattr(response, 'chat_history') and response.chat_history:
         # Get the last message from chat history
         last_message = response.chat_history[-1]
@@ -169,21 +160,19 @@ def orchestrate_workflow(image, nutritionix_key):
         result = result.get("text", "No text output from agents.")
     print(f"Total time: {time.time() - start:.2f}s")
     return result
-    
+
 # Gradio Interface
 interface = gr.Interface(
     fn=orchestrate_workflow,
     inputs=[
         gr.Image(type="numpy", label="Upload a Food Photo"),
-        gr.Textbox(type="password", label="Your Nutritionix API Key (required)"),
-        #gr.Textbox(type="password", label="Your OpenAI/Grok API Key (optional for advice)")
+        gr.Textbox(type="password", label="Your Nutritionix API Key (required)")
     ],
     outputs=[
-        gr.Textbox(label="Nutrition Breakdown"),
-        #gr.Textbox(label="Nutrition Advice")
+        gr.Textbox(label="Nutrition Breakdown")
     ],
     title="Food Nutrition Analyzer",
-    description="Upload a food photo and provide your Nutritionix API key. Add an OpenAI/Grok key for advice."
+    description="Upload a food photo and provide your Nutritionix API key for nutrition data."
 )
 
 if __name__ == "__main__":