Update app.py

app.py

@@ -33,27 +33,130 @@ except:
 # Load environment variables
 load_dotenv()
 
-# Mistral API Key
-MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY", "GlrVCBWyvTYjWGKl5jqtK4K41uWWJ79F")
+# API Keys
+MISTRAL_API_KEY = "GlrVCBWyvTYjWGKl5jqtK4K41uWWJ79F"
+META_LLAMA_API_KEY = "22068836-e455-47e7-8293-373f9e4c84fb"  # Updated API key
 
-# OpenAI API Key for Product Identification
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "sk-exampleapikey") # Replace with your actual OpenAI API key
+# Meta LLaMA API for ingredient extraction from product names/images
+def extract_ingredients_with_llama(image=None, product_name=None):
+    """
+    Use Meta's LLaMA API to extract ingredients from a product image or name
+    """
+    if not image and not product_name:
+        return "No product information provided. Please provide an image or product name."
+
+    # Prepare API call to Meta LLaMA
+    headers = {
+        "Authorization": f"Bearer {META_LLAMA_API_KEY}",
+        "Content-Type": "application/json"
+    }
+
+    # Create prompt based on what's provided
+    if image:
+        # Convert image to base64 for API
+        import base64
+        from io import BytesIO
+
+        buffered = BytesIO()
+        image.save(buffered, format="JPEG")
+        img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
+
+        prompt = [
+            {"role": "system", "content": "You are an expert at identifying food products and their ingredients from images. Extract the product name and list all ingredients you can identify."},
+            {"role": "user", "content": [
+                {"type": "text", "text": "Look at this food product image and list all the ingredients it contains. If you can identify the product name, mention that first, then list all ingredients in a comma-separated format."},
+                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img_str}"}}
+            ]}
+        ]
+    else:
+        # Product name provided
+        prompt = [
+            {"role": "system", "content": "You are an expert at identifying food product ingredients. Your task is to list all common ingredients for the specified product."},
+            {"role": "user", "content": f"Please list all the common ingredients typically found in {product_name}. Provide the ingredients in a comma-separated format."}
+        ]
+
+    # Call Meta LLaMA API
+    try:
+        data = {
+            "model": "meta-llama/Llama-3-8b-hf",  # Use an appropriate model
+            "messages": prompt,
+            "temperature": 0.2,  # Lower temperature for more factual responses
+            "max_tokens": 800
+        }
+
+        # Add logging for debugging
+        print(f"Sending request to LLaMA API with data structure: {json.dumps(data)[:300]}...")
+        
+        response = requests.post(
+            "https://api.llama-api.com/chat/completions",  # Replace with correct endpoint if different
+            headers=headers,
+            json=data,
+            timeout=30  # Add timeout to prevent hanging
+        )
+
+        if response.status_code == 200:
+            text_response = response.json()['choices'][0]['message']['content']
+            print(f"LLaMA API response received: {text_response[:100]}...")
+
+            # Extract ingredients from the response
+            # Look for a list of ingredients following common patterns
+            ingredients_section = re.search(r'ingredients:?\s*([^\.]+)', text_response, re.IGNORECASE)
+            if ingredients_section:
+                ingredients_text = ingredients_section.group(1)
+            else:
+                # If no explicit "ingredients:" section, try to identify comma-separated lists
+                # and take the longest one as it's likely to be the ingredients list
+                comma_lists = re.findall(r'([^\.;:]+(?:,\s*[^\.;:]+){2,})', text_response)
+                if comma_lists:
+                    ingredients_text = max(comma_lists, key=len)
+                else:
+                    ingredients_text = text_response  # Use full response if no list found
+
+            # Parse the ingredients
+            ingredients = parse_ingredients(ingredients_text)
+
+            # Extract product name if possible
+            product_match = re.search(r'product(?:\s+name)?(?:\s+is)?:?\s*([^\.;,\n]+)', text_response, re.IGNORECASE)
+            if product_match:
+                product_name = product_match.group(1).strip()
+                return ingredients, product_name
 
