Merge branch 'main' of https://github.com/prathameshks/FoodAnalyzer-API

.gitattributes

@@ -0,0 +1 @@
+models/mobile_sam.pt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,7 +1,5 @@
 # Ignore sensitive data
 .env
-alembic.ini
-
 
 debug*
 
@@ -23,5 +21,10 @@ env/
 .idea/
 *.swp
 
+# Ignore uploads directory
 uploaded_images/
+
+# But track this specific file
+!uploaded_images/detected_Snack_0.13_db8318a668504073ad5fd0677187d305.jpg
+
 *.pt

Dockerfile

@@ -0,0 +1,22 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.12
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Fix: Copy files to /app instead of /main to match WORKDIR
+COPY --chown=user . /app
+
+# Make sure models directory exists
+RUN mkdir -p /app/models
+
+# Run the app using port 7860 (standard for HF Spaces)
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,3 +1,14 @@
+---
+license: mit
+title: Food Analyzer API
+sdk: docker
+emoji: 🔥
+colorFrom: red
+colorTo: purple
+pinned: true
+short_description: Fast API
+---
+
 # FoodAnalyzer-API
 
 ## Installation and Setup

app.py

@@ -0,0 +1 @@
+from main import app

db/database.py

@@ -2,16 +2,8 @@ import os
 from sqlalchemy import create_engine
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker
-from dotenv import load_dotenv
 
-# Load environment variables
-load_dotenv()
-
-# Get database URL from environment variable
-DATABASE_URL = os.getenv(
-    "DATABASE_URL", 
-    "postgresql://postgres:password@localhost:5432/food_ingredients"
-)
+from env import DATABASE_URL
 
 # Create engine
 engine = create_engine(DATABASE_URL)

db/repositories.py

@@ -1,3 +1,4 @@
+import json
 from sqlalchemy.orm import Session
 from sqlalchemy import cast, or_, String
 from sqlalchemy.dialects.postgresql import JSONB
@@ -38,15 +39,24 @@ class IngredientRepository:
         return self.db.query(models.Ingredient).offset(skip).limit(limit).all()
     
     def create_ingredient(self, ingredient_data: IngredientAnalysisResult):
+        # convert the json data to string using json.dumps
+        name = ingredient_data.name
+        alternate_names = json.dumps(ingredient_data.alternate_names)
+        safety_rating = ingredient_data.safety_rating
+        description = ingredient_data.description
+        health_effects = json.dumps(ingredient_data.health_effects)
+        allergic_info = json.dumps(ingredient_data.allergic_info) if ingredient_data.allergic_info else None
+        diet_type = ingredient_data.diet_type
+        
         # Create ingredient record
         db_ingredient = models.Ingredient(
-            name=ingredient_data.name,
-            alternate_names=ingredient_data.alternate_names,
-            safety_rating=ingredient_data.safety_rating,
-            description=ingredient_data.description,
-            health_effects=ingredient_data.health_effects,
-            allergic_info=ingredient_data.allergic_info,
-            diet_type=ingredient_data.diet_type
+            name=name,
+            alternate_names=alternate_names,
+            safety_rating=safety_rating,
+            description=description,
+            health_effects=health_effects,
+            allergic_info=allergic_info,
+            diet_type=diet_type
         )
         self.db.add(db_ingredient)
         self.db.commit()
@@ -102,7 +112,7 @@ class ProductRepository:
     
     def add_product(self, product_create: ProductCreate):
         db_product = self._create_product(product_create)
-        self._store_analysis_data(db_product, product_create.ingredients_analysis)
+        # self._store_analysis_data(db_product, product_create.ingredients_analysis)
         return db_product
 
     def _create_product(self, product_create: ProductCreate):

env.py

