bug fix

interfaces/productModels.py

@@ -1,5 +1,5 @@
-from typing import List, Dict, Optional
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
 from datetime import datetime
 
 # Add this class to define the request body structure
@@ -21,41 +21,42 @@ class ProductCreate(BaseModel):
     timestamp: datetime
     ingredient_ids: List[int]|str
 
-class SafetyScore(BaseModel):
-    isPresent: bool
-    value: Optional[int] = None
-
-class ProductInfo(BaseModel):
-    id: Optional[int] = None
-    name: Optional[str] = None
-    barcode: Optional[str] = None
+class BasicProductInfo(BaseModel):
+    product_id: str
+    product_name: str
+    brand: Optional[str] = ""
+    category: Optional[str] = ""
     image_url: Optional[str] = None
-    brand: Optional[str] = None
-    manufacturing_places: Optional[str] = None
-    stores: Optional[str] = None
-    countries: Optional[str] = None
+    barcode: Optional[str] = None
+
+class SafetyInfo(BaseModel):
+    safety_score: float = 0
+    is_safe: bool = False
+    warnings: List[str] = []
+    benefits: List[str] = []
 
 class IngredientInfo(BaseModel):
-    ingredients_text: Optional[str] = None
-    ingredients_analysis: Optional[List[Dict[str, Any]]] = None # Adjust type if analysis has a specific structure
-    additives: Optional[List[str]] = None
+    ingredients_list: List[str] = []
+    ingredients_analysis: List[Dict[str, Any]] = []
+    ingredient_count: int = 0
 
 class AllergenInfo(BaseModel):
-    allergens: Optional[List[str]] = None
-    traces: Optional[List[str]] = None
+    allergens: List[str] = []
+    has_allergens: bool = False
 
-class DietInfo(BaseModel):
-    vegan: Optional[bool] = None
-    vegetarian: Optional[bool] = None
+class DietaryInfo(BaseModel):
+    dietary_flags: List[str] = []
+    is_vegetarian: bool = False
+    is_vegan: bool = False
 
 class ProductAnalysisResponse(BaseModel):
-    found: bool
-    safety_score: SafetyScore
-    product_info: Optional[ProductInfo] = None
-    ingredient_info: Optional[IngredientInfo] = None
-    allergen_info: Optional[AllergenInfo] = None
-    diet_info: Optional[DietInfo] = None
-    nutritional_info: Optional[Dict[str, Any]] = None # Adjust type if nutritional info has a specific structure
-    manufacturing_info: Optional[Dict[str, Any]] = None # Adjust type if manufacturing info has a specific structure
+    """Response model for product analysis by marker ID"""
+    found: bool = Field(..., description="Whether the product was found")
+    basic_info: BasicProductInfo = Field(..., description="Basic product information")
+    safety_info: SafetyInfo = Field(..., description="Safety information about the product")
+    ingredient_info: IngredientInfo = Field(..., description="Information about ingredients")
+    allergen_info: AllergenInfo = Field(..., description="Information about allergens")
+    dietary_info: DietaryInfo = Field(..., description="Dietary information")
+    timestamp: str = Field(..., description="Timestamp of the response")
 
 

routers/analysis.py

@@ -7,7 +7,7 @@ from fastapi.responses import JSONResponse, FileResponse
 import pytz
 from sqlalchemy.orm import Session
 from typing import List, Dict, Any
-from db.models import User, Ingredient
+from db.models import Marker, Product, User, Ingredient
 from interfaces.ingredientModels import IngredientAnalysisResult, IngredientRequest
 from interfaces.productModels import ProductIngredientsRequest
 from logger_manager import log_info, log_error