-# Import and configure Mistral API
-def analyze_ingredients_with_mistral(ingredients_list, health_conditions=None):
+            return ingredients, None
+
+        else:
+            print(f"Error response from LLaMA API: {response.status_code} - {response.text}")
+            # Fall back to dummy analysis on error
+            return f"Error calling Meta LLaMA API: {response.status_code} - {response.text}", None
+
+    except Exception as e:
+        print(f"Exception in LLaMA API call: {str(e)}")
+        return f"Error extracting ingredients with LLaMA: {str(e)}", None
+
+# Mistral API for ingredient analysis
+def analyze_ingredients_with_mistral(ingredients_list, health_conditions=None, product_name=None):
     """
     Use Mistral AI to analyze ingredients and provide health insights.
     """
-    if not ingredients_list:
+    if not ingredients_list or (isinstance(ingredients_list, list) and len(ingredients_list) == 0):
         return "No ingredients detected or provided."
 
-    # Prepare the list of ingredients for the prompt
-    ingredients_text = ", ".join(ingredients_list)
+    # Handle error messages that might have been passed
+    if isinstance(ingredients_list, str) and "Error" in ingredients_list:
+        # Fall back to dummy analysis if there was an error
+        return dummy_analyze(product_name if product_name else "Unknown product", health_conditions)
+
+    # Convert to string if it's a list
+    if isinstance(ingredients_list, list):
+        ingredients_text = ", ".join(ingredients_list)
+    else:
+        ingredients_text = ingredients_list
 
     # Create a prompt for Mistral
+    product_info = f"Product Name: {product_name}\n" if product_name else ""
+
     if health_conditions and health_conditions.strip():
         prompt = f"""
-        Analyze the following food ingredients for a person with these health conditions: {health_conditions}
+        {product_info}Analyze the following food ingredients for a person with these health conditions: {health_conditions}
         Ingredients: {ingredients_text}
         For each ingredient:
         1. Provide its potential health benefits
@@ -64,7 +167,7 @@ def analyze_ingredients_with_mistral(ingredients_list, health_conditions=None):
         """
     else:
         prompt = f"""
-        Analyze the following food ingredients:
+        {product_info}Analyze the following food ingredients:
         Ingredients: {ingredients_text}
         For each ingredient:
         1. Provide its potential health benefits
@@ -84,12 +187,18 @@ def analyze_ingredients_with_mistral(ingredients_list, health_conditions=None):
             "temperature": 0.7,
         }
 
-        response = requests.post("https://api.mistral.ai/v1/chat/completions", headers=headers, json=data)
+        response = requests.post(
+            "https://api.mistral.ai/v1/chat/completions", 
+            headers=headers, 
+            json=data,
+            timeout=30
+        )
 
         if response.status_code == 200:
             analysis = response.json()['choices'][0]['message']['content']
         else:
-            return dummy_analyze(ingredients_list, health_conditions) + f"\n\n(Using fallback analysis: Mistral API Error - {response.status_code} - {response.text})"
+            print(f"Error response from Mistral API: {response.status_code} - {response.text}")
+            return dummy_analyze(ingredients_list if isinstance(ingredients_list, list) else [ingredients_text], health_conditions) + f"\n\n(Using fallback analysis: Mistral API Error - {response.status_code} - {response.text})"
 
         # Add disclaimer
         disclaimer = """
@@ -101,21 +210,25 @@ def analyze_ingredients_with_mistral(ingredients_list, health_conditions=None):
         return analysis + disclaimer
 
     except Exception as e:
+        print(f"Exception in Mistral API call: {str(e)}")
         # Fallback to basic analysis if API call fails
-        return dummy_analyze(ingredients_list, health_conditions) + f"\n\n(Using fallback analysis: {str(e)})"
+        return dummy_analyze(ingredients_list if isinstance(ingredients_list, list) else [ingredients_text], health_conditions) + f"\n\n(Using fallback analysis: {str(e)})"
 
 
 # Dummy analysis function for when API is not available
 def dummy_analyze(ingredients_list, health_conditions=None):
