Update app.py

app.py

@@ -1,44 +1,99 @@
-
 import os
 import subprocess
 import sys
 import re
 import numpy as np
-from PIL import Image
 import gradio as gr
 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()
 
 # Mistral API Key
-MISTRAL_API_KEY = "GlrVCBWyvTYjWGKl5jqtK4K41uWWJ79F"
+MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY", "GlrVCBWyvTYjWGKl5jqtK4K41uWWJ79F") # Retrieve from environment or default
+
+# Open Food Facts API for product lookup
+def get_product_ingredients(product_name):
+    """
+    Look up a product by name using the Open Food Facts API and return its ingredients
+    """
+    if not product_name or not product_name.strip():
+        return None, "Please enter a product name"
+
+    try:
+        # Search for products matching the name
+        search_url = f"https://world.openfoodfacts.org/cgi/search.pl?search_terms={product_name}&search_simple=1&action=process&json=1"
+        response = requests.get(search_url)
+        
+        if response.status_code != 200:
+            return None, f"Error connecting to food database: {response.status_code}"
+        
+        data = response.json()
+        
+        # Check if any products were found
+        if data["count"] == 0:
+            return None, f"No products found matching '{product_name}'"
+        
+        # Get the first (most relevant) product
+        product = data["products"][0]
+        
+        # Extract product information
+        product_info = {
+            "name": product.get("product_name", "Unknown product"),
+            "brand": product.get("brands", "Unknown brand"),
+            "ingredients_text": product.get("ingredients_text", ""),
+            "image_url": product.get("image_url", ""),
+            "ingredients_list": []
+        }
+        
+        # If ingredients are available in structured format
+        if "ingredients" in product and isinstance(product["ingredients"], list):
+            for ing in product["ingredients"]:
+                if "text" in ing and ing["text"]:
+                    product_info["ingredients_list"].append(ing["text"].lower())
+        
+        # If no structured ingredients but we have text, parse it
+        elif product_info["ingredients_text"]:
+            product_info["ingredients_list"] = parse_ingredients(product_info["ingredients_text"])
+        
+        # If we still don't have ingredients
+        if not product_info["ingredients_list"]:
+            return None, f"Found product '{product_info['name']}' by {product_info['brand']}, but no ingredients information is available"
+        
+        return product_info, None
+        
+    except requests.exceptions.RequestException as e:
+        return None, f"Network error retrieving product information: {str(e)}"
+    except Exception as e:
+        return None, f"Error retrieving product information: {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)
+
+    # 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 errors
+            cleaned_ingredients.append(i)
+
+    return cleaned_ingredients
 
 # Import and configure Mistral API
-def analyze_ingredients_with_mistral(ingredients_list, health_conditions=None):
+def analyze_ingredients_with_mistral(ingredients_list, product_name="", health_conditions=None):
     """
     Use Mistral AI to analyze ingredients and provide health insights.
     """
@@ -47,11 +102,13 @@ def analyze_ingredients_with_mistral(ingredients_list, health_conditions=None):
 
     # Prepare the list of ingredients for the prompt
     ingredients_text = ", ".join(ingredients_list)
