Add product module and update ingredient model

Add a new `Product` model and update the `Ingredient` model with additional fields.

* **Product Model**:
- Add `models/product.py` to define the `Product` model with fields like `product_name`, `generic_name`, `brands`, `ingredients`, `ingredients_text`, `ingredients_analysis`, `nutriscore`, `nutrient_levels`, `nutriments`, and `data_quality_warnings`.
- Update `models/__init__.py` to import and include the `Product` model.

* **Ingredient Model**:
- Add new fields to `models/ingredient.py`: `description`, `origin`, `allergens`, `vegan`, and `vegetarian`.
- Create Alembic migration script `migrations/versions/xxxx_add_product_and_update_ingredient.py` to add the `Product` table and update the `Ingredient` table.

* **Services**:
- Modify `services/ai_agent.py` to save product details in the `Product` model and ingredient details in the `Ingredient` model.
- Update `services/ingredients.py` to fetch and save new fields for ingredients.

* **Endpoints**:
- Update `routers/analysis.py` to handle saving product information and ingredient search results.

* **Tests**:
- Add tests in `tests/test_ai_agent_service.py` for saving product and ingredient details.
- Add tests in `tests/test_ingredients_service.py` for fetching and saving new fields in the `Ingredient` model.
- Add tests in `tests/test_analysis_agent_service.py` for handling new fields in the `Ingredient` model.

---