@@ -138,21 +138,65 @@ async def process_ingredients_endpoint(product_ingredient: ProductIngredientsReq
         raise HTTPException(status_code=500, detail="Internal Server Error")
 
 
-@router.get("/get_by_marker_id/{target_id}", response_model=ProductAnalysisResponse)
+@router.get("/get_by_marker_id/{target_id}", response_model=None)
 async def get_analysis_by_marker_id(target_id: str, db: Session = Depends(get_db)):
     """
     Retrieves product analysis and ingredient information by marker ID.
     """
     log_info(f"Received request for analysis by marker ID: {target_id}")
     try:
+        # Check if marker exists
+        marker = db.query(Marker).filter(Marker.vuforia_id == target_id).first()
+        if not marker:
+            return JSONResponse(
+                status_code=404,
+                content={
+                    "found": False,
+                    "message": f"Marker with ID {target_id} not found",
+                    "timestamp": datetime.now(tz=pytz.timezone('Asia/Kolkata')).isoformat()
+                }
+            )
+            
+        # Check if product exists
+        product = db.query(Product).filter(Product.id == marker.product_id).first()
+        if not product:
+            return JSONResponse(
+                status_code=404,
+                content={
+                    "found": False,
+                    "message": f"Product not found for marker ID: {target_id}",
+                    "timestamp": datetime.now(tz=pytz.timezone('Asia/Kolkata')).isoformat()
+                }
+            )
+            
+        # Try to get complete product data
         product_data = get_analysis_service_data(db, target_id)
-
+        
+        # If complete data retrieval fails, return minimal data
         if not product_data:
-            raise HTTPException(status_code=404, detail=f"Product not found for marker ID: {target_id}")
-
-        log_info(f"Successfully retrieved product data for marker ID: {target_id}")
+            return JSONResponse(
+                status_code=200,
+                content={
+                    "found": True,
+                    "basic_info": {
+                        "product_id": str(product.id),
+                        "product_name": getattr(product, 'product_name', 'Unknown Product'),
+                    },
+                    "message": "Product found but analysis data could not be processed",
+                    "timestamp": datetime.now(tz=pytz.timezone('Asia/Kolkata')).isoformat()
+                }
+            )
+            
         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)
+        return JSONResponse(
+            status_code=500,
+            content={
+                "found": False,
+                "error": str(e),
+                "message": "Error processing request",
+                "timestamp": datetime.now(tz=pytz.timezone('Asia/Kolkata')).isoformat()
+            }
+        )

services/analysis_service.py

@@ -1,9 +1,72 @@
 from sqlalchemy.orm import Session
-from db.models import Marker, Product
+from db.models import Marker, Product, Ingredient
 from utils.analysis_utils import format_product_analysis_response
-from utils.logger_manager import log_info, log_error
+from logger_manager import log_info, log_error, log_debug
 from interfaces.productModels import ProductAnalysisResponse
-from typing import Optional
+from typing import Optional, List
+import json
+
+def get_product_ingredients(db: Session, product: Product) -> List[dict]:
+    """
+    Fetch ingredients associated with a product.
+    
+    Args:
+        db: Database session
+        product: Product model instance
+        
+    Returns:
+        List of ingredient data dictionaries
+    """
+    ingredient_data = []
+    
+    try:
+        # Check if product has ingredient_ids field
+        ingredient_ids = []
+        
+        if hasattr(product, 'ingredient_ids') and product.ingredient_ids:
+            # Handle string or list format
+            if isinstance(product.ingredient_ids, str):
+                try:
+                    ingredient_ids = [int(id.strip()) for id in product.ingredient_ids.split(',') if id.strip()]
+                except:
+                    try:
+                        ingredient_ids = json.loads(product.ingredient_ids)
+                    except:
+                        log_error(f"Failed to parse ingredient_ids: {product.ingredient_ids}")
+            elif isinstance(product.ingredient_ids, list):
+                ingredient_ids = product.ingredient_ids
+            
+            log_info(f"Found {len(ingredient_ids)} ingredient IDs for product {product.id}")
+            
+            # Fetch ingredients by IDs
+            for ing_id in ingredient_ids:
+                ingredient = db.query(Ingredient).filter(Ingredient.id == ing_id).first()
+                if ingredient:
+                    ingredient_data.append({
+                        "id": ingredient.id,
+                        "name": ingredient.name,
+                        "safety_rating": getattr(ingredient, "safety_rating", 5),
+                        "description": getattr(ingredient, "description", ""),
+                        "health_effects": getattr(ingredient, "health_effects", []),
+                        "allergens": getattr(ingredient, "allergens", [])
+                    })
+        
+        # If we still don't have ingredients, try looking for a relationship
+        if not ingredient_data and hasattr(product, 'ingredients') and product.ingredients:
+            for ingredient in product.ingredients:
+                ingredient_data.append({
+                    "id": ingredient.id,
+                    "name": ingredient.name,
+                    "safety_rating": getattr(ingredient, "safety_rating", 5),
+                    "description": getattr(ingredient, "description", ""),
+                    "health_effects": getattr(ingredient, "health_effects", []),
+                    "allergens": getattr(ingredient, "allergens", [])
+                })
+                
+        return ingredient_data
+    except Exception as e:
+        log_error(f"Error fetching ingredients for product {product.id}: {str(e)}")
+        return []
 
 def get_product_data_by_marker_id(db: Session, target_id: str) -> Optional[ProductAnalysisResponse]:
     """
@@ -15,12 +78,11 @@ def get_product_data_by_marker_id(db: Session, target_id: str) -> Optional[Produ
 
     Returns:
         A ProductAnalysisResponse object or None if no product is found.
-
     """
     log_info(f"Attempting to retrieve product data for marker ID: {target_id}")
     try:
         # Find the marker with the given target_id
