Update app.py

app.py

@@ -1,13 +1,6 @@
 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:
@@ -16,117 +9,68 @@ 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 environment variables and set up API key
-load_dotenv()
+# Set Tesseract path
+pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'
 
-# First try to get API key from environment
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-
-# Then try Google Colab userdata if available
-
-
-# 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)
+        # Verify Tesseract executable
+        if not os.path.exists('/usr/bin/tesseract'):
+            return "Tesseract OCR is not installed. Please install tesseract-ocr."
         
-        # Convert to grayscale
-        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
+        text = pytesseract.image_to_string(image)
         
-        # 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)}"
+import gradio as gr
+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 environment variables
+load_dotenv()
+
+# Configure Gemini API
+GEMINI_API_KEY = "AIzaSyBNXFHDQqzi42t6upOtPpUDz2B-J48U60w"
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+
+# 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
+    # Clean up the text - remove "Ingredients:" prefix if present
     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
+    ingredients = [i.strip().lower() for i in ingredients if i.strip()]
+    return ingredients
 
-# Function to analyze ingredients with Gemini
 # Function to analyze ingredients with Gemini
 def analyze_ingredients_with_gemini(ingredients_list, health_conditions=None):
     """
@@ -137,95 +81,43 @@ def analyze_ingredients_with_gemini(ingredients_list, health_conditions=None):
 
     # Prepare the list of ingredients for the prompt
     ingredients_text = ", ".join(ingredients_list)
-    
-    # Add debug print to check API key at function call time
-    print(f"GEMINI_API_KEY available: {bool(GEMINI_API_KEY)}")
-    
-    # Check if Gemini API is available
-    if not genai or not GEMINI_API_KEY:
-        print("Falling back to dummy analysis: API or key not available")
-        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:
-        print("Attempting to use Gemini API...")
-        # First, check available models
-        try:
-            models = genai.list_models()
-            available_models = [m.name for m in models]
-            print(f"Available models: {available_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]
-            
-            print(f"Selected model: {model_name}")
-                
-            if not model_name:
-                print("No available models found")
-                return dummy_analyze(ingredients_list, health_conditions) + "\n\n(Using fallback analysis: No available models found)"
-                
-            model = genai.GenerativeModel(model_name)
-            print(f"Sending prompt to {model_name}...")
-            response = model.generate_content(prompt)
-            
-            # Check if response is valid
-            if hasattr(response, 'text') and response.text:
-                analysis = response.text
-                print("Received valid response from Gemini API")
-            else:
-                print("Empty response from API")
-                return dummy_analyze(ingredients_list, health_conditions) + "\n\n(Using fallback analysis: Empty API response)"
-                
-        except Exception as e:
-            print(f"Error accessing Gemini API models: {str(e)}")
-            return dummy_analyze(ingredients_list, health_conditions) + f"\n\n(Using fallback analysis: {str(e)})"
+        # Call the Gemini API
+        model = genai.GenerativeModel('gemini-pro')
+        response = model.generate_content(prompt)
 
-        # 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
-        print(f"Overall error in analyze_ingredients_with_gemini: {str(e)}")
-        return dummy_analyze(ingredients_list, health_conditions) + f"\n\n(Using fallback analysis: {str(e)})"
+        # Extract and return the analysis
+        analysis = response.text
 
         # Add disclaimer
         disclaimer = """
@@ -238,47 +130,13 @@ def analyze_ingredients_with_gemini(ingredients_list, health_conditions=None):
 
     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
+        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)
-            # 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:
@@ -287,17 +145,13 @@ def process_input(input_method, text_input, camera_input, upload_input, health_c
     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():
+        if text_input.strip():
             ingredients = parse_ingredients(text_input)
             return analyze_ingredients_with_gemini(ingredients, health_conditions)
         else:
@@ -319,7 +173,7 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
             )
 
             # Camera input
-            camera_input = gr.Image(label="Capture ingredients with camera", type="pil", visible=True)
+            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)
@@ -349,9 +203,9 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
     # 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"))
+            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])
@@ -385,6 +239,7 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
     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.
     """)
 
@@ -396,6 +251,7 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
     - 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.
     """)
 
@@ -413,6 +269,55 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
     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__":
-    app.launch()
+    # 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()