bug fix and improvements

main.py

@@ -10,6 +10,8 @@ from dotenv import load_dotenv
 import os
 import uvicorn
 from pathlib import Path
+import tensorflow as tf
+import tensorflow_hub as hub
 
 load_dotenv()
 # Load environment variables from .env file
@@ -20,6 +22,17 @@ templates = Jinja2Templates(directory="templates")
 
 app = FastAPI()
 
+# Suppress TensorFlow warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # 0=all, 1=no INFO, 2=no WARNING, 3=no ERROR
+
+# Store the model as a state variable in the app
+@app.on_event("startup")
+async def startup_event():
+    # Load model once during startup
+    print("Loading TensorFlow model...")
+    app.state.detector = hub.load("https://tfhub.dev/google/openimages_v4/ssd/mobilenet_v2/1").signatures['default']
+    print("TensorFlow model loaded successfully!")
+
 @app.get("/")
 def read_root():
     return RedirectResponse("/api")

routers/analysis.py

@@ -94,13 +94,26 @@ async def process_ingredients_endpoint(product_ingredient: ProductIngredientsReq
                 
         # Step 2: Generate aggregate analysis with product analyzer agent
         
+        # Safely get user preferences, handling the case where the preferences table doesn't exist
+        user_preferences = {}
+        if current_user:
+            user_preferences["user_id"] = current_user.id
+            try:
+                # Only try to access preferences if the relationship exists
+                if hasattr(current_user, 'preferences') and current_user.preferences:
+                    user_preferences["allergies"] = current_user.preferences[0].allergens
+                    user_preferences["dietary_restrictions"] = current_user.preferences[0].dietary_restrictions
+                else:
+                    user_preferences["allergies"] = None
+                    user_preferences["dietary_restrictions"] = None
+            except Exception as e:
+                log_error(f"Error accessing user preferences: {e}", e)
+                user_preferences["allergies"] = None
+                user_preferences["dietary_restrictions"] = None
+        
         product_analysis = await analyze_product_ingredients(
             ingredients_data=ingredient_results,
-            user_preferences={
-                "user_id": current_user.id,
-                "allergies": current_user.preferences[0].allergens if current_user.preferences else None,
-                "dietary_restrictions": current_user.preferences[0].dietary_restrictions if current_user.preferences else None
-            } if current_user else {}
+            user_preferences=user_preferences
         )
         
         # print("Product analysis result:", product_analysis)

routers/product.py

@@ -26,26 +26,13 @@ from dotenv import load_dotenv
 from services.ingredients import IngredientService 
 from services.productAnalyzerAgent import analyze_product_ingredients
 from utils.db_utils import add_product_to_database
+from utils.vuforia_utils import add_target_to_vuforia, UPLOADED_IMAGES_DIR
 from utils.fetch_data import fetch_product_data_from_api
+import uuid
 
 
 load_dotenv()
 
-
-UPLOADED_IMAGES_DIR = "uploaded_images"
-if not os.path.exists(UPLOADED_IMAGES_DIR):
-    os.makedirs(UPLOADED_IMAGES_DIR)
-
-
-# TensorFlow model caching
-detector = None
-
-
-def load_detector():
-    global detector
-    if detector is None:
-        detector = hub.load("https://tfhub.dev/google/openimages_v4/ssd/mobilenet_v2/1").signatures['default']
-
 VUFORIA_SERVER_ACCESS_KEY = os.getenv("VUFORIA_SERVER_ACCESS_KEY")
 VUFORIA_SERVER_SECRET_KEY = os.getenv("VUFORIA_SERVER_SECRET_KEY")
 VUFORIA_TARGET_DATABASE_NAME = os.getenv("VUFORIA_TARGET_DATABASE_NAME")
@@ -56,12 +43,11 @@ router = APIRouter()
 
 TARGET_CLASSES = set(["Food processor", "Fast food", "Food", "Seafood", "Snack"])
 
-def run_object_detection(image: Image.Image):
-    load_detector()  # Ensure model is loaded
+def run_object_detection(image: Image.Image, request: Request):
+    # Access the model from app state
+    detector = request.app.state.detector
     image_np = np.array(image)
-    # Convert to tensor without specifying dtype
     input_tensor = tf.convert_to_tensor(image_np)[tf.newaxis, ...]
-    # Convert to float32 and normalize to [0,1]
     input_tensor = tf.cast(input_tensor, tf.float32) / 255.0
     results = detector(input_tensor)
     results = {k: v.numpy() for k, v in results.items()}
@@ -70,26 +56,25 @@ def run_object_detection(image: Image.Image):
 def get_filtered_class_boxes(results):
     # for same class, keep the one with the highest score
     # and remove duplicates
-    boxes = []
-    classes = []
-    scores = []
+    high_boxes = None
+    high_classes = None
+    high_scores = None
 
     for i in range(len(results["detection_scores"])):
         class_name = results["detection_class_entities"][i].decode("utf-8")
         box = results["detection_boxes"][i]
         score = results["detection_scores"][i]
         if class_name in TARGET_CLASSES:
-            if class_name not in classes:
-                boxes.append(box)
-                classes.append(class_name)
-                scores.append(score)
+            if high_boxes is None:
+                high_boxes = box
+                high_classes = class_name
+                high_scores = score
             else:
-                index = classes.index(class_name)
-                if score > scores[index]:
-                    boxes[index] = box
-                    classes[index] = class_name
-                    scores[index] = score
-    return boxes, classes, scores
+                if score > high_scores:
+                    high_boxes = box
+                    high_classes = class_name
+                    high_scores = score
+    return high_boxes, high_classes, high_scores
 
 def crop_image(image_np, box):
     ymin, xmin, ymax, xmax = box
@@ -179,7 +164,7 @@ async def create_product(
 
 
 @router.post("/process_image")
-async def process_image_endpoint(file: UploadFile = File(...), db: Session = Depends(get_db)):
+async def process_image_endpoint(file: UploadFile = File(...), db: Session = Depends(get_db), request: Request = None):
     """
     Receives an image file, performs object detection, and returns information about detected objects.
     """
@@ -189,34 +174,30 @@ async def process_image_endpoint(file: UploadFile = File(...), db: Session = Dep
         image_data = await file.read()
         image = Image.open(io.BytesIO(image_data)).convert("RGB")
 
-        # Run object detection
-        results, image_np = run_object_detection(image)
+        # Run object detection with the request object
+        results, image_np = run_object_detection(image, request)
 
         # Get filtered class boxes
-        boxes, class_names, scores = get_filtered_class_boxes(results)
+        box, class_name, score = get_filtered_class_boxes(results)
 
-        detected_objects = []
-        for i in range(len(boxes)):
             # Crop the detected object
-            cropped_img = crop_image(image_np, boxes[i])
-
-            # Save the cropped image temporarily
-            cropped_image_path = os.path.join(UPLOADED_IMAGES_DIR, f"detected_{class_names[i]}_{scores[i]:.2f}.jpg")
-            cropped_img.save(cropped_image_path)
+        cropped_img = crop_image(image_np, box)
 
-            # Find if a product with this image exists in the database
-            product_repo = ProductRepository(db)
-            product = product_repo.get_product_by_image_name(os.path.basename(cropped_image_path))
-
-            detected_objects.append({
-                "class_name": class_names[i],
-                "score": float(scores[i]),
-                "product_info": product.to_dict() if product else None  # Assuming Product model has a to_dict method
-            })
+        # Save the cropped image temporarily
+        unique_id = uuid.uuid4().hex
+        cropped_image_name = f"detected_{class_name}_{score:.2f}_{unique_id}.jpg"
+        cropped_image_path = os.path.join(
+            UPLOADED_IMAGES_DIR, cropped_image_name
+        )
+        cropped_img.save(cropped_image_path)
 
-        return JSONResponse({"detected_objects": detected_objects})
+        return JSONResponse({
+            "class_name": class_name,
+            "score": float(score),
+            "image_name": cropped_image_name
+        })
     except Exception as e:
-        log_error(f"Error processing image: {e}", exc_info=True)
+        log_error(f"Error processing image: {e}", e)
         raise HTTPException(status_code=500, detail=f"Error processing image: {e}")
 
 

utils/db_utils.py

@@ -1,3 +1,4 @@
+from typing import Dict, List,Any
 from sqlalchemy.orm import Session
 from interfaces.ingredientModels import IngredientAnalysisResult
 from interfaces.productModels import ProductCreate
@@ -6,21 +7,61 @@ from logger_manager import log_info, log_error
 from fastapi import HTTPException
 import os
 from services.product_service import ProductService
-from routers.product import add_target_to_vuforia, UPLOADED_IMAGES_DIR # Assuming add_target_to_vuforia and UPLOADED_IMAGES_DIR are needed and will remain in product.py for now. If they are also moved, the import needs adjustment.
+from utils.vuforia_utils import add_target_to_vuforia, UPLOADED_IMAGES_DIR # Assuming add_target_to_vuforia and UPLOADED_IMAGES_DIR are needed and will remain in product.py for now. If they are also moved, the import needs adjustment.
+import json
 
 
 def ingredient_db_to_pydantic(db_ingredient):
     """Convert a database ingredient model to a Pydantic model."""
-    return IngredientAnalysisResult(
-        name=db_ingredient.name,
-        alternate_names=db_ingredient.alternate_names or [],
-        is_found=True,
-        id=db_ingredient.id,
-        safety_rating=db_ingredient.safety_rating or 5,
-        description=db_ingredient.description or "No description available",
-        health_effects=db_ingredient.health_effects or ["Unknown"],
-        details_with_source=[source.data for source in db_ingredient.sources]
-    )
+    try:
+        # Parse string fields that should be lists or dictionaries
+        if isinstance(db_ingredient.alternate_names, str):
+            alternate_names = json.loads(db_ingredient.alternate_names)
+        else:
+            alternate_names = db_ingredient.alternate_names or []
+            
+        if isinstance(db_ingredient.health_effects, str):
+            health_effects = json.loads(db_ingredient.health_effects)
+        else:
+            health_effects = db_ingredient.health_effects or ["Unknown"]
+            
+        # Handle details_with_source, which should be a list of dictionaries
+        if hasattr(db_ingredient, 'sources') and db_ingredient.sources:
+            details = []
+            for source in db_ingredient.sources:
+                if isinstance(source.data, str):
+                    try:
+                        details.append(json.loads(source.data))
+                    except json.JSONDecodeError:
+                        details.append({"source": "Unknown", "data": source.data})
+                else:
+                    details.append(source.data)
+        else:
+            details = []
+            
+        return IngredientAnalysisResult(
+            name=db_ingredient.name,
+            alternate_names=alternate_names,
+            is_found=True,
+            id=db_ingredient.id,
+            safety_rating=db_ingredient.safety_rating or 5,
+            description=db_ingredient.description or "No description available",
+            health_effects=health_effects,
+            details_with_source=details
+        )
+    except Exception as e:
+        log_error(f"Error converting DB ingredient to Pydantic model: {e}", e)
+        # Fallback with minimal valid data
+        return IngredientAnalysisResult(
+            name=db_ingredient.name,
+            alternate_names=[],
+            is_found=True,
+            id=db_ingredient.id,
+            safety_rating=db_ingredient.safety_rating or 5,
+            description=db_ingredient.description or "No description available",
+            health_effects=["Unknown"],
+            details_with_source=[]
+        )
 
 
 async def add_product_to_database(

utils/ingredient_utils.py

@@ -4,11 +4,14 @@ from sqlalchemy.orm import Session
 from db.database import SessionLocal
 from db.repositories import IngredientRepository
 from interfaces.ingredientModels import IngredientAnalysisResult
+from logger_manager import log_error, log_info
 from services.ingredientFinderAgent import IngredientInfoAgentLangGraph
 from dotenv import load_dotenv
 from langsmith import traceable
 import pytz
 
+from utils.db_utils import ingredient_db_to_pydantic
+
 # Load environment variables
 load_dotenv()
 
@@ -20,45 +23,49 @@ llm_semaphore = asyncio.Semaphore(PARALLEL_RATE_LIMIT)
 
 
 @traceable
-async def process_single_ingredient(ingredient_name: str):
+async def process_single_ingredient(ingredient_name: str) -> IngredientAnalysisResult:
     """Process a single ingredient asynchronously with rate limiting"""
-    # Create a new DB session for this specific task to avoid conflicts
-    session = SessionLocal()
-
     try:
-        # Check if ingredient exists in database
-        repo = IngredientRepository(session)
-        db_ingredient = repo.get_ingredient_by_name(ingredient_name)
-
-        if db_ingredient:
-            # Assuming ingredient_db_to_pydantic is now in a utils file, e.g., utils.db_utils
-            from .db_utils import ingredient_db_to_pydantic
-            ingredient_data = ingredient_db_to_pydantic(db_ingredient)
-            return ingredient_data
-        else:
-            # Apply rate limiting for LLM calls only if not in database
-            async with llm_semaphore:
-                # Get from agent if not in database
-                ingredient_finder = IngredientInfoAgentLangGraph()
-
-                ingredient_data = await ingredient_finder.process_ingredient_async(ingredient_name)
-
-                # Save to database for future use
-                repo.create_ingredient(ingredient_data)
-
-                return ingredient_data
+        # First check if ingredient exists in the database
+        with SessionLocal() as db:
+            repo = IngredientRepository(db)
+            db_ingredient = repo.get_ingredient_by_name(ingredient_name)
+            
+            if db_ingredient:
+                log_info(f"Using cached ingredient data for: {ingredient_name}")
+                return ingredient_db_to_pydantic(db_ingredient)
+        
+        # If not in database, process it
+        log_info(f"Processing new ingredient: {ingredient_name}")
+        ingredient_finder = IngredientInfoAgentLangGraph()
+        
+        try:
+            result = await ingredient_finder.process_ingredient_async(ingredient_name)
+        except RuntimeError:
+            result = ingredient_finder.process_ingredient(ingredient_name)
+        
+        # Important: Add an id field even for new ingredients
+        # You can use a temporary id (will be replaced when saved to DB)
+        result.id = 0  # Temporary ID
+        
+        # Save to database for future use
+        with SessionLocal() as db:
+            repo = IngredientRepository(db)
+            db_ingredient = repo.create_ingredient(result)
+            # Update with the real database ID
+            result.id = db_ingredient.id
+            
+        return result
     except Exception as e:
-        # Return a minimal result on error to avoid failing the entire batch
+        log_error(f"Error processing ingredient {ingredient_name}: {e}", e)
+        # Return a minimal valid result for failed ingredients
         return IngredientAnalysisResult(
             name=ingredient_name,
             is_found=False,
+            id=0,  # Add this missing required field
+            alternate_names=[],
             safety_rating=0,
-            description=f"Error during processing: {str(e)}",
-            health_effects=["Error during processing"],
-            allergic_info=[],
-            diet_type="unknown",
+            description="Error processing this ingredient",
+            health_effects=["Unknown"],
             details_with_source=[]
-        )
-    finally:
-        # Important: Close the session when done
-        session.close()
+        )

utils/vuforia_utils.py

@@ -0,0 +1,64 @@
+import json
+from logger_manager import log_info, log_error
+from PIL import Image
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+import requests
+load_dotenv()
+
+UPLOADED_IMAGES_DIR = "uploaded_images"
+if not os.path.exists(UPLOADED_IMAGES_DIR):
+    os.makedirs(UPLOADED_IMAGES_DIR)
+
+
+VUFORIA_SERVER_ACCESS_KEY = os.getenv("VUFORIA_SERVER_ACCESS_KEY")
+VUFORIA_SERVER_SECRET_KEY = os.getenv("VUFORIA_SERVER_SECRET_KEY")
+VUFORIA_TARGET_DATABASE_NAME = os.getenv("VUFORIA_TARGET_DATABASE_NAME")
+VUFORIA_TARGET_DATABASE_ID = os.getenv("VUFORIA_TARGET_DATABASE_ID")
+
+def get_vuforia_auth_headers():
+    """
+    Returns the authentication headers for Vuforia API requests.
+    """
+    return {
+        "Authorization": f"VWS {VUFORIA_SERVER_ACCESS_KEY}:{VUFORIA_SERVER_SECRET_KEY}",
+        "Content-Type": "application/json",
+    }
+
+
+async def add_target_to_vuforia(image_name: str, image_path: str) -> str:
+    """
+    Adds a target to the Vuforia database and returns the Vuforia target ID.
+    """
+    log_info(f"Adding target {image_name} to Vuforia")
+
+    try:
+        with open(image_path, "rb") as image_file:
+            image_data = image_file.read()
+
+        url = f"https://vws.vuforia.com/targets"
+
+        headers = get_vuforia_auth_headers()
+        payload = {
+            "name": image_name,
+            "width": 1.0,  # Default width
+            "image": image_data.hex(),  # Convert image data to hex
+            "active_flag": True,
+        }
+
+        response = await requests.post(url, headers=headers, json=payload)
+        response_data = json.loads(response.text)
+        if response.status_code == 201:
+            log_info(
+                f"Target {image_name} added successfully with Vuforia ID: {response_data['target_id']}"
+            )
+            return response_data["target_id"]
+        else:
+            log_error(f"Failed to add target {image_name}: {response.text}")
+            raise Exception(f"Failed to add target {image_name}: {response.text}")
+    except Exception as e:
+        log_error(f"Error adding target {image_name}: {e}",e)
+        raise
+
+