@@ -0,0 +1,80 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+# Environment variables for FoodAnalyzer-API
+PORT = int(os.getenv("PORT", 8000))
+UPLOADED_IMAGES_DIR = "uploaded_images"
+if not os.path.exists(UPLOADED_IMAGES_DIR):
+    os.makedirs(UPLOADED_IMAGES_DIR)
+    
+# JWT Secret Key
+SECRET_KEY = os.getenv("SECRET_KEY", "09d8f7a6b5c4e3d2f1a0b9c8d7e6f5a4")
+ALGORITHM = os.getenv("ALGORITHM", "HS256")
+ACCESS_TOKEN_EXPIRE_MINUTES = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", 30))
+
+# Hugging Face Transformers API key not required
+# HUGGING_FACE_API_KEY = os.getenv("HUGGING_FACE_API_KEY", None)
+# OpenAI API key not required
+# OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", None)
+
+# API keys and model names for different LLMs here 
+# for google ai studio
+LLM_API_KEY = os.getenv("LLM_API_KEY", None)
+LLM_MODEL_NAME = os.getenv("LLM_MODEL_NAME", "gemini-2.0-flash")
+
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY", None)
+GOOGLE_CSE_ID = os.getenv("GOOGLE_CSE_ID", None)
+
+USDA_API_KEY = os.getenv("USDA_API_KEY", "DEMO_KEY")
+
+# pg db url
+DATABASE_URL = os.getenv("DATABASE_URL", None)
+
+# Vuforia keys
+VUFORIA_SERVER_ACCESS_KEY = os.getenv("VUFORIA_SERVER_ACCESS_KEY", None)
+VUFORIA_SERVER_SECRET_KEY = os.getenv("VUFORIA_SERVER_SECRET_KEY", None)
+VUFORIA_TARGET_DATABASE_NAME = os.getenv("VUFORIA_TARGET_DATABASE_NAME", "FoodAnalyzer_BE_PROJ")
+VUFORIA_TARGET_DATABASE_ID = os.getenv("VUFORIA_TARGET_DATABASE_ID", "FoodAnalyzer_BE_PROJ")
+
+# langsmith keys optional
+LANGSMITH_TRACING = os.getenv("LANGSMITH_TRACING", True)
+LANGSMITH_ENDPOINT = os.getenv("LANGSMITH_ENDPOINT", "https://api.smith.langchain.com")
+LANGSMITH_API_KEY = os.getenv("LANGSMITH_API_KEY", None)
+LANGSMITH_PROJECT = os.getenv("LANGSMITH_PROJECT", None)
+
+# app settings
+PARALLEL_RATE_LIMIT = int(os.getenv("PARALLEL_RATE_LIMIT", 10))
+
+# Rate limiting configuration in seconds
+PUBCHEM_TIMEOUT = int(os.getenv("PUBCHEM_TIMEOUT", 2))
+PUBCHEM_MAX_RETRIES = int(os.getenv("PUBCHEM_MAX_RETRIES", 2))
+
+# Delay in seconds
+DUCKDUCKGO_RATE_LIMIT_DELAY = int(os.getenv("DUCKDUCKGO_RATE_LIMIT_DELAY", 2))
+DUCKDUCKGO_MAX_RETRIES = int(os.getenv("DUCKDUCKGO_MAX_RETRIES", 2))
+
+# fake response for testing
+SEND_FAKE_TARGET = os.getenv("SEND_FAKE_TARGET", False) == "true"
+FAKE_TARGET_IMAGE_NAME = os.getenv("FAKE_TARGET_IMAGE_NAME", "detected_Snack_0.13_db8318a668504073ad5fd0677187d305.jpg")
+
+# Define Required Environment Variables and show error if not set
+required_env_vars = {
+    "LLM_API_KEY":LLM_API_KEY,
+    "GOOGLE_API_KEY":GOOGLE_API_KEY,
+    "GOOGLE_CSE_ID":GOOGLE_CSE_ID,
+    "USDA_API_KEY":USDA_API_KEY,
+    "DATABASE_URL":DATABASE_URL,
+    "VUFORIA_SERVER_ACCESS_KEY":VUFORIA_SERVER_ACCESS_KEY,
+    "VUFORIA_SERVER_SECRET_KEY":VUFORIA_SERVER_SECRET_KEY,
+    "VUFORIA_TARGET_DATABASE_NAME":VUFORIA_TARGET_DATABASE_NAME,
+    "VUFORIA_TARGET_DATABASE_ID":VUFORIA_TARGET_DATABASE_ID,
+}
+
+# Check if all required environment variables are set
+for var in required_env_vars.keys():
+    if required_env_vars[var] is None:
+        raise ValueError(f"Environment variable {var} is not set. Please set it in the .env file.")

interfaces/productModels.py

@@ -8,17 +8,17 @@ class ProductIngredientsRequest(BaseModel):
 
 class ProductCreate(BaseModel):
     product_name: str
-    ingredients: List[str]
+    ingredients: List[str]|str
     overall_safety_score: int
     suitable_diet_types: str
-    allergy_warnings: List[str]
+    allergy_warnings: List[str]|str
     usage_recommendations: str
-    health_insights: Dict[str, List[str]]
-    ingredient_interactions: List[str]
+    health_insights: Dict[str, List[str]]|str
+    ingredient_interactions: List[str]|str
     key_takeaway: str
     ingredients_count: int
     user_id: int
     timestamp: datetime
-    ingredient_ids: List[int]
+    ingredient_ids: List[int]|str
 
 

main.py

@@ -6,25 +6,36 @@ from routers.auth import router as auth_router
 from routers.analysis import router as analysis_router
 from routers.history import router as history_router
 from routers.product import router as product_router
-from dotenv import load_dotenv
 import os
 import uvicorn
 from pathlib import Path
+import tensorflow as tf
+import tensorflow_hub as hub
+from env import PORT
 
-load_dotenv()
-# Load environment variables from .env file
-PORT = os.getenv("PORT", 8000)
 
 # Define the templates directory
 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")
 
 # print every request data for request using middleware
+
 @app.middleware("http")
 async def log_requests(request: Request, call_next):
     # Store the body content before sending to the next handler
@@ -33,7 +44,7 @@ async def log_requests(request: Request, call_next):
     request._body = body_content
     response = await call_next(request)
     print(f"Request: {request.method} {request.url}")
-    # print(f"Data: {body_content}")
+    print(f"Data: {body_content}"[:100])
     print(f"Headers: {request.headers}")
     return response
 

requirements.txt

@@ -2,14 +2,15 @@
 fastapi==0.115.12
 uvicorn==0.34.0
 python-multipart==0.0.20
