Update app.py

app.py

@@ -1,178 +1,14 @@
-import os
-import uvicorn
 from fastapi import FastAPI, File, UploadFile
-from fastapi.middleware.cors import CORSMiddleware
 import google.generativeai as genai
-from ultralytics import YOLO
 from PIL import Image
 import io
 import json
-import re
-import pickle
-import time
-from datetime import datetime
-
-# Initialize FastAPI app
-app = FastAPI(title="Food Nutrition API", 
-              description="API for detecting food items and retrieving nutritional information")
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Allows all origins, modify for production
-    allow_credentials=True,
-    allow_methods=["*"],  # Allows all methods
-    allow_headers=["*"],  # Allows all headers
-)
-
-# Load YOLOv8 model
-model = YOLO("models/best.pt")
-
-
-
-# Set up Google Gemini API - Get from environment variable
-GOOGLE_API_KEY = "AIzaSyD_VdzzRsWhM7_SrYTwgi0VT2cZJ6tWETE"
-genai.configure(api_key=GOOGLE_API_KEY)
-gemini_model = genai.GenerativeModel("gemini-1.5-pro")
-
-# # Cache configuration
-# CACHE_DIR = os.getenv("CACHE_DIR", ".")  # Get cache directory from environment or use current directory
-# CACHE_FILE = os.path.join(CACHE_DIR, "food_nutrition_cache.pkl")
-# CACHE_EXPIRY_DAYS = int(os.getenv("CACHE_EXPIRY_DAYS", "30"))  # Cache entries expire after 30 days by default
-
-CACHE_DIR = os.getenv("CACHE_DIR", "")  # Use /tmp for temporary storage
-CACHE_FILE = os.path.join(CACHE_DIR, "food_nutrition_cache.pkl")
-CACHE_EXPIRY_DAYS = int(os.getenv("CACHE_EXPIRY_DAYS", "30"))  # Default to 30 days
-
-def load_cache():
-    """Load the nutrition cache from disk."""
-    if os.path.exists(CACHE_FILE):
-        try:
-            with open(CACHE_FILE, 'rb') as f:
-                return pickle.load(f)
-        except (pickle.PickleError, EOFError):
-            print("Cache file corrupted, creating new cache")
-    return {}
-
-
-def save_cache(cache):
-    """Save the nutrition cache to disk."""
-    try:
-        # Ensure cache directory exists
-        os.makedirs(os.path.dirname(CACHE_FILE), exist_ok=True)
-        with open(CACHE_FILE, 'wb') as f:
-            pickle.dump(cache, f)
-    except Exception as e:
-        print(f"Error saving cache: {e}")
-
-
-# Initialize the cache
-nutrition_cache = load_cache()
-
-
-def clean_expired_cache_entries():
-    """Remove expired entries from the cache."""
-    current_time = time.time()
-    expiry_seconds = CACHE_EXPIRY_DAYS * 24 * 60 * 60
-    expired_keys = []
-    
-    for food_item, entry in nutrition_cache.items():
-        if current_time - entry['timestamp'] > expiry_seconds:
-            expired_keys.append(food_item)
-    
-    for key in expired_keys:
-        del nutrition_cache[key]
-    
-    if expired_keys:
-        save_cache(nutrition_cache)
-        print(f"Removed {len(expired_keys)} expired cache entries")
-
-
-def get_food_info(food_item):
-    """Fetch nutritional information with caching."""
-    # Check if the food item is in cache and not expired
-    if food_item in nutrition_cache:
-        print(f"Cache hit for {food_item}")
-        return nutrition_cache[food_item]['data']
-    
-    print(f"Cache miss for {food_item}, fetching from API")
-    # If not in cache, fetch from Gemini API
-    prompt = f"""
-    Provide the nutritional information for "{food_item}" in JSON format with the following structure:
-
-    {{
-      "food_item": "{food_item}",
-      "nutritional_info": {{
-        "calories_kcal": value,
-        "protein_g": value,
-        "fiber_g": value,
-        "vitamins": {{
-          "Vitamin A_mcg": value,
-          "Vitamin C_mg": value,
-          "Vitamin D_mcg": value,
-          "Vitamin E_mg": value,
-          "Vitamin K_mcg": value,
-          "Vitamin B1_mg": value,
-          "Vitamin B2_mg": value,
-          "Vitamin B3_mg": value,
-          "Vitamin B6_mg": value,
-          "Vitamin B12_mcg": value,
-          "Folate_mcg": value
-        }}
-      }},
-      "health_benefits": [
-        "Brief description of health benefit 1",
-        "Brief description of health benefit 2"
-      ]
-    }}
-
-    Ensure the response is **valid JSON** inside triple backticks (```json ... ```).
-    """
+from google.colab import userdata
 
