Adding migrations from alembic

Dockerfile

@@ -1,6 +1,12 @@
 # Use a lightweight Python image
 FROM python:3.10.12
 
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
 # Create a non-root user
 RUN useradd -m -u 1000 user
 
@@ -15,13 +21,16 @@ RUN pip install --no-cache-dir --upgrade -r requirements.txt
 COPY . .
 
 # Create and set permissions for the cache directory
-RUN mkdir /.cache && chown -R user:user /.cache && chmod -R u+w,go-w /.cache
+RUN mkdir -p /.cache /app/.cache && \
+    chown -R user:user /.cache /app/.cache && \
+    chmod -R u+w,go-w /.cache /app/.cache
 
-# Set up the environment variables for Alembic
+# Set up the environment variables
 ENV ALEMBIC_CONFIG=alembic.ini
+ENV TORCH_HOME=/app/.cache/torch
 
 # Switch to the non-root user
 USER user
 
 # Run the application, including the migration step
-CMD ["bash", "-c", "alembic upgrade head && uvicorn main:app --host 0.0.0.0 --port 7860"]
+CMD ["bash", "-c", "alembic upgrade head && uvicorn main:app --host 0.0.0.0 --port 7860"]

alembic/versions/6936c1095473_adding_changes_stated_from_app_.py

