Update app.py

app.py

@@ -1,6 +1,13 @@
 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:
@@ -9,68 +16,134 @@ except ImportError:
     subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'pytesseract'])
     import pytesseract
 
-# Set Tesseract path
-pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'
-
-def extract_text_from_image(image):
-    try:
-        if image is None:
-            return "No image captured. Please try again."
-        
-        # Verify Tesseract executable
-        if not os.path.exists('/usr/bin/tesseract'):
-            return "Tesseract OCR is not installed. Please install tesseract-ocr."
-        
-        text = pytesseract.image_to_string(image)
-        
-        if not text.strip():
-            return "No text could be extracted. Ensure image is clear and readable."
+# 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'
+try:
+    import google.generativeai as genai
+    if GEMINI_API_KEY:
+        # Configure Gemini API
+        genai.configure(api_key=GEMINI_API_KEY)
+        print("Gemini API configured successfully")
         
-        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
+        # Test API connection
+        try:
+            models = genai.list_models()
+            print(f"Available models: {[m.name for m in models]}")
+        except Exception as e:
+            print(f"Error checking Gemini API models: {e}")
+    else:
+        print("No Gemini API key available. Will use dummy implementation.")
+except ImportError:
+    print("Google Generative AI package not found, using dummy implementation")
+    genai = None
 
 # Load environment variables
+# Load environment variables and set up API key
 load_dotenv()
 
-# Configure Gemini API
-GEMINI_API_KEY = "AIzaSyBNXFHDQqzi42t6upOtPpUDz2B-J48U60w"
-genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+# 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."
-        text = pytesseract.image_to_string(image)
+        
+        # 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):
-    # Basic parsing - split by commas, semicolons, and line breaks
     if not text:
         return []
 
-    # Clean up the text - remove "Ingredients:" prefix if present
+    # 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)
-    ingredients = [i.strip().lower() for i in ingredients if i.strip()]
-    return ingredients
+    
+    # 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):
     """
@@ -81,43 +154,95 @@ 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:
-        # Call the Gemini API
-        model = genai.GenerativeModel('gemini-pro')
-        response = model.generate_content(prompt)
+        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)})"
+
+        # 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.
+        """
 
-        # Extract and return the analysis
-        analysis = response.text
+        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)})"
 
         # Add disclaimer
         disclaimer = """
@@ -130,13 +255,47 @@ def analyze_ingredients_with_gemini(ingredients_list, health_conditions=None):
 
     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."
+        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:
@@ -145,13 +304,17 @@ 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.strip():
+        if text_input and text_input.strip():
             ingredients = parse_ingredients(text_input)
             return analyze_ingredients_with_gemini(ingredients, health_conditions)
         else:
@@ -173,7 +336,7 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
             )
 
             # Camera input
-            camera_input = gr.Image(label="Capture ingredients with camera", type="pil")
+            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)
@@ -203,9 +366,9 @@ with gr.Blocks(title="AI Ingredient Scanner") as app:
     # 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"
+            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])
@@ -239,7 +402,6 @@ 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.
     """)
 
@@ -251,7 +413,6 @@ 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.
     """)
 
@@ -269,55 +430,6 @@ 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__":
-    # 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()
+    app.launch()