Update app.py

app.py

@@ -1,64 +1,398 @@
+import os
+import subprocess
+import sys
+import re
+import numpy as np
+from PIL import Image
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-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]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-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)",
-        ),
-    ],
-)
+import requests
+import json
+from dotenv import load_dotenv
 
+# Attempt to install pytesseract if not found
+try:
+    import pytesseract
+except ImportError:
+    subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'pytesseract'])
+    import pytesseract
 
+# AFTER importing pytesseract, then set the path
+try:
+    # First try the default path
+    if os.path.exists('/usr/bin/tesseract'):
+        pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'
+    # Try to find it on the PATH
+    else:
+        tesseract_path = subprocess.check_output(['which', 'tesseract']).decode().strip()
+        if tesseract_path:
+            pytesseract.pytesseract.tesseract_cmd = tesseract_path
+except:
+    # If all else fails, try the default installation path
+    pytesseract.pytesseract.tesseract_cmd = 'tesseract'
+
+
+# Load environment variables
+load_dotenv()
+
+# Import and configure Gemini API
+try:
+    import google.generativeai as genai
+    # Configure Gemini API
+    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") or GEMINI_API_KEY
+    if GEMINI_API_KEY:
+      genai.configure(api_key=GEMINI_API_KEY)
+      print("Gemini API configured successfully")
+    else:
+      print("Warning: No Gemini API key found. Will use fallback analysis.")
+except ImportError:
+    print("Google Generative AI package not found, using dummy implementation")
+    genai = None
+
+# 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."
+        
+        # Verify Tesseract executable is accessible
+        try:
+            subprocess.run([pytesseract.pytesseract.tesseract_cmd, "--version"], 
+                          check=True, capture_output=True, text=True)
+        except (subprocess.SubprocessError, FileNotFoundError):
+            return "Tesseract OCR is not installed or not properly configured. Please check installation."
+        
+        # Image preprocessing for better OCR
+        import cv2
+        import numpy as np
+        
+        # Convert PIL image to OpenCV format
+        img_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+        
+        # Convert to grayscale
+        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
+        
+        # Apply thresholding to get black and white image
+        _, binary = cv2.threshold(gray, 150, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+        
+        # Noise removal
+        kernel = np.ones((1, 1), np.uint8)
+        binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
+        
+        # Dilate to connect text
+        binary = cv2.dilate(binary, kernel, iterations=1)
+        
+        # Convert back to PIL image for tesseract
+        binary_pil = Image.fromarray(cv2.bitwise_not(binary))
+        
+        # Run OCR with improved configuration
+        custom_config = r'--oem 3 --psm 6 -l eng'
+        text = pytesseract.image_to_string(binary_pil, config=custom_config)
+        
+        if not text.strip():
+            # Try original image as fallback
+            text = pytesseract.image_to_string(image, config=custom_config)
+            
+        if not text.strip():
+            return "No text could be extracted. Ensure image is clear and readable."
+        
+        return text
+    except Exception as e:
+        return f"Error extracting text: {str(e)}"
+# Function to parse ingredients from text
+def parse_ingredients(text):
+    if not text:
+        return []
+
+    # Clean up the text
+    text = re.sub(r'^ingredients:?\s*', '', text.lower(), flags=re.IGNORECASE)
+    
+    # Remove common OCR errors and extraneous characters
+    text = re.sub(r'[|\\/@#$%^&*()_+=]', '', text)
+    
+    # Replace common OCR errors
+    text = re.sub(r'\bngredients\b', 'ingredients', text)
+    
+    # Handle common OCR misreads
+    replacements = {
+        '0': 'o', 'l': 'i', '1': 'i',
+        '5': 's', '8': 'b', 'Q': 'g',
+    }
+    
+    for error, correction in replacements.items():
+        text = text.replace(error, correction)
+    
+    # Split by common ingredient separators
+    ingredients = re.split(r',|;|\n', text)
+    
+    # Clean up each ingredient
+    cleaned_ingredients = []
+    for i in ingredients:
+        i = i.strip().lower()
+        if i and len(i) > 1:  # Ignore single characters which are likely OCR errors
+            cleaned_ingredients.append(i)
+    
+    return cleaned_ingredients
+
+# Function to analyze ingredients with Gemini
+# 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)
+    
+    # Check if Gemini API is available
+    if not genai or not os.getenv("GEMINI_API_KEY"):
+        return dummy_analyze(ingredients_list, health_conditions)
+    
+    # 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:
+        # First, check available models
+        try:
+            models = genai.list_models()
+            available_models = [m.name for m in models]
+            
+            # Try models in order of preference
+            model_names = ['gemini-pro', 'gemini-1.5-pro', 'gemini-1.0-pro']
+            
+            # Find first available model from our preference list
+            model_name = None
+            for name in model_names:
+                if any(name in m for m in available_models):
+                    model_name = name
+                    break
+                    
+            # If none of our preferred models are available, use the first available model
+            if not model_name and available_models:
+                model_name = available_models[0]
+                
+            if not model_name:
+                return dummy_analyze(ingredients_list, health_conditions) + "\n\n(Using fallback analysis: No available models found)"
+                
+            model = genai.GenerativeModel(model_name)
+            response = model.generate_content(prompt)
+            
+            # Check if response is valid
+            if hasattr(response, 'text') and response.text:
+                analysis = response.text
+            else:
+                return dummy_analyze(ingredients_list, health_conditions) + "\n\n(Using fallback analysis: Empty API response)"
+                
+        except Exception as e:
+            return dummy_analyze(ingredients_list, health_conditions) + f"\n\n(Using fallback analysis: {str(e)})"
+
+        # 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 dummy_analyze(ingredients_list, 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)
+
+    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
+
+# 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)
+            # If OCR fails, inform the user they can try manual entry
+            if "Error" in extracted_text or "No text could be extracted" in extracted_text:
+                return extracted_text + "\n\nPlease try using the 'Manual Entry' option instead."
+                
+            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)
+            # If OCR fails, inform the user they can try manual entry
+            if "Error" in extracted_text or "No text could be extracted" in extracted_text:
+                return extracted_text + "\n\nPlease try using the 'Manual Entry' option instead."
+                
+            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 and 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", visible=True)
+
+            # 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: gr.update(visible=(choice == "Image Upload")),
+            camera_input: gr.update(visible=(choice == "Camera")),
+            text_input: gr.update(visible=(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.
+    """)
+
+# Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    app.launch()