Update app.py

app.py

@@ -1,57 +1,294 @@
 import gradio as gr
-import google.generativeai as genai
+import re
+import numpy as np
+from PIL import Image
+import pytesseract
+import requests
+import json
 import os
+from dotenv import load_dotenv
+import google.generativeai as genai
 
-# Load API key from Hugging Face Secret
+# Load environment variables
+load_dotenv()
+
+# Configure Gemini API
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 genai.configure(api_key=GEMINI_API_KEY)
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:  # User message
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:  # Assistant response
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    # Call Gemini API
-    model = genai.GenerativeModel("gemini-1.5-flash")
-    response = model.generate_content(message, stream=True)
-
-    output = ""
-    for chunk in response:
-        if chunk.text:
-            output += chunk.text
-            yield output  # Stream response in real-time
-
-# Gradio Interface
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
 
-if __name__ == "__main__":
-    demo.launch()
+# Function to extract text from images using OCR
+def extract_text_from_image(image):
+    try:
+        if image is None:
+            return "No image captured. Please try again."
+        text = pytesseract.image_to_string(image)
+        return text
+    except Exception as e:
+        return f"Error extracting text: {str(e)}"
+
+# Function to parse ingredients from text
+def parse_ingredients(text):
+    # Basic parsing - split by commas, semicolons, and line breaks
+    if not text:
+        return []
+
+    # Clean up the text - remove "Ingredients:" prefix if present
+    text = re.sub(r'^ingredients:?\s*', '', text.lower(), flags=re.IGNORECASE)
+
+    # Split by common ingredient separators
+    ingredients = re.split(r',|;|\n', text)
+    ingredients = [i.strip().lower() for i in ingredients if i.strip()]
+    return ingredients
+
+# Function to analyze ingredients with Gemini
+def analyze_ingredients_with_gemini(ingredients_list, health_conditions=None):
+    """
+    Use Gemini to analyze ingredients and provide health insights
+    """
+    if not ingredients_list:
+        return "No ingredients detected or provided."
+
+    # Prepare the list of ingredients for the prompt
+    ingredients_text = ", ".join(ingredients_list)
+
+    # Create a prompt for Gemini
+    if health_conditions and health_conditions.strip():
+        prompt = f"""
+        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
+        2. Identify any potential risks
+        3. Note if it may affect the specified health conditions
+
+        Then provide an overall assessment of the product's suitability for someone with the specified health conditions.
+        Format your response in markdown with clear headings and sections.
+        """
+    else:
+        prompt = f"""
+        Analyze the following food ingredients:
+
+        Ingredients: {ingredients_text}
+
+        For each ingredient:
+        1. Provide its potential health benefits
+        2. Identify any potential risks or common allergens associated with it
+
+        Then provide an overall assessment of the product's general health profile.
+        Format your response in markdown with clear headings and sections.
+        """
+
+    try:
+        # Call the Gemini API
+        model = genai.GenerativeModel('gemini-pro')
+        response = model.generate_content(prompt)
+
+        # Extract and return the analysis
+        analysis = response.text
+
+        # Add disclaimer
+        disclaimer = """
+        ## Disclaimer
+        This analysis is provided for informational purposes only and should not replace professional medical advice.
+        Always consult with a healthcare provider regarding dietary restrictions, allergies, or health conditions.
+        """
+
+        return analysis + disclaimer
+
+    except Exception as e:
+        # Fallback to basic analysis if API call fails
+        return f"Error connecting to analysis service: {str(e)}\n\nPlease try again later."
+
+# 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":
+        if camera_input is not None:
+            extracted_text = extract_text_from_image(camera_input)
+            ingredients = parse_ingredients(extracted_text)
+            return analyze_ingredients_with_gemini(ingredients, health_conditions)
+        else:
+            return "No camera image captured. Please try again."
+
+    elif input_method == "Image Upload":
+        if upload_input is not None:
+            extracted_text = extract_text_from_image(upload_input)
+            ingredients = parse_ingredients(extracted_text)
+            return analyze_ingredients_with_gemini(ingredients, health_conditions)
+        else:
+            return "No image uploaded. Please try again."
+
+    elif input_method == "Manual Entry":
+        if text_input.strip():
+            ingredients = parse_ingredients(text_input)
+            return analyze_ingredients_with_gemini(ingredients, health_conditions)
+        else:
+            return "No ingredients entered. Please try again."
+
+    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.")
+
+    with gr.Row():
+        with gr.Column():
+            input_method = gr.Radio(
+                ["Camera", "Image Upload", "Manual Entry"],
+                label="Input Method",
+                value="Camera"
+            )
+
+            # Camera input
+            camera_input = gr.Image(label="Capture ingredients with camera", type="pil")
 
