Create app.py

app.py

@@ -0,0 +1,429 @@
+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"
+
+# Import and configure Mistral API
+def analyze_ingredients_with_mistral(ingredients_list, health_conditions=None):
+    """
+    Use Mistral AI 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 Mistral
+    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:
+        headers = {
+            "Authorization": f"Bearer {MISTRAL_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        data = {
+            "model": "mistral-small",  # Or another suitable model
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": 0.7,
+        }
+
+        response = requests.post("https://api.mistral.ai/v1/chat/completions", headers=headers, json=data)
+
+        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})"
+
+        # 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 the Mistral API call failed. In the actual application,
+    the ingredients would be analyzed by Mistral 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 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)
+        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__":
+    app.launch()