For more details, open the [Copilot Workspace session](https://copilot-workspace.githubnext.com/prathameshks/FoodAnalyzer-API/tree/main?shareId=XXXX-XXXX-XXXX-XXXX).

migrations/versions/xxxx_add_product_and_update_ingredient.py

@@ -0,0 +1,57 @@
+"""add product and update ingredient
+
+Revision ID: xxxx
+Revises: fcf5a0dab27d
+Create Date: 2025-03-22 10:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'xxxx'
+down_revision: Union[str, None] = 'fcf5a0dab27d'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('products',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('product_name', sa.String(), nullable=False),
+    sa.Column('generic_name', sa.String(), nullable=True),
+    sa.Column('brands', sa.String(), nullable=True),
+    sa.Column('ingredients', sa.JSON(), nullable=True),
+    sa.Column('ingredients_text', sa.String(), nullable=True),
+    sa.Column('ingredients_analysis', sa.JSON(), nullable=True),
+    sa.Column('nutriscore', sa.JSON(), nullable=True),
+    sa.Column('nutrient_levels', sa.JSON(), nullable=True),
+    sa.Column('nutriments', sa.JSON(), nullable=True),
+    sa.Column('data_quality_warnings', sa.JSON(), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_products_id'), 'products', ['id'], unique=False)
+    op.add_column('ingredients', sa.Column('description', sa.String(), nullable=True))
+    op.add_column('ingredients', sa.Column('origin', sa.String(), nullable=True))
+    op.add_column('ingredients', sa.Column('allergens', sa.String(), nullable=True))
+    op.add_column('ingredients', sa.Column('vegan', sa.Boolean(), nullable=True))
+    op.add_column('ingredients', sa.Column('vegetarian', sa.Boolean(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_products_id'), table_name='products')
+    op.drop_table('products')
+    op.drop_column('ingredients', 'description')
+    op.drop_column('ingredients', 'origin')
+    op.drop_column('ingredients', 'allergens')
+    op.drop_column('ingredients', 'vegan')
+    op.drop_column('ingredients', 'vegetarian')
+    # ### end Alembic commands ###

models/__init__.py

@@ -3,5 +3,6 @@ from .user import User
 from .user_preferences import UserPreferences
 from .ingredient import Ingredient
 from .scan_history import ScanHistory
+from .product import Product
 
-__all__ = ["Base", "User", "UserPreferences", "Ingredient", "ScanHistory"]
+__all__ = ["Base", "User", "UserPreferences", "Ingredient", "ScanHistory", "Product"]

models/ingredient.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, Integer, String, JSON
+from sqlalchemy import Column, Integer, String, JSON, Boolean
 from .base import Base
 
 class Ingredient(Base):
@@ -7,3 +7,8 @@ class Ingredient(Base):
     id = Column(Integer, primary_key=True, index=True)
     name = Column(String, unique=True, index=True)
     nutritional_info = Column(JSON)
+    description = Column(String, nullable=True)
+    origin = Column(String, nullable=True)
+    allergens = Column(String, nullable=True)
+    vegan = Column(Boolean, nullable=True)
+    vegetarian = Column(Boolean, nullable=True)

models/product.py

@@ -0,0 +1,17 @@
+from sqlalchemy import Column, Integer, String, JSON
+from .base import Base
+
+class Product(Base):
+    __tablename__ = "products"
+
+    id = Column(Integer, primary_key=True, index=True)
+    product_name = Column(String, nullable=False)
+    generic_name = Column(String, nullable=True)
+    brands = Column(String, nullable=True)
+    ingredients = Column(JSON, nullable=True)
+    ingredients_text = Column(String, nullable=True)
+    ingredients_analysis = Column(JSON, nullable=True)
+    nutriscore = Column(JSON, nullable=True)
+    nutrient_levels = Column(JSON, nullable=True)
+    nutriments = Column(JSON, nullable=True)
+    data_quality_warnings = Column(JSON, nullable=True)

routers/analysis.py

@@ -4,8 +4,10 @@ from typing import List, Dict, Any
 from database import get_db
 from models.user import User
 from models.ingredient import Ingredient
+from models.product import Product
 from services.analysis_agent import analyze_ingredients, provide_personalized_recommendations
 from services.auth_service import get_current_user
+from services.ai_agent import process_data
 
 router = APIRouter()
 
@@ -24,3 +26,11 @@ def personalized_recommendations_endpoint(db: Session = Depends(get_db), current
         return recommendations
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/process_product")
+def process_product_endpoint(barcode: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    try:
+        product_data = process_data(db, barcode)
+        return product_data
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

services/ai_agent.py

@@ -2,6 +2,7 @@ from sqlalchemy.orm import Session
 from fastapi import HTTPException
 from utils import fetch_product_data_from_api, save_json_file
 from models.ingredient import Ingredient
+from models.product import Product
 from services.ingredients import get_ingredient_by_name, save_ingredient_data, fetch_ingredient_data_from_api
 from typing import Dict, Any
 import json
@@ -85,6 +86,32 @@ def process_data(db: Session, barcode: str) -> Dict[str, Any]:
     data = clean_data(data)
     data = standardize_data(data)
     data = enrich_data(db, data)
+    
+    # Save product details in the Product model
+    product = Product(
+        product_name=data["product_name"],
+        generic_name=data["generic_name"],
+        brands=data["brands"],
+        ingredients=data["ingredients"],
+        ingredients_text=data["ingredients_text"],
+        ingredients_analysis=data["ingredients_analysis"],
+        nutriscore=data["nutriscore"],
+        nutrient_levels=data["nutrient_levels"],
+        nutriments=data["nutriments"],
+        data_quality_warnings=data["data_quality_warnings"]
+    )
+    db.add(product)
+    db.commit()
+    db.refresh(product)
+    
+    # Save ingredient details in the Ingredient model
+    for ingredient in data["ingredients"]:
+        ingredient_data = get_ingredient_by_name(db, ingredient["text"])
+        if not ingredient_data:
+            ingredient_data = fetch_ingredient_data_from_api(ingredient["text"])
+            save_ingredient_data(db, ingredient["text"], ingredient_data)
+        ingredient["nutritional_info"] = ingredient_data
+    
     save_json_file(barcode, data)
     return data
 

services/ingredients.py

@@ -16,18 +16,41 @@ def fetch_ingredient_data_from_api(name: str) -> Dict[str, Any]:
     response = requests.get(url)
     if response.status_code != 200:
         raise HTTPException(status_code=response.status_code, detail=f"Failed to fetch data for ingredient {name}")
-    return response.json()
+    data = response.json()
+    return {
+        "nutritional_info": data.get("nutritional_info", {}),
+        "description": data.get("description", ""),
+        "origin": data.get("origin", ""),
+        "allergens": data.get("allergens", ""),
+        "vegan": data.get("vegan", False),
+        "vegetarian": data.get("vegetarian", False)
+    }
 
 def get_ingredient_data(db: Session, name: str) -> Dict[str, Any]:
     ingredient = get_ingredient_by_name(db, name)
     if ingredient:
-        return ingredient.nutritional_info
+        return {
+            "nutritional_info": ingredient.nutritional_info,
+            "description": ingredient.description,
+            "origin": ingredient.origin,
+            "allergens": ingredient.allergens,
+            "vegan": ingredient.vegan,
+            "vegetarian": ingredient.vegetarian
+        }
     data = fetch_ingredient_data_from_api(name)
     save_ingredient_data(db, name, data)
     return data
 
 def save_ingredient_data(db: Session, name: str, data: Dict[str, Any]):
-    ingredient = Ingredient(name=name, nutritional_info=data)
+    ingredient = Ingredient(
+        name=name,
+        nutritional_info=data.get("nutritional_info", {}),
+        description=data.get("description", ""),
+        origin=data.get("origin", ""),
+        allergens=data.get("allergens", ""),
+        vegan=data.get("vegan", False),
+        vegetarian=data.get("vegetarian", False)
+    )
     db.add(ingredient)
     db.commit()
     db.refresh(ingredient)

tests/test_ai_agent_service.py

@@ -2,6 +2,8 @@ import unittest
 from unittest.mock import patch, MagicMock
 from sqlalchemy.orm import Session
 from services.ai_agent import preprocess_data, validate_data, clean_data, standardize_data, enrich_data, process_data, integrate_hugging_face_transformers
+from models.product import Product
+from models.ingredient import Ingredient
 
 class TestAIAgentService(unittest.TestCase):
 
@@ -143,5 +145,58 @@ class TestAIAgentService(unittest.TestCase):
         result = integrate_hugging_face_transformers('test_model', 'Test text')
         self.assertEqual(result, 'Test sequence')
 
+    @patch('services.ai_agent.get_ingredient_by_name')
+    @patch('services.ai_agent.fetch_ingredient_data_from_api')
+    @patch('services.ai_agent.save_ingredient_data')
+    def test_process_data_saves_ingredient_details(self, mock_save_ingredient_data, mock_fetch_ingredient_data_from_api, mock_get_ingredient_by_name):
+        db = MagicMock(spec=Session)
+        mock_get_ingredient_by_name.return_value = None
+        mock_fetch_ingredient_data_from_api.return_value = {'nutritional_info': 'Test Info'}
+        data = {
+            'product_name': 'Test Product',
+            'generic_name': 'Test Generic',
+            'brands': 'Test Brand',
+            'ingredients': [
+                {
+                    'text': 'Test Ingredient',
+                    'sub_ingredients': []
+                }
+            ],
+            'ingredients_text': 'Test Ingredients Text',
+            'ingredients_analysis': {},
+            'nutriscore': {},
+            'nutrient_levels': {},
+            'nutriments': {},
+            'data_quality_warnings': []
+        }
+        with patch('services.ai_agent.preprocess_data', return_value=data), \
+             patch('services.ai_agent.validate_data', return_value=True), \
+             patch('services.ai_agent.clean_data', return_value=data), \
+             patch('services.ai_agent.standardize_data', return_value=data), \
+             patch('services.ai_agent.enrich_data', return_value=data):
+            result = process_data(db, 'test_barcode')
+            self.assertEqual(result['product_name'], 'Test Product')
+            mock_save_ingredient_data.assert_called_once_with(db, 'Test Ingredient', {'nutritional_info': 'Test Info'})
+
+    @patch('services.ai_agent.preprocess_data')
+    @patch('services.ai_agent.validate_data')
+    @patch('services.ai_agent.clean_data')
+    @patch('services.ai_agent.standardize_data')
+    @patch('services.ai_agent.enrich_data')
+    @patch('services.ai_agent.save_json_file')
+    def test_process_data_saves_product_details(self, mock_save_json_file, mock_enrich_data, mock_standardize_data, mock_clean_data, mock_validate_data, mock_preprocess_data):
+        db = MagicMock(spec=Session)
+        mock_preprocess_data.return_value = {'product_name': 'Test Product'}
+        mock_validate_data.return_value = True
+        mock_clean_data.return_value = {'product_name': 'Test Product'}
+        mock_standardize_data.return_value = {'product_name': 'Test Product'}
+        mock_enrich_data.return_value = {'product_name': 'Test Product'}
+        result = process_data(db, 'test_barcode')
+        self.assertEqual(result['product_name'], 'Test Product')
+        mock_save_json_file.assert_called_once_with('test_barcode', {'product_name': 'Test Product'})
+        db.add.assert_called_once()
+        db.commit.assert_called_once()
+        db.refresh.assert_called_once()
+
 if __name__ == '__main__':
     unittest.main()

tests/test_analysis_agent_service.py

@@ -52,5 +52,37 @@ class TestAnalysisAgentService(unittest.TestCase):
         self.assertIn("recommended_ingredients", result)
         self.assertEqual(len(result["recommended_ingredients"]), 3)
 
+    def test_analyze_ingredients_with_new_fields(self):
+        self.db.query.return_value.filter.return_value.first.return_value = self.preferences
+        self.db.query.return_value.all.return_value = [
+            Ingredient(name="sugar", nutritional_info={"calories": 100}, description="Sweetener", origin="USA", allergens="", vegan=True, vegetarian=True),
+            Ingredient(name="salt", nutritional_info={"sodium": 200}, description="Seasoning", origin="India", allergens="", vegan=True, vegetarian=True),
+            Ingredient(name="flour", nutritional_info={"carbs": 300}, description="Baking ingredient", origin="Canada", allergens="", vegan=True, vegetarian=True)
+        ]
+
+        result = analyze_ingredients(self.db, self.ingredients, self.user_id)
+
+        self.assertIn("safe_ingredients", result)
+        self.assertIn("unsafe_ingredients", result)
+        self.assertIn("additional_facts", result)
+        self.assertEqual(len(result["safe_ingredients"]), 2)
+        self.assertEqual(len(result["unsafe_ingredients"]), 1)
+        self.assertEqual(result["safe_ingredients"][0]["description"], "Sweetener")
+        self.assertEqual(result["safe_ingredients"][1]["origin"], "India")
+
+    def test_provide_personalized_recommendations_with_new_fields(self):
+        self.db.query.return_value.all.return_value = [
+            Ingredient(name="sugar", nutritional_info={"calories": 100}, description="Sweetener", origin="USA", allergens="", vegan=True, vegetarian=True),
+            Ingredient(name="salt", nutritional_info={"sodium": 200}, description="Seasoning", origin="India", allergens="", vegan=True, vegetarian=True),
+            Ingredient(name="flour", nutritional_info={"carbs": 300}, description="Baking ingredient", origin="Canada", allergens="", vegan=True, vegetarian=True)
+        ]
+
+        result = provide_personalized_recommendations(self.db, self.user_id)
+
+        self.assertIn("recommended_ingredients", result)
+        self.assertEqual(len(result["recommended_ingredients"]), 3)
+        self.assertEqual(result["recommended_ingredients"][0]["description"], "Sweetener")
+        self.assertEqual(result["recommended_ingredients"][1]["origin"], "India")
+
 if __name__ == "__main__":
     unittest.main()

tests/test_ingredients_service.py

@@ -11,19 +11,47 @@ class TestIngredientService(unittest.TestCase):
     def test_get_ingredient_data(self, mock_save_ingredient_data, mock_fetch_ingredient_data_from_api, mock_get_ingredient_by_name):
         db = MagicMock(spec=Session)
         mock_get_ingredient_by_name.return_value = None
-        mock_fetch_ingredient_data_from_api.return_value = {"name": "test_ingredient", "nutritional_info": "test_info"}
+        mock_fetch_ingredient_data_from_api.return_value = {
+            "nutritional_info": "test_info",
+            "description": "test_description",
+            "origin": "test_origin",
+            "allergens": "test_allergens",
+            "vegan": True,
+            "vegetarian": True
+        }
 
         result = get_ingredient_data(db, "test_ingredient")
 
         mock_get_ingredient_by_name.assert_called_once_with(db, "test_ingredient")
         mock_fetch_ingredient_data_from_api.assert_called_once_with("test_ingredient")
-        mock_save_ingredient_data.assert_called_once_with(db, "test_ingredient", {"name": "test_ingredient", "nutritional_info": "test_info"})
-        self.assertEqual(result, {"name": "test_ingredient", "nutritional_info": "test_info"})
+        mock_save_ingredient_data.assert_called_once_with(db, "test_ingredient", {
+            "nutritional_info": "test_info",
+            "description": "test_description",
+            "origin": "test_origin",
+            "allergens": "test_allergens",
+            "vegan": True,
+            "vegetarian": True
+        })
+        self.assertEqual(result, {
+            "nutritional_info": "test_info",
+            "description": "test_description",
+            "origin": "test_origin",
+            "allergens": "test_allergens",
+            "vegan": True,
+            "vegetarian": True
+        })
 
     def test_save_ingredient_data(self):
         db = MagicMock(spec=Session)
         name = "test_ingredient"
-        data = {"name": "test_ingredient", "nutritional_info": "test_info"}
+        data = {
+            "nutritional_info": "test_info",
+            "description": "test_description",
+            "origin": "test_origin",
+            "allergens": "test_allergens",
+            "vegan": True,
+            "vegetarian": True
+        }
 
         save_ingredient_data(db, name, data)