+            # Image upload
+            upload_input = gr.Image(label="Upload image of ingredients label", 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,
+                visible=False
+            )
+
+            # Health conditions input - now optional and more flexible
+            health_conditions = gr.Textbox(
+                label="Enter your health concerns (optional)",
+                placeholder="diabetes, high blood pressure, peanut allergy, etc.",
+                lines=2,
+                info="The AI will automatically analyze ingredients for these conditions"
+            )
+
+            analyze_button = gr.Button("Analyze Ingredients")
+
+        with gr.Column():
+            output = gr.Markdown(label="Analysis Results")
+            extracted_text_output = gr.Textbox(label="Extracted Text (for verification)", lines=3)
+
+    # Show/hide inputs based on selection
+    def update_visible_inputs(choice):
+        return {
+            upload_input: choice == "Image Upload",
+            camera_input: choice == "Camera",
+            text_input: choice == "Manual Entry"
+        }
+
+    input_method.change(update_visible_inputs, input_method, [upload_input, camera_input, text_input])
+
+    # Extract and display the raw text (for verification purposes)
+    def show_extracted_text(input_method, text_input, camera_input, upload_input):
+        if input_method == "Camera" and camera_input is not None:
+            return extract_text_from_image(camera_input)
+        elif input_method == "Image Upload" and upload_input is not None:
+            return extract_text_from_image(upload_input)
+        elif input_method == "Manual Entry":
+            return text_input
+        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
+    )
+
+    analyze_button.click(
+        fn=show_extracted_text,
+        inputs=[input_method, text_input, camera_input, upload_input],
+        outputs=extracted_text_output
+    )
+
+    gr.Markdown("### How to use")
+    gr.Markdown("""
+    1. Choose your input method (Camera, Image Upload, or Manual Entry)
+    2. Take a photo of the ingredients label or enter ingredients manually
+    3. Optionally enter your health concerns
+    4. Click "Analyze Ingredients" to get your personalized analysis
+
+    The AI will automatically analyze the ingredients, their health implications, and their potential impact on your specific health concerns.
+    """)
+
+    gr.Markdown("### Examples of what you can ask")
+    gr.Markdown("""
+    The system can handle a wide range of health concerns, such as:
+    - General health goals: "trying to reduce sugar intake" or "watching sodium levels"
+    - Medical conditions: "diabetes" or "hypertension"
+    - Allergies: "peanut allergy" or "shellfish allergy"
+    - Dietary restrictions: "vegetarian" or "gluten-free diet"
+    - Multiple conditions: "diabetes, high cholesterol, and lactose intolerance"
+
+    The AI will tailor its analysis to your specific needs.
+    """)
+
+    gr.Markdown("### Tips for best results")
+    gr.Markdown("""
+    - Hold the camera steady and ensure good lighting
+    - Focus directly on the ingredients list
+    - Make sure the text is clear and readable
+    - Be specific about your health concerns for more targeted analysis
+    """)
+
+    gr.Markdown("### Disclaimer")
+    gr.Markdown("""
+    This tool is for informational purposes only and should not replace professional medical advice.
+    Always consult with a healthcare provider regarding dietary restrictions, allergies, or health conditions.
+    """)
+
+# Function to run when testing without API key
+def run_with_dummy_llm():
+    # Override the LLM function with a dummy version for testing
+    global analyze_ingredients_with_gemini
+
+    def dummy_analyze(ingredients_list, health_conditions=None):
+        ingredients_text = ", ".join(ingredients_list)
+
+        report = f"""
+        # Ingredient Analysis Report
+
+        ## Detected Ingredients
+        {", ".join([i.title() for i in ingredients_list])}
+
+        ## Overview
+        This is a simulated analysis since no API key was provided. In the actual application,
+        the ingredients would be analyzed by an LLM for their health implications.
+
+        ## Health Considerations
+        """
+
+        if health_conditions:
+            report += f"""
+            The analysis would specifically consider these health concerns: {health_conditions}
+            """
+        else:
+            report += """
+            No specific health concerns were provided, so a general analysis would be performed.
+            """
+
+        report += """
+        ## Disclaimer
+        This analysis is provided for informational purposes only and should not replace professional medical advice.
+        Always consult with a healthcare provider regarding dietary restrictions, allergies, or health conditions.
+        """
+
+        return report
+
+    # Replace the real function with the dummy
+    analyze_ingredients_with_gemini = dummy_analyze
+
+    # Launch the app
+    app.launch()
+
+# Launch the app
+if __name__ == "__main__":
+    # Check if API key exists
+    if not os.getenv("GEMINI_API_KEY"):
+        print("WARNING: No Gemini API key found. Running with simulated LLM responses.")
+        run_with_dummy_llm()
+    else:
+        app.launch()