-    try:
-        response = gemini_model.generate_content(prompt)
-        result = response.text if response else "No data found"
-        
-        # Store in cache with timestamp
-        nutrition_cache[food_item] = {
-            'data': result,
-            'timestamp': time.time()
-        }
-        
-        # Save updated cache
-        save_cache(nutrition_cache)
-        
-        return result
-    except Exception as e:
-        print(f"Error fetching from Gemini API: {e}")
-        return json.dumps({"error": f"Failed to retrieve data: {str(e)}"})
-
-
-def parse_nutrition_response(response_dict):
-    """Parses the raw response containing JSON-like data embedded in a string format."""
-    parsed_data = {}
-
-    for food, raw_json in response_dict.items():
-        # Extract JSON part from the response using regex
-        json_match = re.search(r"```json\n(.*?)\n```", raw_json, re.DOTALL)
-
-        if json_match:
-            json_data = json_match.group(1)  # Extract JSON content
-            try:
-                parsed_data[food] = json.loads(json_data)  # Convert JSON string to dictionary
-            except json.JSONDecodeError:
-                parsed_data[food] = {"error": "Invalid JSON format"}
-        else:
-            parsed_data[food] = {"error": "JSON not found in response"}
+app = FastAPI()
 
-    return parsed_data
-
-
-def detect_food(image: Image.Image):
-    """Detect food items in an image using YOLOv8."""
-    results = model(image)
-    detected_foods = {model.names[int(box.cls)] for result in results for box in result.boxes}
-    return list(detected_foods)
+# Set your API key
+genai.configure(api_key=userdata.get('GOOGLE_API_KEY'))
 
 @app.get("/")
 def read_root():
@@ -183,92 +19,66 @@ async def root_head():
     return {}  # Empty response for HEAD requests
 
 @app.post("/analyze")