-    ingredients_text = ", ".join(ingredients_list)
+    if isinstance(ingredients_list, str):
+        ingredients_text = ingredients_list
+    else:
+        ingredients_text = ", ".join(ingredients_list)
 
     report = f"""
     # Ingredient Analysis Report
     ## Detected Ingredients
-    {", ".join([i.title() for i in ingredients_list])}
+    {", ".join([i.title() for i in ingredients_list]) if isinstance(ingredients_list, list) else ingredients_text}
     ## Overview
-    This is a simulated analysis since the Mistral API call failed. In the actual application,
-    the ingredients would be analyzed by Mistral for their health implications.
+    This is a simulated analysis since the API call failed. In the actual application,
+    the ingredients would be analyzed by an AI model for their health implications.
     ## Health Considerations
     """
 
@@ -283,127 +396,99 @@ def parse_ingredients(text):
 
     return cleaned_ingredients
 
-def identify_product_and_get_ingredients(image):
-    """
-    Identifies the product from the image using OpenAI and retrieves ingredients.
-    """
-    try:
-        # Encode the image to base64
-        buffered = io.BytesIO()
-        image.save(buffered, format="JPEG")
-        img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
 
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {OPENAI_API_KEY}"
-        }
+# Function to process input based on method (camera, product photo, or product name)
+def process_input(input_method, product_name, camera_input, product_photo, health_conditions):
+    if input_method == "Product Photo":
+        if product_photo is not None:
+            # Use Meta LLaMA to extract ingredients from product photo
+            ingredients, detected_product = extract_ingredients_with_llama(image=product_photo)
 
-        payload = {
-            "model": "gpt-4-vision-preview",
-            "messages": [
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": "Identify the food product in this image.  If identifiable, also find its ingredients."
-                        },
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:image/jpeg;base64,{img_str}"
-                            }
-                        }
-                    ]
-                }
-            ],
-            "max_tokens": 500
-        }
-
-        response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)
-        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
+            # If error occurred, use fallback analysis
+            if isinstance(ingredients, str) and "Error" in ingredients:
+                print(f"LLaMA API error, using fallback: {ingredients}")
+                return f"Error extracting ingredients. Using fallback analysis.\n\n{dummy_analyze('Unknown food product', health_conditions)}"
 
-        data = response.json()
-        response_text = data['choices'][0]['message']['content']
+            # Add product name info if detected
+            product_info = ""
+            if detected_product:
+                product_info = f"## Product: {detected_product}\n\n"
 
-        # Attempt to extract ingredients from the response
-        ingredients_match = re.search(r"Ingredients:\s*(.+)", response_text, re.IGNORECASE)
-        if ingredients_match:
-            ingredients_text = ingredients_match.group(1)
-            ingredients = parse_ingredients(ingredients_text)
-            return ingredients, response_text
+            # Analyze ingredients
+            analysis = analyze_ingredients_with_mistral(ingredients, health_conditions, detected_product)
+            return product_info + analysis
         else:
-            # If ingredients not found, return the full response for further handling
-            return None, response_text
+            return "No product image captured. Please try again."
 
-    except requests.exceptions.RequestException as e:
-        return None, f"Error during OpenAI API request: {e}"
-    except json.JSONDecodeError as e:
-        return None, f"Error decoding JSON response from OpenAI: {e}"
-    except Exception as e:
-        return None, f"Error identifying product: {e}"
+    elif input_method == "Product Name":
+        if product_name and product_name.strip():
+            # Use Meta LLaMA to extract ingredients based on product name
+            ingredients, _ = extract_ingredients_with_llama(product_name=product_name)
+
+            # If error occurred, use fallback analysis
+            if isinstance(ingredients, str) and "Error" in ingredients:
+                print(f"LLaMA API error, using fallback: {ingredients}")
+                return f"Error extracting ingredients. Using fallback analysis.\n\n{dummy_analyze(product_name, health_conditions)}"
+
+            # Analyze ingredients
+            return analyze_ingredients_with_mistral(ingredients, health_conditions, product_name)
+        else:
+            return "No product name entered. Please try again."
 
-# Function to process input based on method (camera, upload, or manual entry)
-def process_input(input_method, text_input, camera_input, upload_input, health_conditions):
-    if input_method == "Camera":
+    elif input_method == "Camera (Ingredients Label)":
         if camera_input is not None:
