Databse and model setup

db/database.py

@@ -0,0 +1,31 @@
+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"
+)
+
+# Create engine
+engine = create_engine(DATABASE_URL)
+
+# Create session factory
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Create base class for models
+Base = declarative_base()
+
+# Dependency to get DB session
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

db/models.py

@@ -0,0 +1,96 @@
+from sqlalchemy import Column, Integer, String, Float, Boolean, Text, JSON, ForeignKey, DateTime
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from .database import Base
+from typing import List, Optional
+from datetime import datetime
+
+
+class Ingredient(Base):
+    __tablename__ = "ingredients"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, unique=True, index=True)
+    alternate_names = Column(JSON, nullable=True)
+    safety_rating = Column(Integer, nullable=True)
+    description = Column(Text, nullable=True)
+    health_effects = Column(JSON, nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    # Relationships
+    sources = relationship("IngredientSource", back_populates="ingredient")
+    
+class IngredientSource(Base):
+    __tablename__ = "ingredient_sources"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    ingredient_id = Column(Integer, ForeignKey("ingredients.id"))
+    source_name = Column(String, nullable=False)
+    found = Column(Boolean, default=False)
+    summary = Column(Text, nullable=True)
+    data = Column(JSON, nullable=True)
+    
+    # Relationships
+    ingredient = relationship("Ingredient", back_populates="sources")
+    
+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)
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    email = Column(String, unique=True, index=True)
+    hashed_password = Column(String, nullable=False)
+    is_active = Column(Boolean, default=True)
+    
+    # Relationships
+    preferences = relationship(
+        "UserPreferences", 
+        back_populates="user",
+        cascade="all, delete-orphan"
+    )
+    scan_history = relationship(
+        "ScanHistory", 
+        back_populates="user",
+        cascade="all, delete-orphan"
+    )
+
+class UserPreferences(Base):
+    __tablename__ = "user_preferences"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"))
+    dietary_restrictions = Column(String, nullable=True)
+    allergens = Column(String, nullable=True)
+    preferred_ingredients = Column(String, nullable=True)
+    disliked_ingredients = Column(String, nullable=True)
+
+    # Relationships
+    user = relationship("User", back_populates="preferences")
+
+class ScanHistory(Base):
+    __tablename__ = "scan_history"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"))
+    product_id = Column(Integer)
+    scan_date = Column(DateTime, default=datetime.now)
+
+    # Relationships
+    user = relationship("User", back_populates="scan_history")

db/repositories.py

@@ -0,0 +1,88 @@
+from sqlalchemy.orm import Session
+from sqlalchemy import cast, or_, String
+from sqlalchemy.dialects.postgresql import JSONB
+from . import models
+from interfaces.ingredientModels import IngredientAnalysisResult
+
+class IngredientRepository:
+    def __init__(self, db: Session):
+        self.db = db
+    
+    def get_ingredient_by_name(self, name: str):        
+        exact_match = self.db.query(models.Ingredient).filter(models.Ingredient.name.ilike(name)).first()
+    
+        if exact_match:
+            return exact_match
+        
+        # If no exact match, try searching in alternate names
+        try:
+            # Use .first() to return the model instance, not the query object
+            alternate_match = self.db.query(models.Ingredient).filter(
+                models.Ingredient.alternate_names.cast(JSONB).op('?')(name)
+            ).first()
+            
+            return alternate_match
+        except Exception as e:
+            from logger_manager import logger
+            logger.error(f"Error searching alternate names: {e}")
+            return None
+        
+    def get_all_ingredients(self, skip: int = 0, limit: int = 100):
+        return self.db.query(models.Ingredient).offset(skip).limit(limit).all()
+    
+    def create_ingredient(self, ingredient_data: IngredientAnalysisResult):
+        # 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
+        )
+        self.db.add(db_ingredient)
+        self.db.commit()
+        self.db.refresh(db_ingredient)
+        
+        # Create source records
+        for source in ingredient_data.details_with_source:
+            db_source = models.IngredientSource(
+                ingredient_id=db_ingredient.id,
+                source_name=source.get("source", "Unknown"),
+                found=source.get("found", False),
+                summary=source.get("summary", ""),
+                data=source
+            )
+            self.db.add(db_source)
+        
+        self.db.commit()
+        return db_ingredient
+    
+    def update_ingredient(self, name: str, ingredient_data: IngredientAnalysisResult):
+        db_ingredient = self.get_ingredient_by_name(name)
+        if db_ingredient:
+            # Update ingredient fields
+            db_ingredient.alternate_names = ingredient_data.alternate_names
+            db_ingredient.safety_rating = ingredient_data.safety_rating
+            db_ingredient.description = ingredient_data.description
+            db_ingredient.health_effects = ingredient_data.health_effects
+            
+            # Delete old sources
+            self.db.query(models.IngredientSource).filter(
+                models.IngredientSource.ingredient_id == db_ingredient.id
+            ).delete()
+            
+            # Create new sources
+            for source in ingredient_data.details_with_source:
+                db_source = models.IngredientSource(
+                    ingredient_id=db_ingredient.id,
+                    source_name=source.get("source", "Unknown"),
+                    found=source.get("found", False),
+                    summary=source.get("summary", ""),
+                    data=source
+                )
+                self.db.add(db_source)
+            
+            self.db.commit()
+            self.db.refresh(db_ingredient)
+            return db_ingredient
+        return None