-async def analyze_image(file: UploadFile = File(...)):
-    """API endpoint to analyze food from an image and return nutritional info."""
-    # Periodically clean expired cache entries
-    clean_expired_cache_entries()
-    
-    try:
-        # Process the image
-        contents = await file.read()
-        image = Image.open(io.BytesIO(contents))
-        detected_foods = detect_food(image)
-
-        if not detected_foods:
-            return {"message": "No food detected"}
-
-        # Get nutrition info (from cache if available)
-        raw_nutrition_info = {food: get_food_info(food) for food in detected_foods}
-        parsed_nutrition_info = parse_nutrition_response(raw_nutrition_info)
-
-        # Add cache statistics to the response
-        cache_stats = {
-            "cache_size": len(nutrition_cache),
-            "cache_hits": sum(1 for food in detected_foods if food in nutrition_cache),
-            "cache_misses": sum(1 for food in detected_foods if food not in nutrition_cache),
-            "last_cache_update": datetime.fromtimestamp(
-                max([entry['timestamp'] for entry in nutrition_cache.values()]) 
-                if nutrition_cache else time.time()
-            ).isoformat()
+async def analyze_food_image(file: UploadFile = File(...)):
+    """Analyzes food items in the image using Gemini 1.5 Flash"""
+    image_bytes = await file.read()
+    img = Image.open(io.BytesIO(image_bytes))
+
+    model = genai.GenerativeModel("gemini-1.5-flash")  # Best for real-time image processing
+
+    # Updated prompt for structured JSON response
+    prompt = """
+    Identify all food items in the given image and determine their approximate quantity. Then, provide nutritional information 
+    in valid JSON format following this structure:
+
+    ```json
+    {
+      "detected_food_items": [
+        {
+          "food_item": "Detected food name",
+          "quantity": "Approximate quantity (e.g., 1 bowl, 2 slices, half a chapati)",
+          "nutritional_info": {
+            "calories_kcal": value,
+            "protein_g": value,
+            "fiber_g": value,
+            "vitamins": {
+              "Vitamin A_mcg": value,
+              "Vitamin C_mg": value,
+              "Vitamin D_mcg": value,
+              "Vitamin E_mg": value,
+              "Vitamin K_mcg": value,
+              "Vitamin B1_mg": value,
+              "Vitamin B2_mg": value,
+              "Vitamin B3_mg": value,
+              "Vitamin B6_mg": value,
+              "Vitamin B12_mcg": value,
+              "Folate_mcg": value
+            }
+          },
+          "health_benefits": [
+            "Brief description of health benefit 1",
+            "Brief description of health benefit 2"
+          ]
         }
-
-        return {
-            "detected_foods": detected_foods,
-            "nutrition_info": parsed_nutrition_info,
-            "cache_stats": cache_stats
-        }
-    except Exception as e:
-        return {"error": f"An error occurred: {str(e)}"}
-
-
-# Add endpoints to manage the cache
-@app.get("/cache/stats")
-async def get_cache_stats():
-    """Get statistics about the nutrition cache."""
-    if not nutrition_cache:
-        return {"message": "Cache is empty"}
-    
-    return {
-        "cache_size": len(nutrition_cache),
-        "foods_cached": list(nutrition_cache.keys()),
-        "oldest_entry": datetime.fromtimestamp(
-            min([entry['timestamp'] for entry in nutrition_cache.values()])
-        ).isoformat(),
-        "newest_entry": datetime.fromtimestamp(
-            max([entry['timestamp'] for entry in nutrition_cache.values()])
-        ).isoformat()
+      ]
     }
+    ```
 
+    - **Ensure the response is valid JSON** inside triple backticks (```json ... ```).
+    - **Include accurate nutritional values based on the given quantity.**
+    - **If exact values are unavailable, provide estimated values.**
+    - **Ensure proper formatting and completeness of data.**
+    """
 
-@app.delete("/cache/clear")
-async def clear_cache():
-    """Clear the nutrition cache."""
-    global nutrition_cache
-    nutrition_cache = {}
-    save_cache(nutrition_cache)
-    return {"message": "Cache cleared successfully"}
-
-
-@app.delete("/cache/item/{food_item}")
-async def delete_cache_item(food_item: str):
-    """Delete a specific food item from the cache."""
-    if food_item in nutrition_cache:
-        del nutrition_cache[food_item]
-        save_cache(nutrition_cache)
-        return {"message": f"Removed {food_item} from cache"}
-    return {"message": f"{food_item} not found in cache"}
-
+    # Get response from API
+    response = model.generate_content([prompt, img])
 
-# Add health check endpoint for production deployments
-@app.get("/health")
-async def health_check():
-    """Health check endpoint for monitoring."""
-    return {
-        "status": "healthy",
-        "cache_size": len(nutrition_cache),
-        "yolo_model_loaded": model is not None,
-        "gemini_api_configured": GOOGLE_API_KEY != ""
-    }
+    # Extract JSON response
+    try:
+        json_response = response.text.strip("```json").strip("```")  # Remove markdown formatting
+        return json.loads(json_response)  # Convert to Python dictionary
+    except json.JSONDecodeError:
+        return {"error": "Invalid response format from AI model"}
 
 import os