-            ingredients, response_text = identify_product_and_get_ingredients(camera_input)
+            extracted_text = extract_text_from_image(camera_input)
 
-            if ingredients:
-                return analyze_ingredients_with_mistral(ingredients, health_conditions), response_text
-            else:
-                return f"Could not identify ingredients from the image. Response from OpenAI:\n\n{response_text}", response_text
+            # If OCR fails, try using Meta LLaMA API as backup
+            if "Error" in extracted_text or "No text could be extracted" in extracted_text:
+                print(f"OCR failed, trying LLaMA API backup: {extracted_text}")
+                ingredients, detected_product = extract_ingredients_with_llama(image=camera_input)
 
-        else:
-            return "No camera image captured. Please try again.", ""
+                if isinstance(ingredients, str) and "Error" in ingredients:
+                    return f"Could not extract ingredients from image. Using fallback analysis.\n\n{dummy_analyze('Unknown food product', health_conditions)}"
 
-    elif input_method == "Image Upload":
-        if upload_input is not None:
-            ingredients, response_text = identify_product_and_get_ingredients(upload_input)
-            if ingredients:
-                return analyze_ingredients_with_mistral(ingredients, health_conditions), response_text
-            else:
-                return f"Could not identify ingredients from the image. Response from OpenAI:\n\n{response_text}", response_text
+                product_info = ""
+                if detected_product:
+                    product_info = f"## Product: {detected_product}\n\n"
 
-        else:
-            return "No image uploaded. Please try again.", ""
+                analysis = analyze_ingredients_with_mistral(ingredients, health_conditions, detected_product)
+                return product_info + "Ingredients extracted using AI image analysis.\n\n" + analysis
 
-    elif input_method == "Manual Entry":
-        if text_input and text_input.strip():
-            ingredients = parse_ingredients(text_input)
-            return analyze_ingredients_with_mistral(ingredients, health_conditions), ""
+            # If OCR succeeded, parse ingredients normally
+            ingredients = parse_ingredients(extracted_text)
+            return analyze_ingredients_with_mistral(ingredients, health_conditions)
         else:
-            return "No ingredients entered. Please try again.", ""
+            return "No camera image captured. Please try again."
 
-    return "Please provide input using one of the available methods.", ""
+    return "Please provide input using one of the available methods."
 
 # Create the Gradio interface
 with gr.Blocks(title="AI Ingredient Scanner") as app:
     gr.Markdown("# AI Ingredient Scanner")
-    gr.Markdown("Scan product ingredients and analyze them for health benefits, risks, and potential allergens.")
+    gr.Markdown("Analyze product ingredients for health benefits, risks, and potential allergens. Just take a photo of the product or enter its name!")
 
     with gr.Row():
         with gr.Column():
             input_method = gr.Radio(
-                ["Camera", "Image Upload", "Manual Entry"],
+                ["Product Photo", "Product Name", "Camera (Ingredients Label)"],
                 label="Input Method",
-                value="Camera"
+                value="Product Photo",
+                info="Choose how you want to identify the product"
             )
 