-        marker = db.query(Marker).filter(Marker.target_id == target_id).first()
+        marker = db.query(Marker).filter(Marker.vuforia_id == target_id).first()
 
         if not marker:
             log_info(f"No marker found for target ID: {target_id}")
@@ -33,11 +95,26 @@ def get_product_data_by_marker_id(db: Session, target_id: str) -> Optional[Produ
             log_info(f"No product found for product_id: {marker.product_id} linked to marker ID: {target_id}")
             return None
 
-        log_info(f"Product found for marker ID {target_id}: {product.name}")
-
+        log_info(f"Product found for marker ID {target_id}: {product.product_name}")
+        
+        # Log product fields for debugging
+        log_info(f"Product fields: ID={product.id}, Name={product.product_name}")
+        
+        # Get ingredient details if needed
+        ingredients = get_product_ingredients(db, product)
+        if ingredients:
+            log_info(f"Found {len(ingredients)} ingredients for product {product.id}")
+            # Update product with ingredients if needed
+            if not hasattr(product, 'ingredients_list') or not product.ingredients_list:
+                product.ingredients_list = [ing["name"] for ing in ingredients]
+            
+            # Add ingredient analysis data if needed
+            if not hasattr(product, 'ingredients_analysis') or not product.ingredients_analysis:
+                product.ingredients_analysis = ingredients
+        
         # Format the response using the utility function
         response_data = format_product_analysis_response(product)
-
+        
         return response_data
 
     except Exception as e:

utils/analysis_utils.py

@@ -1,54 +1,167 @@
-from typing import Dict, Any, Optional, Any
+import json
+from datetime import datetime
+import pytz
+from typing import Dict, Any, List, Optional
+from db.models import Product
 from interfaces.productModels import ProductAnalysisResponse
+from logger_manager import log_info, log_error, log_debug
 
-def format_product_analysis_response(product_data: Optional[Any]) -> Optional[ProductAnalysisResponse]:
-    """
-    Formats the retrieved product analysis data into a consistent response structure.
-
-    Args:
-        product_data: A SQLAlchemy Product object, or None if not found.
+def safe_parse_json(value, default=None):
+    """Safely parse a JSON string, with fallback to default value"""
+    if value is None:
+        return default
+    
+    if not isinstance(value, str):
+        return value
+        
+    try:
+        # Handle double-quoted JSON strings (e.g. '"Vegetarian"')
+        parsed = json.loads(value)
+        return parsed
+    except json.JSONDecodeError:
+        # If it's not valid JSON but might be a comma-separated list
+        if ',' in value:
+            return [item.strip() for item in value.split(',')]
+        return default
 
-    Returns:
-        A ProductAnalysisResponse object or None.
+def format_product_analysis_response(product):
     """
-    if product_data is None:
-        return None
-
-    # Assuming product_data is a SQLAlchemy Product object
-    safety_score_value = product_data.overall_safety_score
-    safety_score_isPresent = safety_score_value is not None
-
-    return ProductAnalysisResponse(
-        found=True,
-        safety_score={
-            "isPresent": safety_score_isPresent,
-            "value": safety_score_value,
-        },
-        product_info= {
-            "id": product_data.id,
-            "name": product_data.product_name,
-            "barcode": None, # Assuming barcode is not in Product model
-            "image_url": None, # Assuming image_url is not in Product model
-            "brand": None, # Assuming brand is not in Product model
-            "manufacturing_places": None, # Assuming manufacturing_places is not in Product model
-            "stores": None, # Assuming stores is not in Product model
-            "countries": None, # Assuming countries is not in Product model
-        },
-        ingredient_info={
-            "ingredients_text": product_data.ingredients,
-            "ingredients_analysis": product_data.ingredient_interactions, # Assuming ingredient_interactions maps to analysis
-            "additives": None, # Assuming additives are not directly in Product model
-        },
-        allergen_info= {
-            "allergens": product_data.allergy_warnings,
-            "traces": None, # Assuming traces are not directly in Product model
-        },
-        diet_info={
-            "vegan": None, # Assuming vegan is not directly in Product model
-            "vegetarian": None, # Assuming vegetarian is not directly in Product model
-        },
-        nutritional_info=None, # Assuming nutritional_info is not directly in Product model
-        manufacturing_info=None # Assuming manufacturing_info is not directly in Product model
-    )
-
-# Add other helper functions as needed for analysis
+    Format product data into a ProductAnalysisResponse object with simple error handling.
+    """
+    try:
+        # Print product data for debugging
+        log_debug(f"Product object attributes: {dir(product)}")
+        log_debug(f"Product __dict__: {product.__dict__}")
+        
+        # Extract and parse the dietary flags - handle the specific case that's failing
+        dietary_flags = []
+        try:
+            diet_types = getattr(product, 'suitable_diet_types', None)
+            if diet_types:
+                # Parse the JSON string - handle the case where it's a quoted string like '"Vegetarian"'
+                parsed_diet = safe_parse_json(diet_types, [])
+                if isinstance(parsed_diet, str):
+                    dietary_flags = [parsed_diet]  # Convert single string to list
+                elif isinstance(parsed_diet, list):
+                    dietary_flags = parsed_diet
+        except Exception as e:
+            log_error(f"Error parsing dietary flags: {e}")
+            dietary_flags = []
+        
+        # Parse health insights
+        health_insights = {}
+        try:
+            insights_str = getattr(product, 'health_insights', None)
+            if insights_str:
+                health_insights = safe_parse_json(insights_str, {})
+        except Exception as e:
+            log_error(f"Error parsing health insights: {e}")
+        
+        # Extract warnings and benefits from health insights if available
+        warnings = []
+        benefits = []
+        try:
+            if isinstance(health_insights, dict):
+                warnings = health_insights.get('concerns', [])
+                benefits = health_insights.get('benefits', [])
+        except Exception as e:
+            log_error(f"Error extracting warnings/benefits: {e}")
+        
+        # Parse allergy warnings
+        allergens = []
+        try:
+            allergy_str = getattr(product, 'allergy_warnings', None)
+            if allergy_str:
+                allergens = safe_parse_json(allergy_str, [])
+        except Exception as e:
+            log_error(f"Error parsing allergens: {e}")
+        
+        # Parse ingredients list
+        ingredients_list = []
+        try:
+            ing_list = getattr(product, 'ingredients_list', None) or getattr(product, 'ingredients', None)
+            if ing_list:
+                ingredients_list = safe_parse_json(ing_list, [])
+        except Exception as e:
+            log_error(f"Error parsing ingredients list: {e}")
+        
+        # Parse ingredients analysis if available
+        ingredients_analysis = []
+        try:
+            ing_analysis = getattr(product, 'ingredients_analysis', [])
+            if ing_analysis:
+                if isinstance(ing_analysis, list):
+                    ingredients_analysis = ing_analysis
+                else:
+                    ingredients_analysis = safe_parse_json(ing_analysis, [])
+        except Exception as e:
+            log_error(f"Error parsing ingredients analysis: {e}")
+        
+        # Construct the final response
+        return ProductAnalysisResponse(
+            found=True,
+            basic_info={
+                "product_id": str(product.id),
+                "product_name": getattr(product, 'product_name', ''),
+                "brand": "",
+                "category": "",
+                "image_url": None,
+                "barcode": None
+            },
+            safety_info={
+                "safety_score": float(getattr(product, 'overall_safety_score', 0)),
+                "is_safe": getattr(product, 'overall_safety_score', 0) > 5,
+                "warnings": warnings,
+                "benefits": benefits
+            },
+            ingredient_info={
+                "ingredients_list": ingredients_list,
+                "ingredients_analysis": ingredients_analysis,
+                "ingredient_count": getattr(product, 'ingredients_count', 0)
+            },
+            allergen_info={
+                "allergens": allergens,
+                "has_allergens": len(allergens) > 0
+            },
+            dietary_info={
+                "dietary_flags": dietary_flags,
+                "is_vegetarian": any(flag.lower() == 'vegetarian' for flag in dietary_flags),
+                "is_vegan": any(flag.lower() == 'vegan' for flag in dietary_flags)
+            },
+            timestamp=datetime.now(tz=pytz.timezone('Asia/Kolkata')).isoformat()
+        )
+    except Exception as e:
+        log_error(f"Error in format_product_analysis_response: {str(e)}")
+        # Return a minimal valid response rather than raising an exception
+        return ProductAnalysisResponse(
+            found=True,
+            basic_info={
+                "product_id": str(product.id),
+                "product_name": getattr(product, 'product_name', 'Unknown Product'),
+                "brand": "",
+                "category": "",
+                "image_url": None,
+                "barcode": None
+            },
+            safety_info={
+                "safety_score": 0.0,
+                "is_safe": False,
+                "warnings": [],
+                "benefits": []
+            },
+            ingredient_info={
+                "ingredients_list": [],
+                "ingredients_analysis": [],
+                "ingredient_count": 0
+            },
+            allergen_info={
+                "allergens": [],
+                "has_allergens": False
+            },
+            dietary_info={
+                "dietary_flags": [],
+                "is_vegetarian": False,
+                "is_vegan": False
+            },
+            timestamp=datetime.now(tz=pytz.timezone('Asia/Kolkata')).isoformat()
+        )