-jinja2
+jinja2==3.1.6
+aiohttp==3.11.16
 
 # Database
 sqlalchemy==2.0.40
 alembic==1.15.2
 psycopg2-binary==2.9.10
-mysqlclient
-pymysql
+mysqlclient==2.2.7
+pymysql==1.1.1
 
 # Authentication
 python-jose==3.3.0
@@ -19,16 +20,16 @@ bcrypt==4.0.1  # Using 4.0.1 to avoid the attribute error
 # AI & ML
 langchain==0.3.23
 langchain-community==0.3.21
-langchain-google-genai
+langchain-google-genai==2.0.10
 langchain-openai==0.3.12
-google-generativeai
+google-generativeai==0.8.4
 openai==1.73.0
 langgraph==0.3.27
 langsmith==0.3.30
 
 # Computer Vision
-tensorflow
-tensorflow_hub
+tensorflow==2.19.0
+tensorflow_hub==0.16.1
 pillow==11.1.0
 opencv-python==4.11.0.86
 pytesseract==0.3.13

routers/analysis.py

@@ -8,7 +8,7 @@ import pytz
 from sqlalchemy.orm import Session
 from typing import List, Dict, Any
 from db.models import User, Ingredient
-from interfaces.ingredientModels import IngredientAnalysisResult
+from interfaces.ingredientModels import IngredientAnalysisResult, IngredientRequest
 from interfaces.productModels import ProductIngredientsRequest
 from logger_manager import log_info, log_error
 from db.database import get_db,SessionLocal