interfaces/authModels.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel
+
+class UserCreate(BaseModel):
+    username: str
+    email: str
+    password: str
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+    
+class UserResponse(BaseModel):
+    id: int
+    username: str
+    email: str
+    is_active: bool
+
+    class Config:
+        from_attributes = True  # This enables ORM mode
+        
+        
+class TokenData(BaseModel):
+    username: str | None = None

interfaces/ingredientModels.py

@@ -0,0 +1,33 @@
+from typing import Dict, List, Any, Optional, TypedDict
+from pydantic import BaseModel, Field
+
+
+# Define a structured output model
+class IngredientAnalysisResult(BaseModel):
+    name: str
+    alternate_names: List[str] = Field(default_factory=list)
+    is_found: bool = False
+    safety_rating: int = 5
+    description: str = "No information found."
+    health_effects: List[str] = Field(default_factory=lambda: ["Unknown"])
+    details_with_source: List[Dict[str, Any]] = [Field(default_factory=list)]
+    
+    class Config:
+        from_attributes = True  # Enable ORM mode
+
+# Define typed state for LangGraph
+class IngredientState(TypedDict):
+    ingredient: str
+    sources_data: List[Dict[str, Any]]
+    status: str
+    result: Optional[Dict[str, Any]]
+    local_db_checked: bool
+    web_search_done: bool
+    wikipedia_checked: bool
+    open_food_facts_checked: bool
+    usda_checked: bool
+    pubchem_checked: bool
+    analysis_done: bool
+
+class IngredientRequest(BaseModel):
+    name: str

models/__init__.py

@@ -1,8 +0,0 @@
-from .base import Base
-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", "Product"]

models/base.py

@@ -1,4 +0,0 @@
-from sqlalchemy.orm import DeclarativeBase
-
-class Base(DeclarativeBase):
-    pass

models/ingredient.py

@@ -1,14 +0,0 @@
-from sqlalchemy import Column, Integer, String, JSON, Boolean
-from .base import Base
-
-class Ingredient(Base):
-    __tablename__ = "ingredients"
-
-    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

@@ -1,17 +0,0 @@
-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)

models/scan_history.py

@@ -1,16 +0,0 @@
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy import ForeignKey, Integer, DateTime
-from datetime import datetime
-from .base import Base
-from typing import Optional
-
-class ScanHistory(Base):
-    __tablename__ = "scan_history"
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    user_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"))
-    product_id: Mapped[int] = mapped_column(Integer)
-    scan_date: Mapped[datetime] = mapped_column(DateTime, default=datetime.now)
-
-    # Add relationship to user
-    user: Mapped["User"] = relationship("User", back_populates="scan_history")

models/user.py

@@ -1,28 +0,0 @@
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy import String, Boolean
-from typing import List, TYPE_CHECKING
-from .base import Base
-
-if TYPE_CHECKING:
-    from .user_preferences import UserPreferences
-
-class User(Base):
-    __tablename__ = "users"
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    username: Mapped[str] = mapped_column(String, unique=True, index=True)
-    email: Mapped[str] = mapped_column(String, unique=True, index=True)
-    hashed_password: Mapped[str] = mapped_column(String)
-    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
-    
-    preferences: Mapped[List["UserPreferences"]] = relationship(
-        "UserPreferences", 
-        back_populates="user",
-        cascade="all, delete-orphan"
-    )
-    # Add relationship to scan history
-    scan_history: Mapped[List["ScanHistory"]] = relationship(
-        "ScanHistory", 
-        back_populates="user",
-        cascade="all, delete-orphan"
-    )

models/user_preferences.py

@@ -1,19 +0,0 @@
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy import ForeignKey, String
-from typing import Optional, TYPE_CHECKING
-from .base import Base
-
-if TYPE_CHECKING:
-    from .user import User
-
-class UserPreferences(Base):
-    __tablename__ = "user_preferences"
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    user_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"))
-    dietary_restrictions: Mapped[Optional[str]] = mapped_column(String, nullable=True)
-    allergens: Mapped[Optional[str]] = mapped_column(String, nullable=True)
-    preferred_ingredients: Mapped[Optional[str]] = mapped_column(String, nullable=True)
-    disliked_ingredients: Mapped[Optional[str]] = mapped_column(String, nullable=True)
-
-    user: Mapped["User"] = relationship("User", back_populates="preferences")