+    
+    product_context = f"for the product '{product_name}'" if product_name else ""
 
     # Create a prompt for Mistral
     if health_conditions and health_conditions.strip():
         prompt = f"""
-        Analyze the following food ingredients for a person with these health conditions: {health_conditions}
+        Analyze the following food ingredients {product_context} for a person with these health conditions: {health_conditions}
         Ingredients: {ingredients_text}
         For each ingredient:
         1. Provide its potential health benefits
@@ -62,7 +119,7 @@ def analyze_ingredients_with_mistral(ingredients_list, health_conditions=None):
         """
     else:
         prompt = f"""
-        Analyze the following food ingredients:
+        Analyze the following food ingredients {product_context}:
         Ingredients: {ingredients_text}
         For each ingredient:
         1. Provide its potential health benefits
@@ -98,11 +155,13 @@ def analyze_ingredients_with_mistral(ingredients_list, health_conditions=None):
 
         return analysis + disclaimer
 
+    except requests.exceptions.RequestException as e:
+        # Fallback to basic analysis if API call fails
+        return dummy_analyze(ingredients_list, health_conditions) + f"\n\n(Using fallback analysis: Network error - {str(e)})"
     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)
@@ -134,217 +193,55 @@ def dummy_analyze(ingredients_list, health_conditions=None):
 
     return report
 
-# 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."
-
-        # Import necessary libraries
-        import cv2
-        import numpy as np
-        from PIL import Image, ImageOps, ImageEnhance
-
-        # First approach: Invert the image for light text on dark background
-        inverted_image = ImageOps.invert(image)
-
-        # Try OCR on inverted image
-        custom_config = r'--oem 3 --psm 6 -l eng --dpi 300'
-        inverted_text = pytesseract.image_to_string(inverted_image, config=custom_config)
-
-        # Second approach: OpenCV processing for colored backgrounds
-        img_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-
-        # Convert to grayscale
-        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
-
-        # Apply bilateral filter to preserve edges while reducing noise
-        filtered = cv2.bilateralFilter(gray, 11, 17, 17)
-
-        # Adaptive thresholding to handle varied lighting
-        thresh = cv2.adaptiveThreshold(filtered, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-                                      cv2.THRESH_BINARY, 11, 2)
-
-        # Invert the image (if text is light on dark background)
-        inverted_thresh = cv2.bitwise_not(thresh)
-
-        # Try OCR on processed image
-        cv_text = pytesseract.image_to_string(
-            Image.fromarray(inverted_thresh),
-            config=custom_config
-        )
-
-        # Third approach: Color filtering to isolate text from colored background
-        # Convert to HSV color space to better isolate colors
-        hsv = cv2.cvtColor(img_cv, cv2.COLOR_BGR2HSV)
-
-        # Create a mask to extract light colored text (assuming white/light text)
-        lower_white = np.array([0, 0, 150])
-        upper_white = np.array([180, 30, 255])
-        mask = cv2.inRange(hsv, lower_white, upper_white)
-
-        # Apply morphological operations to clean up the mask
-        kernel = np.ones((2, 2), np.uint8)
-        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
-        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
-
-        # Improve character connectivity
-        mask = cv2.dilate(mask, kernel, iterations=1)
-
-        # Try OCR on color filtered image
-        color_text = pytesseract.image_to_string(
-            Image.fromarray(mask),
-            config=r'--oem 3 --psm 6 -l eng --dpi 300'
-        )
-
-        # Fourth approach: Try directly with the image but with different configs
-        direct_text = pytesseract.image_to_string(
-            image,
-            config=r'--oem 3 --psm 11 -l eng --dpi 300'
-        )
-
-        # Compare results and select the best one
-        results = [inverted_text, cv_text, color_text, direct_text]
-
-        # Select the result with the most alphanumeric characters
-        def count_alphanumeric(text):
-            return sum(c.isalnum() for c in text)
-
-        best_text = max(results, key=count_alphanumeric)
-
-        # If still poor results, try with explicit text color inversion in tesseract
-        if count_alphanumeric(best_text) < 20:
-            # Try with tesseract's built-in inversion
-            neg_text = pytesseract.image_to_string(
-                image,
-                config=r'--oem 3 --psm 6 -c textord_heavy_nr=1 -c textord_debug_printable=0 -l eng --dpi 300'
-            )
-            if count_alphanumeric(neg_text) > count_alphanumeric(best_text):
-                best_text = neg_text
-
-        # Clean up the text
-        best_text = re.sub(r'[^\w\s,;:%.()\n\'-]', '', best_text)
-        best_text = best_text.replace('\n\n', '\n')
-
-        # Special case for ingredients list format
-        if "ingredient" in best_text.lower() or any(x in best_text.lower() for x in ["sugar", "cocoa", "milk", "contain"]):
-            # Specific cleaning for ingredient lists
-            best_text = re.sub(r'([a-z])([A-Z])', r'\1 \2', best_text)  # Add space between lowercase and uppercase
-            best_text = re.sub(r'(\d+)([a-zA-Z])', r'\1 \2', best_text)  # Add space between number and letter
-
-        if not best_text.strip():
-            return "No text could be extracted. Ensure image is clear and readable."
-
-        return best_text.strip()
-    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 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_mistral(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_mistral(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_mistral(ingredients, health_conditions)
+# Function to process product name input
+def process_product_input(product_name, manual_ingredients, use_manual, health_conditions):
+    if use_manual:
+        if manual_ingredients and manual_ingredients.strip():
+            ingredients = parse_ingredients(manual_ingredients)
+            return f"Analyzing manually entered ingredients:\n\n{analyze_ingredients_with_mistral(ingredients, '', health_conditions)}", manual_ingredients
         else:
-            return "No ingredients entered. Please try again."
-
-    return "Please provide input using one of the available methods."
+            return "No ingredients entered. Please try again.", ""
+    else:
+        if not product_name or not product_name.strip():
+            return "Please enter a product name", ""
+            
+        product_info, error = get_product_ingredients(product_name)
+        
+        if error:
+            return error, ""
+            
+        # Display analysis using the ingredients
+        return f"# Analysis for {product_info['name']} by {product_info['brand']}\n\n{analyze_ingredients_with_mistral(product_info['ingredients_list'], product_info['name'], health_conditions)}", ", ".join(product_info['ingredients_list'])
 
 # 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("Find and analyze product ingredients 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"
+            # Option to use manual ingredients or product lookup
+            use_manual_ingredients = gr.Checkbox(
+                label="Enter ingredients manually instead of product lookup",
+                value=False
             )
-
-            # 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(
+            
+            # Product name input
+            product_name_input = gr.Textbox(
+                label="Enter product name",
+                placeholder="Oreo cookies, Coca Cola, Nutella, etc.",
+                lines=1
+            )
+            
+            # Manual ingredients input (initially hidden)
+            manual_ingredients_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 input
             health_conditions = gr.Textbox(
                 label="Enter your health concerns (optional)",
                 placeholder="diabetes, high blood pressure, peanut allergy, etc.",
@@ -356,48 +253,32 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
 
         with gr.Column():
             output = gr.Markdown(label="Analysis Results")
-            extracted_text_output = gr.Textbox(label="Extracted Text (for verification)", lines=3)
+            ingredients_output = gr.Textbox(label="Identified Ingredients", lines=3)
 
-    # Show/hide inputs based on selection
-    def update_visible_inputs(choice):
+    # Show/hide inputs based on checkbox
+    def update_visible_inputs(use_manual):
         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_name_input: gr.update(visible=not use_manual),
+            manual_ingredients_input: gr.update(visible=use_manual)
         }
 
-    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"
+    use_manual_ingredients.change(update_visible_inputs, use_manual_ingredients, [product_name_input, manual_ingredients_input])
 
     # 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
+        fn=process_product_input,
+        inputs=[product_name_input, manual_ingredients_input, use_manual_ingredients, health_conditions],
+        outputs=[output, ingredients_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
+    1. Enter a product name (e.g., "Oreo cookies", "Coca Cola", "Nutella")
+    2. Or check the box to enter ingredients manually if you prefer
     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.
+    
+    The AI will automatically find the product's ingredients and analyze their health implications and potential impact on your specific health concerns.
     """)
 
     gr.Markdown("### Examples of what you can ask")
@@ -413,10 +294,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 ingredients list
-    - Make sure the text is clear and readable
+    - Use the full product name and brand if possible
     - Be specific about your health concerns for more targeted analysis
+    - If a product can't be found, try entering the ingredients manually
     """)
 
     gr.Markdown("### Disclaimer")
@@ -427,4 +307,4 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
 
 # Launch the app
 if __name__ == "__main__":
-    app.launch()
+    app.launch()