@@ -94,17 +94,30 @@ 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)
-        
+         
         # Step 3: Prepare final response
         result = {
             "ingredients_count": len(ingredients),
@@ -139,5 +152,5 @@ async def get_analysis_by_marker_id(target_id: str, db: Session = Depends(get_db
         return product_data
 
     except Exception as e:
-        log_error(f"Error in get_analysis_by_marker_id: {str(e)}", e)
-        raise HTTPException(status_code=500, detail="Internal Server Error")
+        log_error(f"Error in get_analysis_by_marker_id: {str(e)}", e) 
+        raise HTTPException(status_code=500, detail="Internal Server Error")

routers/product.py

@@ -1,9 +1,11 @@
+from datetime import datetime
 import io
 from fastapi import APIRouter, Request, HTTPException, File, UploadFile, Form
 from fastapi.responses import JSONResponse, FileResponse
 from typing import List, Dict, Any
 from logger_manager import log_debug, log_info, log_error
 import os
+from services.auth_service import get_current_user
 from services.product_service import ProductService
 from db.models import Marker, Product
 from sqlalchemy.orm import Session
@@ -20,47 +22,29 @@ from db.database import get_db
 from fastapi import Depends
 from db.repositories import ProductRepository, IngredientRepository
 
-from dotenv import load_dotenv
 
 
 from services.ingredients import IngredientService 
 from services.productAnalyzerAgent import analyze_product_ingredients
+from utils.analyze import process_product_ingredients
+from utils.db_utils import add_product_to_database
 from utils.fetch_data import fetch_product_data_from_api
+import uuid
+import json
 
-
-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")
-VUFORIA_TARGET_DATABASE_ID = os.getenv("VUFORIA_TARGET_DATABASE_ID")
+# import environment variables
+from env import FAKE_TARGET_IMAGE_NAME, SEND_FAKE_TARGET,UPLOADED_IMAGES_DIR, VUFORIA_SERVER_ACCESS_KEY,VUFORIA_SERVER_SECRET_KEY,VUFORIA_TARGET_DATABASE_NAME,VUFORIA_TARGET_DATABASE_ID
 
 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()}
@@ -69,26 +53,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
@@ -103,119 +86,167 @@ def crop_image(image_np, box):
 
 @router.post("/add")
 async def create_product(
-    request: Request, db: Session = Depends(get_db)
+    request: Request,
+    db: Session = Depends(get_db)
 ):
     """Endpoint to add a new product, its ingredients, and associated markers."""
     try:
         log_info("Create product endpoint called")
-        data = await request.json()
-        print("Received data:", data)
-
-        # Extract product details and data from request body
+        # Get the request body
+        form_data = await request.form()
+        name = form_data.get("name")
+        image_name = form_data.get("image_name")
+
+        # Extract all ingredients[] fields as a list
+        ingredients_list = []
+        for key, value in form_data.multi_items():
+            if key == "ingredients[]":
+                ingredients_list.append(value)
+                
+        log_debug(f"Received product name: {name}")
+        log_debug(f"Received ingredients: {ingredients_list}")
+        log_debug(f"Received image name: {image_name}")
+            
+        # Save the uploaded image
+        image_path = os.path.join(UPLOADED_IMAGES_DIR, image_name)
+
+        # analyze the product ingredients
+        results = await process_product_ingredients(ingredients_list)
+        
+        # extract data from the analysis results 
+        #         result = {
+        #     "ingredients_count": len(product_ingredients),
+        #     "processed_ingredients": ingredient_results,
+        #     "ingredient_ids": product_analysis["ingredient_ids"],
+        #     "overall_analysis": product_analysis,
+        #     "timestamp": datetime.now(tz=pytz.timezone('Asia/Kolkata')).isoformat()
+        # }
+        # {{
+        # "overall_safety_score": (number between 1-10),
+        # "suitable_diet_types": (strings from "Vegan", "Vegetarian", "Non-Vegetarian"),
+        # "allergy_warnings": (array of strings),
+        # "usage_recommendations": (string with specific guidance),
+        # "health_insights": {{
+        # "benefits": (array of strings),
+        # "concerns": (array of strings)
+        # }},
+        # "ingredient_interactions": (array of strings),
+        # "key_takeaway": (string)
+        # }}
         
-        image_names: List[str] = data.get("image_names")
+        # Check if the analysis results are valid
+        analysis_results = results.get("overall_analysis", {})
+        overall_safety_score = analysis_results.get("overall_safety_score", 0)
+        suitable_diet_types = analysis_results.get("suitable_diet_types", [])
+        allergy_warnings = analysis_results.get("allergy_warnings", [])
+        usage_recommendations = analysis_results.get("usage_recommendations", "")
+        health_insights = analysis_results.get("health_insights", {})
+        ingredient_interactions = analysis_results.get("ingredient_interactions", [])
+        key_takeaway = analysis_results.get("key_takeaway", "")
         
-        # Parse ProductCreate model from data
+        current_user_id = 0
+        try:
+            current_user = await get_current_user()
+            current_user_id = current_user.id
+        except:
+            # Handle case where user is not authenticated
+            log_error("User not authenticated, using default user ID")
+            current_user_id = 0  # Default user ID, change as needed
+        
+        # Create product data model
         product_create_data = ProductCreate(
-            product_name=data.get("name"),
-            ingredients=data.get("ingredients"),
-            overall_safety_score=data.get("overall_safety_score"),
-            suitable_diet_types=data.get("suitable_diet_types"),
-            allergy_warnings=data.get("allergy_warnings"),
-            usage_recommendations=data.get("usage_recommendations"),
-            health_insights=data.get("health_insights"),
-            ingredient_interactions=data.get("ingredient_interactions"),
-            key_takeaway=data.get("key_takeaway"),
-            ingredients_count=data.get("ingredients_count"),
-            user_id=data.get("user_id"),
-            timestamp=data.get("timestamp"),
-            ingredient_ids=[]  
+            product_name=name,
+            ingredients=json.dumps(ingredients_list),
+            overall_safety_score=overall_safety_score,
+            suitable_diet_types=json.dumps(suitable_diet_types),
+            allergy_warnings=json.dumps(allergy_warnings),
+            usage_recommendations=usage_recommendations,
+            health_insights=json.dumps(health_insights),
+            ingredient_interactions=json.dumps(ingredient_interactions),
+            key_takeaway=json.dumps(key_takeaway),
+            ingredients_count=results.get("ingredients_count", 0),
+            user_id=current_user_id,  # Can be updated later if needed
+            timestamp=results.get("timestamp", datetime.now().isoformat()),
+            ingredient_ids=json.dumps(results.get("ingredient_ids", [])),
         )
 
-        # Find ingredients and append their IDs
-        ingredient_repo = IngredientRepository(db)
-        for ingredient_name in product_create_data.ingredients:
-            ingredient = ingredient_repo.get_ingredient_by_name(ingredient_name)
-            if ingredient:
-                product_create_data.ingredient_ids.append(ingredient.id)
-
-        # Analyze product ingredients and store analysis data
-        ingredient_results = []
-        for ingredient_name in product_create_data.ingredients:
-            ingredient = ingredient_repo.get_ingredient_by_name(ingredient_name)
-            if ingredient:
-                ingredient_results.append(ingredient)
-        
-        product_analysis = await analyze_product_ingredients(
-            ingredients_data=ingredient_results,
-            user_preferences={
-                "user_id": product_create_data.user_id,
-                "allergies": None,
-                "dietary_restrictions": None
-            }
-        )
-        product_create_data.ingredients_analysis = product_analysis
 
-        # use repository to add product
+        # Add product to database
         product_repo = ProductRepository(db)
         product = product_repo.add_product(product_create_data)
-        product_id=product.id
-        await add_product_to_database(product_id, image_names, db, data)
-        return JSONResponse(
-            {
-                 "message": "Product data and image processed successfully",
-                "product_id":product_id,
-                 "data":data,
-                "product_data": product_create_data.model_dump()
-                
-             }
-        )
-
-    except HTTPException as e:
-        return JSONResponse({"error": e.detail}, status_code=e.status_code)
+        
+        print(product)
+        
+        # Add Vuforia target if needed
+        await add_product_to_database(product.id, [image_name], db, {
+            "name": name,
+            "ingredients": ingredients_list,
+            "image_name": image_name,
+        })
+        
+        return JSONResponse({
+            "message": "Product data and image processed successfully",
+            "product_id": product.id,
+            "image_name": image_name
+        })
     except Exception as e:
-         return JSONResponse({"error": str(e)}, status_code=500)
+        log_error(f"Error creating product: {e}", e)
+        print(e)
+        return JSONResponse({"error": str(e)}, status_code=500)
 
 
 @router.post("/process_image")
-async def process_image_endpoint(file: UploadFile = File(...), db: Session = Depends(get_db)):
+async def process_image_endpoint(image: UploadFile = File(...), db: Session = Depends(get_db), request: Request = None):
     """
     Receives an image file, performs object detection, and returns information about detected objects.
     """
     log_info("Process image endpoint called")
     try:
         # Read image from the uploaded file
-        image_data = await file.read()
+        image_data = await image.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)
-
-        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)
-
-            # 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
-            })
-
-        return JSONResponse({"detected_objects": detected_objects})
+        box, class_name, score = get_filtered_class_boxes(results)
+        
+        # Check if any objects were detected
+        if box is None:
+            log_info("No food objects detected in image")
+            # if send dummy target is allowed send default image
+            if SEND_FAKE_TARGET:
+                return JSONResponse({
+                    "class_name": "food",
+                    "score": float(0.24),
+                    "image_name": FAKE_TARGET_IMAGE_NAME,
+                    "detected": True
+                })
+            return JSONResponse({
+                "error": "No food objects detected in the image",
+                "detected": False
+            }, status_code=400)
+
+        # Crop the detected object
+        cropped_img = crop_image(image_np, box)
+
+        # 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({
+            "class_name": class_name,
+            "score": float(score),
+            "image_name": cropped_image_name,
+            "detected": True
+        })
     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}")
 
 