-            # Camera input
-            camera_input = gr.Image(label="Capture image of product", type="pil", visible=True)
-
-            # Image upload
-            upload_input = gr.Image(label="Upload image of product", type="pil", visible=False)
-
-            # Text input
-            text_input = gr.Textbox(
-                label="Enter ingredients list (comma separated)",
-                placeholder="milk, sugar, flour, eggs, vanilla extract",
-                lines=3,
+            # Product name input
+            product_name = gr.Textbox(
+                label="Enter product name",
+                placeholder="e.g., Coca-Cola, Oreo Cookies, Lay's Potato Chips",
                 visible=False
             )
 
+            # Product photo capture
+            product_photo = gr.Image(label="Take a photo of the product", type="pil", visible=True)
+
+            # Camera input for ingredients label (original functionality)
+            camera_input = gr.Image(label="Capture ingredients label with camera", type="pil", visible=False)
+
             # Health conditions input - now optional and more flexible
             health_conditions = gr.Textbox(
                 label="Enter your health concerns (optional)",
@@ -412,36 +497,64 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
                 info="The AI will automatically analyze ingredients for these conditions"
             )
 
-            analyze_button = gr.Button("Analyze Ingredients")
+            analyze_button = gr.Button("Analyze Product")
 
         with gr.Column():
             output = gr.Markdown(label="Analysis Results")
-            extracted_text_output = gr.Textbox(label="Extracted Response from OpenAI", lines=5)
+            extracted_info = gr.Textbox(label="Extracted Information (for verification)", lines=3)
 
     # Show/hide inputs based on selection
     def update_visible_inputs(choice):
         return {
-            upload_input: gr.update(visible=(choice == "Image Upload")),
-            camera_input: gr.update(visible=(choice == "Camera")),
-            text_input: gr.update(visible=(choice == "Manual Entry"))
+            product_photo: gr.update(visible=(choice == "Product Photo")),
+            product_name: gr.update(visible=(choice == "Product Name")),
+            camera_input: gr.update(visible=(choice == "Camera (Ingredients Label)")),
         }
 
-    input_method.change(update_visible_inputs, input_method, [upload_input, camera_input, text_input])
+    input_method.change(update_visible_inputs, input_method, [product_photo, product_name, camera_input])
+
+    # Display extracted information (for verification purposes)
+    def show_extracted_info(input_method, product_name, camera_input, product_photo):
+        if input_method == "Product Photo" and product_photo is not None:
+            ingredients, product = extract_ingredients_with_llama(image=product_photo)
+            if isinstance(ingredients, list):
+                return f"Product: {product if product else 'Unknown'}\nIngredients: {', '.join(ingredients)}"
+            else:
+                return ingredients
+        elif input_method == "Product Name" and product_name:
+            ingredients, _ = extract_ingredients_with_llama(product_name=product_name)
+            if isinstance(ingredients, list):
+                return f"Product: {product_name}\nIngredients: {', '.join(ingredients)}"
+            else:
+                return ingredients
+        elif input_method == "Camera (Ingredients Label)" and camera_input is not None:
+            extracted_text = extract_text_from_image(camera_input)
+            return extracted_text
+        return "No input detected"
 
     # Set up event handlers
     analyze_button.click(
         fn=process_input,
-        inputs=[input_method, text_input, camera_input, upload_input, health_conditions],
-        outputs=[output, extracted_text_output]
+        inputs=[input_method, product_name, camera_input, product_photo, health_conditions],
+        outputs=output
+    )
+
+    analyze_button.click(
+        fn=show_extracted_info,
+        inputs=[input_method, product_name, camera_input, product_photo],
+        outputs=extracted_info
     )
 
     gr.Markdown("### How to use")
     gr.Markdown("""
-    1. Choose your input method (Camera, Image Upload, or Manual Entry)
-    2. Take a photo of the product or upload an image, or enter ingredients manually
-    3. Optionally enter your health concerns
-    4. Click "Analyze Ingredients" to get your personalized analysis
-    The AI will automatically identify the product and analyze the ingredients, their health implications, and their potential impact on your specific health concerns.
+    1. Choose your input method:
+       - **Product Photo**: Take a photo of the entire product (front, back, or packaging)
+       - **Product Name**: Simply enter the name of the product
+       - **Camera (Ingredients Label)**: Traditional method - take a photo of the ingredients list
+    2. Optionally enter your health concerns
+    3. Click "Analyze Product" to get your personalized analysis
+
+    The AI will automatically detect the product, extract its ingredients, and analyze them.
     """)
 
     gr.Markdown("### Examples of what you can ask")
@@ -458,8 +571,9 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
     gr.Markdown("### Tips for best results")
     gr.Markdown("""
     - Hold the camera steady and ensure good lighting
-    - Focus directly on the product, including its label
-    - Make sure the product is clearly visible
+    - For Product Photo: Capture the entire product package clearly
+    - For Product Name: Be specific (e.g., "Honey Nut Cheerios" instead of just "Cheerios")
+    - For Ingredients Label: Focus directly on the ingredients list text
     - Be specific about your health concerns for more targeted analysis
     """)
 
@@ -471,6 +585,4 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
 
 # Launch the app
 if __name__ == "__main__":
-    import io
-    import base64
     app.launch()