working add product

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

@@ -7,7 +7,10 @@ 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")

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
 
 

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/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
@@ -24,14 +26,14 @@ from db.repositories import ProductRepository, IngredientRepository
 
 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.vuforia_utils import add_target_to_vuforia, UPLOADED_IMAGES_DIR
 from utils.fetch_data import fetch_product_data_from_api
 import uuid
 import json
 
 # import environment variables
-from env import FAKE_TARGET_IMAGE_NAME, SEND_FAKE_TARGET, VUFORIA_SERVER_ACCESS_KEY,VUFORIA_SERVER_SECRET_KEY,VUFORIA_TARGET_DATABASE_NAME,VUFORIA_TARGET_DATABASE_ID
+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()
 
@@ -108,55 +110,77 @@ async def create_product(
         # 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)
+        # }}
+        
+        # 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", "")
+        
+        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=name,
-            ingredients=ingredients_list,
-            overall_safety_score=0,  # Default values
-            suitable_diet_types=[],
-            allergy_warnings=[],
-            usage_recommendations="",
-            health_insights="",
-            ingredient_interactions="",
-            key_takeaway="",
-            ingredients_count=len(ingredients_list),
-            user_id=None,  # Can be updated later if needed
-            timestamp=None,
-            ingredient_ids=[]
+            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
-        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
 
         # Add product to database
         product_repo = ProductRepository(db)
         product = product_repo.add_product(product_create_data)
         
+        print(product)
+        
         # Add Vuforia target if needed
         await add_product_to_database(product.id, [image_name], db, {
             "name": name,
-            "ingredients": ingredients,
+            "ingredients": ingredients_list,
             "image_name": image_name,
         })
         

services/ingredientFinderAgent.py

@@ -412,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

@@ -46,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}
@@ -62,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/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

@@ -7,7 +7,8 @@ from logger_manager import log_info, log_error
 from fastapi import HTTPException
 import os
 from services.product_service import ProductService
-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.
+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
 
 

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/vuforia_utils.py

@@ -1,58 +1,93 @@
 import json
+import hmac
+import hashlib
+import base64
+import time
+from datetime import datetime
 from logger_manager import log_info, log_error
-from PIL import Image
 import os
-from pathlib import Path
-import requests
-
-UPLOADED_IMAGES_DIR = "uploaded_images"
-if not os.path.exists(UPLOADED_IMAGES_DIR):
-    os.makedirs(UPLOADED_IMAGES_DIR)
-
-from env import VUFORIA_SERVER_ACCESS_KEY, VUFORIA_SERVER_SECRET_KEY, VUFORIA_TARGET_DATABASE_NAME, 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",
-    }
+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()
-
-        url = f"https://vws.vuforia.com/targets"
-
-        headers = get_vuforia_auth_headers()
+        
+        # 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
-            "image": image_data.hex(),  # Convert image data to hex
+            "width": 1.0,  # Default width in scene units
+            "image": image_base64,
             "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}")
+        
+        # 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
-
-
+        log_error(f"Error adding target {image_name}: {e}", e)
+        raise