@@ -248,4 +279,15 @@ async def get_image(image_name: str):
     if os.path.exists(image_path):
         return FileResponse(image_path, media_type="image/jpeg")
     else:
-        return JSONResponse({"error": "Image not found"}, status_code=404)
+        return JSONResponse({"error": "Image not found"}, status_code=404)
+        
+    
+# In your API, add an endpoint like:
+@router.get("/marker/{vuforia_id}")
+async def get_product_by_marker(vuforia_id: str, db: Session = Depends(get_db)):
+    marker = db.query(Marker).filter(Marker.vuforia_id == vuforia_id).first()
+    if not marker:
+        raise HTTPException(status_code=404, detail="Target not found")
+    
+    product = db.query(Product).filter(Product.id == marker.product_id).first()
+    return product

services/auth_service.py

@@ -1,8 +1,8 @@
 from passlib.context import CryptContext
 from jose import JWTError, jwt
 from datetime import datetime, timedelta
-from fastapi import Depends, HTTPException, status
-from fastapi.security import OAuth2PasswordBearer
+from fastapi import Depends, HTTPException, status, Request
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
 from sqlalchemy import func
 from sqlalchemy.orm import Session,Mapped
 from db.database import get_db
@@ -19,7 +19,8 @@ ACCESS_TOKEN_EXPIRE_MINUTES = 30
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
 
-
+# Create an optional OAuth2 scheme that doesn't auto-error
+oauth2_scheme_optional = OAuth2PasswordBearer(tokenUrl="token", auto_error=False)
 
 def verify_password(plain_password, hashed_password):
     log_info("Verifying password")
@@ -63,7 +64,101 @@ def create_access_token(data: dict, expires_delta: timedelta | None = None):
     encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
     return encoded_jwt
 