@@ -0,0 +1,26 @@
+"""Adding Changes stated from APP developer side
+
+Revision ID: 6936c1095473
+Revises: b55dbab76bb4
+Create Date: 2024-08-31 04:14:27.218586
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '6936c1095473'
+down_revision: Union[str, None] = 'b55dbab76bb4'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    pass
+
+
+def downgrade() -> None:
+    pass

orders/models.py

@@ -1,5 +1,5 @@
 # models.py
-from sqlalchemy import Column, ForeignKey, Integer, String, Float, DateTime
+from sqlalchemy import Column, ForeignKey, Integer, String, Float, DateTime, LargeBinary
 from sqlalchemy.orm import relationship
 from core.database import Base
 from datetime import datetime
@@ -26,3 +26,10 @@ class Order(Base):
 
     user = relationship("User", back_populates="orders")
     meal = relationship("Meal", back_populates="orders")
+
+class RecommendationModel(Base):
+    __tablename__ = "recommendation_models"
+
+    id = Column(Integer, primary_key=True, index=True)
+    model = Column(LargeBinary, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)

orders/routes.py

@@ -1,9 +1,11 @@
-from fastapi import APIRouter, status, Depends, HTTPException
+from fastapi import APIRouter, status, Depends, BackgroundTasks, HTTPException
+from fastapi.responses import JSONResponse
 from typing import List, Optional
 from core.database import get_db
 from core.security import get_current_user
 from orders.services import create_meal, get_meals, get_meal, update_meal, delete_meal, create_user_order, get_user_orders
 from orders.schemas import OrderCreate, OrderBase, Order, MealBase, MealCreate, MealUpdate, Meal
+from users.schemas import User
 from sqlalchemy.orm import Session
 from services.recommendation_service import MealRecommender
 
@@ -28,7 +30,12 @@ def health_check():
 
 @meal_router.post("/", response_model=MealBase, status_code=status.HTTP_201_CREATED)
 async def meal_create(data: MealCreate, db: Session = Depends(get_db)):
-    return create_meal(db, data)
+    new_meal = await create_meal(db, data)
+    id, name = new_meal.id, new_meal.name
+    return JSONResponse(
+        content={"id": id, "name": name},
+        status_code=status.HTTP_200_OK
+        )
 
 
 @meal_router.get("/", response_model=List[MealBase])
@@ -62,7 +69,11 @@ def meal_delete(meal_id: int, db: Session = Depends(get_db)):
 
 @order_router.post("/", response_model=OrderBase, status_code=status.HTTP_201_CREATED)
 def create_order(order: OrderCreate, current_user: OrderBase = Depends(get_current_user), db: Session = Depends(get_db)):
-    return create_user_order(db, order, current_user.id)
+    new_order = create_user_order(db, order, current_user.id)
+    return JSONResponse(
+        content={"id": new_order.id, "meal_id": new_order.meal_id, "quantity": new_order.quantity},
+        status_code=status.HTTP_200_OK
+        )
 
 
 @order_router.get("/", response_model=List[OrderBase])
@@ -71,8 +82,15 @@ def get_orders(current_user: OrderBase = Depends(get_current_user), skip: int =
 
 
 @meal_router.get("/recommendations/", response_model=List[MealBase])
-async def get_recommendations(current_user: OrderBase = Depends(get_current_user), db: Session = Depends(get_db)):
+async def get_recommendations(
+    background_tasks: BackgroundTasks,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+    ):
     recommender = MealRecommender(db)
     recommendations = recommender.get_recommendations(current_user)
+    
+    # Schedule model retraining in the background
+    background_tasks.add_task(recommender.train_model)
+    
     return recommendations
-

orders/schemas.py

@@ -30,3 +30,14 @@ class Order(OrderBase):
 
     class Config:
         orm_mode = True
+
+
+class Recommendation(BaseModel):
+    meal_id: int
+    name: str
+    description: str
+    price: float
+    score: float
+
+    class Config:
+        orm_mode = True

services/face_match.py

@@ -3,6 +3,9 @@ import numpy as np
 from sqlalchemy.orm import Session
 from users.models import UserEmbeddings
 from core.config import get_settings
+import logging
+
+logger = logging.getLogger(__name__)
 
 settings = get_settings()
 
@@ -10,28 +13,59 @@ class FaceMatch:
     def __init__(self, db: Session):
         self.db = db
         self.threshold = settings.FACE_RECOGNITION_THRESHOLD
+        self.max_matches = 1  # Only allow one match
+        self.embedding_shape = None  # Will be set when loading embeddings
 
     def load_embeddings_from_db(self):
         user_embeddings = self.db.query(UserEmbeddings).all()
-        return {ue.user_id: np.array(ue.embeddings) for ue in user_embeddings}
+        embeddings_dict = {}
+        for ue in user_embeddings:
+            embedding = np.array(ue.embeddings)
+            if self.embedding_shape is None:
+                self.embedding_shape = embedding.shape
+            elif embedding.shape != self.embedding_shape:
+                logger.warning(f"Inconsistent embedding shape for user {ue.user_id}. Expected {self.embedding_shape}, got {embedding.shape}")
+                continue  # Skip this embedding
+            embeddings_dict[ue.user_id] = embedding
+        return embeddings_dict
+
+    def validate_embedding(self, embedding):
+        if self.embedding_shape is None:
+            logger.warning("No reference embedding shape available")
+            return False
+        if np.array(embedding).shape != self.embedding_shape:
+            logger.warning(f"Invalid embedding shape. Expected {self.embedding_shape}, got {np.array(embedding).shape}")
+            return False
+        return True
 
     def match_faces(self, new_embeddings, saved_embeddings):
+        if not self.validate_embedding(new_embeddings):
+            return None, 0
+
         new_embeddings = np.array(new_embeddings)
-        max_similarity = 0
-        identity = None
+        similarities = []
 
         for user_id, stored_embeddings in saved_embeddings.items():
             similarity = cosine_similarity(new_embeddings.reshape(1, -1), stored_embeddings.reshape(1, -1))[0][0]
-            if similarity > max_similarity:
-                max_similarity = similarity
-                identity = user_id
+            similarities.append((user_id, similarity))
 
-        return identity, max_similarity if max_similarity > self.threshold else (None, 0)
+        # Sort similarities in descending order
+        similarities.sort(key=lambda x: x[1], reverse=True)
+
+        # Check if the top match exceeds the threshold and if there's a significant gap to the second-best match
+        if similarities and similarities[0][1] > self.threshold:
+            if len(similarities) == 1 or similarities[0][1] - similarities[1][1] > 0.1:
+                return similarities[0]
+        
+        return None, 0
 
     def new_face_matching(self, new_embeddings):
         embeddings_dict = self.load_embeddings_from_db()
         if not embeddings_dict:
-            return {'status': 'Error', 'message': 'No embeddings available in the database'}
+            return {'status': 'Error', 'message': 'No valid embeddings available in the database'}
+
+        if not self.validate_embedding(new_embeddings):
+            return {'status': 'Error', 'message': 'Invalid embedding shape'}
 
         identity, similarity = self.match_faces(new_embeddings, embeddings_dict)
         if identity:
@@ -43,5 +77,5 @@ class FaceMatch:
             }
         return {
             'status': 'Error',
-            'message': 'No matching face found'
+            'message': 'No matching face found or multiple potential matches detected'
         }

services/facial_processing.py

@@ -22,12 +22,16 @@ class FacialProcessing:
             # Detect faces
             boxes, _ = self.mtcnn.detect(img)
             
-            if boxes is None:
+            if boxes is None or len(boxes) == 0:
                 logger.warning(f"No face detected in image: {image_path}")
                 return None
             
+            if len(boxes) > 1:
+                logger.warning(f"Multiple faces detected in image: {image_path}")
+                return None
+            
             # Get the largest face
-            largest_box = max(boxes, key=lambda box: (box[2] - box[0]) * (box[3] - box[1]))
+            largest_box = boxes[0]
             face = self.mtcnn(img, return_prob=False)
             
             if face is None:
@@ -35,9 +39,19 @@ class FacialProcessing:
                 return None
             
             # Extract embeddings
-            embeddings = self.resnet(face).detach().cpu().numpy().flatten()
+            with torch.no_grad():
+                embeddings = self.resnet(face).cpu().numpy().flatten()
             return embeddings.tolist()
             
         except Exception as e:
             logger.error(f"An error occurred while extracting embeddings: {e}")
+            return None
+
+    def preprocess_image(self, image_path):
+        try:
+            img = Image.open(image_path)
+            img = img.convert('RGB')
+            return img
+        except Exception as e:
+            logger.error(f"Error opening image: {e}")
             return None

services/recommendation_service.py

@@ -1,70 +1,63 @@
-# recommender_system.py
 import pandas as pd
 from surprise import Dataset, Reader, SVD
 from surprise.model_selection import train_test_split
-import joblib
 from datetime import datetime, timedelta
-import os
+import pickle
 import random
 from sqlalchemy.orm import Session
+from sqlalchemy import func
 from typing import List
-from orders.models import Order, Meal
+from orders.models import Order, Meal, RecommendationModel
 from users.models import User
 
-
 class MealRecommender:
     def __init__(self, db: Session):
         self.db = db
-        self.model_path = 'recommendation_model.joblib'
-        self.last_train_path = 'last_train_time.txt'
         self.retrain_interval = timedelta(days=1)
         self.algo = self.load_or_train_model()
 
     def fetch_data(self):
-        orders = self.db.query(Order).all()
-        return pd.DataFrame([(order.user_id, order.meal_id, order.quantity) for order in orders], 
-                            columns=['user_id', 'meal_id', 'quantity'])
+        # Fetch data in batches to handle large datasets
+        batch_size = 1000
+        offset = 0
+        data = []
+        while True:
+            batch = self.db.query(Order.user_id, Order.meal_id, Order.quantity).offset(offset).limit(batch_size).all()
+            if not batch:
+                break
+            data.extend(batch)
+            offset += batch_size
+        return pd.DataFrame(data, columns=['user_id', 'meal_id', 'quantity'])
 
     def train_model(self):
         data = self.fetch_data()
         if data.empty:
-            self.algo = None
             return None
-        
+
         reader = Reader(rating_scale=(1, 5))
         dataset = Dataset.load_from_df(data[['user_id', 'meal_id', 'quantity']], reader)
-    
+
         trainset = dataset.build_full_trainset()
         algo = SVD()
         algo.fit(trainset)
-        
-        joblib.dump(algo, self.model_path)
-        self._update_last_train_time()
+
+        # Save model to database
+        model_binary = pickle.dumps(algo)
+        model_record = RecommendationModel(model=model_binary, created_at=datetime.now())
+        self.db.add(model_record)
+        self.db.commit()
+
         return algo
 
     def load_or_train_model(self):
-        try:
-            if self._should_retrain():
-                return self.train_model()
-            return joblib.load(self.model_path)
-        except FileNotFoundError:
-            return self.train_model()
-
-    def _should_retrain(self):
-        if not os.path.exists(self.last_train_path):
-            return True
-        with open(self.last_train_path, 'r') as f:
-            last_train_time = datetime.fromisoformat(f.read().strip())
-        return datetime.now() - last_train_time > self.retrain_interval
+        latest_model = self.db.query(RecommendationModel).order_by(RecommendationModel.created_at.desc()).first()
 
-    def _update_last_train_time(self):
-        with open(self.last_train_path, 'w') as f:
-            f.write(datetime.now().isoformat())
+        if latest_model and datetime.now() - latest_model.created_at <= self.retrain_interval:
+            return pickle.loads(latest_model.model)
+        else:
+            return self.train_model()
 
     def get_recommendations(self, user: User):
-        if self._should_retrain():
-            self.algo = self.train_model()
-
         if self.algo is None:
             return self.get_random_recommendations()
 

users/models.py

@@ -8,7 +8,6 @@ class User(Base):
 
     id = Column(Integer, primary_key=True, index=True)
     email = Column(String, unique=True, index=True, nullable=False)
-    username = Column(String, unique=True, index=True, nullable=False)
     password = Column(String, nullable=False)
     first_name = Column(String, nullable=True) 
     last_name = Column(String, nullable=True)   

users/routes.py

@@ -25,8 +25,18 @@ router = APIRouter(
 @router.post("/", status_code=status.HTTP_201_CREATED, response_model=UserBase)
 async def create_user(data: UserCreate, db: Session = Depends(get_db)):
     new_user = await create_user_account(data, db)
-    return new_user
-
+    access_token_expires = timedelta(minutes=int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "30")))
+    payload = {"id": new_user.id, "sub": new_user.email}
+    access_token = await create_access_token(data=payload, expiry=access_token_expires)
+    refresh_token = await create_refresh_token(data=payload)
+
+    return JSONResponse(content={
+        "access_token": access_token,
+        "refresh_token": refresh_token,
+        "token_type": "Bearer",
+        "expires_in": access_token_expires.seconds
+    }, status_code=status.HTTP_200_OK)
+    
 @router.get("/me/", response_model=UserBase)
 async def read_users_me(current_user: User = Depends(get_current_user)):
     return current_user

users/schemas.py

@@ -3,7 +3,6 @@ from typing import Optional, List
 from datetime import datetime
 
 class UserBase(BaseModel):
-    username: str = Field(..., min_length=3, max_length=50)
     first_name: str = Field(..., min_length=1, max_length=50)
     last_name: str = Field(..., min_length=1, max_length=50)
     email: EmailStr
@@ -14,7 +13,6 @@ class UserCreate(UserBase):
     password: str = Field(..., min_length=8)
 
 class UserUpdate(BaseModel):
-    username: Optional[str] = Field(None, min_length=3, max_length=50)
     first_name: Optional[str] = Field(None, min_length=1, max_length=50)
     last_name: Optional[str] = Field(None, min_length=1, max_length=50)
     email: Optional[EmailStr] = None

users/services.py

@@ -12,7 +12,6 @@ async def create_user_account(data: UserCreate, db: Session):
     
     new_user = User(
         email=data.email,
-        username=data.username,
         first_name=data.first_name,
         last_name=data.last_name,
         age=data.age,