-async def get_current_user(db: Session = Depends(get_db), token: str = Depends(oauth2_scheme)):
+# New flexible token extractor
+async def get_token_from_request(request: Request = None, oauth_token: str = None):
+    """Extract token from various sources, prioritizing standard formats but 
+    supporting Hugging Face Spaces custom headers"""
+    
+    # First try the standard OAuth2 token if provided
+    if oauth_token:
+        return oauth_token
+        
+    if request is None:
+        return None
+    
+    # Try standard Authorization header (works in local development)
+    auth_header = request.headers.get("Authorization")
+    if auth_header and auth_header.startswith("Bearer "):
+        return auth_header.replace("Bearer ", "")
+    
+    # Try Hugging Face's custom header
+    hf_token = request.headers.get("x-ip-token")
+    if hf_token:
+        log_info(f"Using token from Hugging Face x-ip-token header")
+        return hf_token
+    
+    # Final fallback: check query parameters
+    token_param = request.query_params.get("token")
+    if token_param:
+        log_info(f"Using token from query parameter")
+        return token_param
+        
+    return None
+
+# Replace or add this function
+async def get_current_user(
+    request: Request,
+    db: Session = Depends(get_db),
+    oauth_token: str = Depends(oauth2_scheme_optional)
+):
+    """Enhanced user authentication that supports both standard OAuth2
+    and Hugging Face Spaces deployments"""
+    
+    log_info("Getting current user with flexible auth")
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    
+    # Get token from any available source
+    token = await get_token_from_request(request, oauth_token)
+    
+    if not token:
+        log_error("No authentication token found")
+        raise credentials_exception
+    
+    try:
+        # Try to decode the token
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        email: str = payload.get("sub")
+        if email is None:
+            log_error("Token missing 'sub' claim")
+            raise credentials_exception
+            
+        token_data = TokenData(email=email)
+        
+    except JWTError as e:
+        log_error(f"JWT verification failed: {str(e)}", e)
+        raise credentials_exception
+        
+    except Exception as e:
+        log_error(f"Token processing error: {str(e)}", e)
+        raise HTTPException(status_code=500, detail=str(e))
+    
+    # Find the user
+    user = get_user(db, email=token_data.email)
+    if user is None:
+        log_error(f"User not found: {token_data.email}")
+        raise credentials_exception
+        
+    return user
+
+# Add this function for active users with flexible auth
+async def get_current_active_user(
+    request: Request,
+    db: Session = Depends(get_db),
+    oauth_token: str = Depends(oauth2_scheme_optional)
+):
+    """Get active user with flexible authentication"""
+    current_user = await get_current_user(request, db, oauth_token)
+    
+    if not current_user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+        
+    return UserResponse.from_orm(current_user)
+
+async def get_current_user_old(db: Session = Depends(get_db), token: str = Depends(oauth2_scheme)):
     log_info("Getting current user")
     credentials_exception = HTTPException(
         status_code=status.HTTP_401_UNAUTHORIZED,
@@ -87,7 +182,7 @@ async def get_current_user(db: Session = Depends(get_db), token: str = Depends(o
         raise credentials_exception
     return user
 
-async def get_current_active_user(current_user: User = Depends(get_current_user)):
+async def get_current_active_user_old(current_user: User = Depends(get_current_user_old)):
     log_info("Getting current active user")
     try:
         if not current_user.is_active:

services/ingredientFinderAgent.py

@@ -3,7 +3,6 @@ from functools import partial
 import os
 import json
 import traceback
-from dotenv import load_dotenv
 from typing import Dict, Any
 
 from langchain_google_genai import ChatGoogleGenerativeAI
@@ -14,9 +13,7 @@ from logger_manager import log_debug, log_error, log_info, log_warning
 from utils.agent_tools import search_local_db,search_web,search_wikipedia,search_open_food_facts,search_usda,search_pubchem
 
 # Load environment variables from .env file
-load_dotenv()
-
-
+from env import GOOGLE_API_KEY, LLM_MODEL_NAME
 
 def create_summary_from_source(source: Dict[str, Any]) -> str:
     """Create a meaningful summary from source data."""
@@ -94,12 +91,9 @@ def analyze_ingredient(state: IngredientState) -> IngredientState:
     Returns:
         Updated state with analysis results
     """
-    # Get API key and model from environment
-    api_key = os.getenv("GOOGLE_API_KEY")
-    model_name = os.getenv("LLM_MODEL_NAME", "gemini-1.5-pro")
     
     # Basic validation
-    if not api_key:
+    if not GOOGLE_API_KEY:
         log_error("No Google API key found in environment variables")
         new_state = state.copy()
         new_state["result"] = {
@@ -114,8 +108,8 @@ def analyze_ingredient(state: IngredientState) -> IngredientState:
     # Initialize LLM
     try:
         llm = ChatGoogleGenerativeAI(
-            google_api_key=api_key,
-            model=model_name,
+            google_GOOGLE_API_KEY=GOOGLE_API_KEY,
+            model=LLM_MODEL_NAME,
             temperature=0.3,  # Lower temperature for more factual responses
             # convert_system_message_to_human=True
         )
@@ -418,12 +412,34 @@ class IngredientInfoAgentLangGraph:
         # Extract the result or create a default
         if final_state.get("result"):
             log_info(f"Analysis complete for {ingredient}")
-            return IngredientAnalysisResult(**final_state["result"])
+            # Ensure id field is present
+            if "id" not in final_state["result"]:
+                final_state["result"]["id"] = 0  # Will be replaced with actual DB ID
+            
+            result = IngredientAnalysisResult(**final_state["result"])
+            
+            # Save to database using SessionLocal
+            from db.database import SessionLocal
+            from db.repositories import IngredientRepository
+            
+            with SessionLocal() as db:
+                repo = IngredientRepository(db)
+                db_ingredient = repo.create_ingredient(result)
+                # Update with real database ID
+                result.id = db_ingredient.id
+                
+            return result
         else:
             log_info(f"No result in final state for {ingredient}, returning default")
+            # Include id field in default result
             return IngredientAnalysisResult(
                 name=ingredient, 
-                is_found=len(sources_data) > 0, 
+                is_found=len(sources_data) > 0,
+                id=0,  # Required field
+                alternate_names=[],
+                safety_rating=0,
+                description="No reliable information found",
+                health_effects=["Unknown"],
                 details_with_source=sources_data
             )
         

services/productAnalyzerAgent.py

@@ -1,13 +1,12 @@
 import os
 from typing import List, Dict, Any, Optional
-from dotenv import load_dotenv
 from langchain_core.messages import HumanMessage
 from langchain_google_genai import ChatGoogleGenerativeAI
 from logger_manager import log_error, log_info
 from interfaces.ingredientModels import IngredientAnalysisResult
 
 # Load environment variables
-load_dotenv()
+from env import LLM_API_KEY, LLM_MODEL_NAME
 
 async def analyze_product_ingredients(
     ingredients_data: List[IngredientAnalysisResult],
@@ -19,13 +18,10 @@ async def analyze_product_ingredients(
     """
     log_info(f"Analyzing product with {len(ingredients_data)} ingredients")
     
-    # Initialize LLM
-    api_key = os.getenv("LLM_API_KEY")
-    model_name = os.getenv("LLM_MODEL_NAME", "gemini-2.0-flash")
-    
+    # Initialize LLM    
     llm = ChatGoogleGenerativeAI(
-        google_api_key=api_key,
-        model=model_name,
+        google_LLM_API_KEY=LLM_API_KEY,
+        model=LLM_MODEL_NAME,
         temperature=0.2  # Lower temperature for more factual responses
     )
     
@@ -50,6 +46,8 @@ Description: {ingredient.description[:200] + '...' if len(ingredient.description
         allergies = user_preferences.get("allergies", "None specified")
         diet = user_preferences.get("dietary_restrictions", "None specified")
         user_context = f"""
+## Also consider the following user preferences:
+        
 User has the following preferences:
 - Dietary Restrictions: {diet}
 - Allergies: {allergies}
@@ -66,7 +64,6 @@ analysis that would be helpful for a consumer viewing this in an AR application.
 ## INGREDIENTS INFORMATION:
 {''.join(ingredients_summary)}
 
-## Also consider the following user preferences:
 {user_context}
 
 ## REQUIRED ANALYSIS:

utils/agent_tools.py

@@ -2,12 +2,10 @@ import asyncio
 import os
 
 import pandas as pd
-from dotenv import load_dotenv
 
 from typing import Dict, Any
 # modular
 from logger_manager import log_error, log_info, log_warning
-from dotenv import load_dotenv
 
 import aiohttp
 import time
@@ -20,7 +18,7 @@ from langchain_core.tools import tool
 
 
 # Load environment variables from .env file
-load_dotenv()
+from env import PUBCHEM_MAX_RETRIES, PUBCHEM_TIMEOUT,DUCKDUCKGO_MAX_RETRIES,DUCKDUCKGO_RATE_LIMIT_DELAY,USDA_API_KEY
 
 # Load Scraped Database
 SCRAPED_DB_PATH = "data/Food_Aditives_E_numbers.csv"  # Ensure this file exists
@@ -32,15 +30,6 @@ else:
     log_warning("Scraped database not found!")
 
 
-# Define a rate limit (adjust as needed)
-PUBCHEM_TIMEOUT = float(os.getenv("PUBCHEM_TIMEOUT", "2.0"))   # seconds
-PUBCHEM_MAX_RETRIES = int(os.getenv("PUBCHEM_MAX_RETRIES", "3"))  # Max retries
-
-# Rate limiting configuration
-DUCKDUCKGO_RATE_LIMIT_DELAY = float(os.getenv("DUCKDUCKGO_RATE_LIMIT_DELAY", "2.0"))  # Delay in seconds
-DUCKDUCKGO_MAX_RETRIES = int(os.getenv("DUCKDUCKGO_MAX_RETRIES", "3"))  # Max retries
-
-
 # Define tool functions
 @tool("search_local_db")
 def search_local_db(ingredient: str) -> Dict[str, Any]:
@@ -98,12 +87,11 @@ def search_usda(ingredient: str) -> Dict[str, Any]:
     
     try:
         usda_api = "https://api.nal.usda.gov/fdc/v1"
-        usda_api_key = os.getenv("USDA_API_KEY", "DEMO_KEY")  # Use DEMO_KEY if not provided
         
         # Search for the ingredient
         search_url = f"{usda_api}/foods/search"
         params = {
-            "api_key": usda_api_key,
+            "api_key": USDA_API_KEY,
             "query": ingredient,
             "dataType": ["Foundation", "SR Legacy", "Branded"],
             "pageSize": 5

utils/analyze.py

@@ -0,0 +1,56 @@
+import asyncio
+from datetime import datetime
+import pytz
+from typing import List, Dict, Any
+from logger_manager import log_info, log_error
+from services.productAnalyzerAgent import analyze_product_ingredients
+from utils.ingredient_utils import process_single_ingredient
+
+# Load environment variables
+from env import PARALLEL_RATE_LIMIT
+
+log_info(f"Using parallel rate limit of {PARALLEL_RATE_LIMIT}")
+
+# Create a semaphore to limit concurrent API calls
+llm_semaphore = asyncio.Semaphore(PARALLEL_RATE_LIMIT)
+
+
+async def process_product_ingredients(product_ingredients: List[str]) -> Dict[str, Any]:    
+    log_info(f"process_product_ingredients called for {len(product_ingredients)} ingredients")
+    try:
+        # Step 1: Process individual ingredients
+        ingredient_results = []
+            
+        log_info(f"Starting parallel ingredient processing with rate limit {PARALLEL_RATE_LIMIT}")
+        
+        # Create tasks for parallel processing
+        tasks = []
+        for ingredient_name in product_ingredients:
+            task = process_single_ingredient(ingredient_name)
+            tasks.append(task)
+        
+        # Execute tasks concurrently with rate limiting
+        ingredient_results = await asyncio.gather(*tasks)
+        log_info(f"Completed parallel processing of {len(ingredient_results)} ingredients")
+            
+        product_analysis = await analyze_product_ingredients(
+            ingredients_data=ingredient_results
+        )
+        
+        # print("Product analysis result:", product_analysis)
+        
+        # Step 3: Prepare final response
+        result = {
+            "ingredients_count": len(product_ingredients),
+            "processed_ingredients": ingredient_results,
+            "ingredient_ids": product_analysis["ingredient_ids"],
+            "overall_analysis": product_analysis,
+            "timestamp": datetime.now(tz=pytz.timezone('Asia/Kolkata')).isoformat()
+        }
+
+        log_info("process_product_ingredients completed successfully")
+        return result
+        
+    except Exception as e:
+        log_error(f"Error in process_product_ingredients: {str(e)}",e)
+        return None

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,62 @@ 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
+from env import 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/external_api_utils.py

@@ -2,12 +2,8 @@ import requests
 import json
 import os
 from logger_manager import log_info, log_error
-from dotenv import load_dotenv
 
-load_dotenv()
-
-VUFORIA_SERVER_ACCESS_KEY = os.getenv("VUFORIA_SERVER_ACCESS_KEY")
-VUFORIA_SERVER_SECRET_KEY = os.getenv("VUFORIA_SERVER_SECRET_KEY")
+from env import VUFORIA_SERVER_ACCESS_KEY, VUFORIA_SERVER_SECRET_KEY
 
 def get_vuforia_auth_headers():
     """

utils/image_processing_utils.py

@@ -5,7 +5,7 @@ from PIL import Image, ImageDraw, ImageFont, ImageOps
 import requests
 from io import BytesIO
 import os
-
+from env import UPLOADED_IMAGES_DIR
 
 # Load the model from TF Hub
 # Cache the model globally
@@ -14,10 +14,6 @@ detector = hub.load("https://tfhub.dev/google/openimages_v4/ssd/mobilenet_v2/1")
 # Classes you care about
 TARGET_CLASSES = set(["Food processor", "Fast food", "Food", "Seafood", "Snack"])
 
-UPLOADED_IMAGES_DIR = "uploaded_images"
-if not os.path.exists(UPLOADED_IMAGES_DIR):
-    os.makedirs(UPLOADED_IMAGES_DIR)
-
 
 def load_image_from_url(url, size=(640, 480)):
     response = requests.get(url)

utils/ingredient_utils.py

@@ -4,61 +4,65 @@ 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()
+from env import PARALLEL_RATE_LIMIT
 
-# Get rate limit from environment variable or use default
-PARALLEL_RATE_LIMIT = int(os.getenv("PARALLEL_RATE_LIMIT", 10))
 
 # Create a semaphore to limit concurrent API calls
 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,93 @@
+import json
+import hmac
+import hashlib
+import base64
+import time
+from datetime import datetime
+from logger_manager import log_info, log_error
+import os
+import aiohttp
+
+from env import VUFORIA_SERVER_ACCESS_KEY, VUFORIA_SERVER_SECRET_KEY,UPLOADED_IMAGES_DIR
+
+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.
+    Implements proper Vuforia authentication and request format.
+    """
+    log_info(f"Adding target {image_name} to Vuforia")
+
+    try:
+        # Read image data
+        with open(image_path, "rb") as image_file:
+            image_data = image_file.read()
+        
+        # Base64 encode the image
+        image_base64 = base64.b64encode(image_data).decode('utf-8')
+        
+        # Create request data
+        request_path = '/targets'
+        host = 'vws.vuforia.com'
+        url = f"https://{host}{request_path}"
+        
+        # Create payload
+        payload = {
+            "name": image_name,
+            "width": 1.0,  # Default width in scene units
+            "image": image_base64,
+            "active_flag": True,
+        }
+        
+        # Convert payload to JSON
+        body = json.dumps(payload)
+        
+        # Get current date in proper format for Vuforia
+        date = datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT')
+        
+        # Set content type
+        content_type = 'application/json'
+        
+        # Calculate MD5 of request body
+        content_md5 = hashlib.md5(body.encode('utf-8')).hexdigest()
+        
+        # Create string to sign according to Vuforia docs
+        string_to_sign = f"POST\n{content_md5}\n{content_type}\n{date}\n{request_path}"
+        
+        # Generate signature
+        signature = hmac.new(
+            VUFORIA_SERVER_SECRET_KEY.encode('utf-8'),
+            string_to_sign.encode('utf-8'),
+            hashlib.sha1
+        ).digest()
+        signature_hex = base64.b64encode(signature).decode('utf-8')
+        
+        # Create headers
+        headers = {
+            'Authorization': f'VWS {VUFORIA_SERVER_ACCESS_KEY}:{signature_hex}',
+            'Content-Type': content_type,
+            'Date': date,
+            'Content-MD5': content_md5
+        }
+        
+        # Make the API request
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, headers=headers, data=body) as response:
+                # Get response text and try to parse as JSON
+                response_text = await response.text()
+                try:
+                    response_json = json.loads(response_text)
+                except:
+                    response_json = {"error": "Failed to parse response"}
+                
+                log_info(f"Vuforia response status: {response.status}")
+                
+                if response.status == 201:  # Created
+                    log_info(f"Target added successfully: {response_json}")
+                    return response_json.get("target_id", "unknown_target_id")
+                else:
+                    log_error(f"Failed to add target: Status {response.status}, Response: {response_text}")
+                    raise Exception(f"Failed to add target {image_name}: Status {response.status}, Error: {response_json.get('result_code', 'Unknown')}")
+                    
+    except Exception as e:
+        log_error(f"Error adding target {image_name}: {e}", e)
+        raise