Push new edits

core/config.py

@@ -2,31 +2,42 @@ import os
 from pathlib import Path
 from dotenv import load_dotenv
 from urllib.parse import quote_plus
-from pydantic_settings import BaseSettings  # Make sure this import is correct
+from pydantic_settings import BaseSettings
 
 load_dotenv()
 
 class Settings(BaseSettings):
-    # Use environment variables to configure the database URL components
+    # Database settings
     DATABASE_USER: str = os.getenv("PG_USER")
     DATABASE_PASSWORD: str = os.getenv("PG_PASSWORD")
     DATABASE_HOST: str = os.getenv("PG_HOST")
     DATABASE_PORT: str = os.getenv("PG_PORT")
     DATABASE_NAME: str = os.getenv("PG_NAME")
     
-    # Combine components into the full URL using a property
+    # JWT settings
+    JWT_SECRET_KEY: str = os.getenv("JWT_SECRET")
+    JWT_ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "30"))
+    REFRESH_TOKEN_EXPIRE_DAYS: int = int(os.getenv("REFRESH_TOKEN_EXPIRE_DAYS", "7"))
+
+    # Application settings
+    DEBUG: bool = os.getenv("DEBUG", "False").lower() == "true"
+    ALLOWED_HOSTS: list = os.getenv("ALLOWED_HOSTS", "*").split(",")
+
+    # Face recognition settings
+    FACE_RECOGNITION_THRESHOLD: float = float(os.getenv("FACE_RECOGNITION_THRESHOLD", "0.6"))
+
     @property
     def DATABASE_URL(self) -> str:
         user = quote_plus(self.DATABASE_USER)
         password = quote_plus(self.DATABASE_PASSWORD)
         return f"postgresql://{user}:{password}@{self.DATABASE_HOST}:{self.DATABASE_PORT}/{self.DATABASE_NAME}?sslmode=require"
 
-    JWT_SECRET_KEY: str = os.getenv("JWT_SECRET")
-    JWT_ALGORITHM: str = os.getenv("JWT_ALGORITHM")
-    ACCESS_TOKEN_EXPIRE_MINUTES: int = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", default="30"))  # Default value as fallback
+    class Config:
+        env_file = ".env"
 
-def get_settings():
+def get_settings() -> Settings:
     return Settings()
 
 # Usage example
-settings = get_settings()
+settings = get_settings()

core/database.py

@@ -14,6 +14,7 @@ engine = create_engine(
     max_overflow=0
                        
                        )
+
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
 Base = declarative_base()

core/security.py

@@ -1,75 +1,59 @@
 from passlib.context import CryptContext
 from fastapi.security import OAuth2PasswordBearer
-from fastapi import Depends, HTTPException
+from fastapi import Depends, HTTPException, status
 from datetime import timedelta, datetime
 from jose import JWTError, jwt
 from core.config import get_settings
 from sqlalchemy.orm import Session
 from core.database import get_db
 
-
 settings = get_settings()
 
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-oauth2scheme = OAuth2PasswordBearer(tokenUrl="auth/token/")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="auth/token/")
 
-def get_password_hash(password):
+def get_password_hash(password: str) -> str:
     return pwd_context.hash(password)
 
-def verify_password(plain_password, hashed_password):
+def verify_password(plain_password: str, hashed_password: str) -> bool:
     return pwd_context.verify(plain_password, hashed_password)
 
-async def create_access_token(data:dict, expiry:timedelta):
+async def create_access_token(data: dict, expiry: timedelta) -> str:
     payload = data.copy()
     expire = datetime.utcnow() + expiry
     payload.update({"exp": expire})
-    token = jwt.encode(payload,
-                       settings.JWT_SECRET_KEY,
-                       algorithm=settings.JWT_ALGORITHM)
-    
-    return token
+    return jwt.encode(payload, settings.JWT_SECRET_KEY, algorithm=settings.JWT_ALGORITHM)
 
-async def create_refresh_token(data:dict):
+async def create_refresh_token(data: dict) -> str:
     payload = data.copy()
-    token = jwt.encode(payload,
-                       settings.JWT_SECRET_KEY,
-                       algorithm=settings.JWT_ALGORITHM)
-    return token
+    return jwt.encode(payload, settings.JWT_SECRET_KEY, algorithm=settings.JWT_ALGORITHM)
 
-def get_token_payload(token:str):
+def get_token_payload(token: str) -> dict:
     try:
-        payload = jwt.decode(token,
-                             settings.JWT_SECRET_KEY,
-                             algorithms=[settings.JWT_ALGORITHM])
-        return payload
+        return jwt.decode(token, settings.JWT_SECRET_KEY, algorithms=[settings.JWT_ALGORITHM])
     except JWTError:
         return None
-    
-async def get_current_user(token: str = Depends(oauth2scheme), db: Session = Depends(get_db)):
-    from users.services import get_user_by_email  # Local import
+
+async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    from users.services import get_user_by_email  # Local import to avoid circular dependency
+
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
 
     try:
         payload = get_token_payload(token)
-        email = payload.get("sub")
+        if payload is None:
+            raise credentials_exception
+        email: str = payload.get("sub")
         if email is None:
-            raise HTTPException(status_code=401,
-                                detail="Invalid Token",
-                                headers={"WWW-Authenticate": "Bearer"})
+            raise credentials_exception
     except JWTError:
-        raise HTTPException(status_code=401,
-                            detail="Invalid Token",
-                            headers={"WWW-Authenticate": "Bearer"}
-                            )
-    
+        raise credentials_exception
+
     user = get_user_by_email(email, db=db)
     if user is None:
-        raise HTTPException(status_code=401,
-                            detail="User not found",
-                            headers={"WWW-Authenticate": "Bearer"}
-                            )
-    return user
-
-
-
-
-    
+        raise credentials_exception
+    return user

main.py

@@ -1,6 +1,5 @@
-# main.py
 from fastapi import FastAPI
-from typing import List
+from fastapi.middleware.cors import CORSMiddleware
 from users.routes import router as users_router
 from auth.route import router as auth_router
 from orders.routes import order_router, meal_router
@@ -13,24 +12,30 @@ app = FastAPI(
     redoc_url="/redoc",
     openapi_url="/openapi.json",
 )
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+# Include routers
 app.include_router(users_router)
 app.include_router(auth_router)
 app.include_router(meal_router)
 app.include_router(order_router)
 
-
 @app.get("/", tags=["Home"])
 def read_root():
     return {"message": "Welcome to SnapFeast API!"}
 
-
 @app.get("/health", tags=["Health"])
 def health_check():
     return {"status": "ok"}
 
-
 if __name__ == "__main__":
     import uvicorn
-
-    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")
-
+    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")

services/face_match.py

@@ -2,16 +2,20 @@ from sklearn.metrics.pairwise import cosine_similarity
 import numpy as np
 from sqlalchemy.orm import Session
 from users.models import UserEmbeddings
+from core.config import get_settings
+
+settings = get_settings()
 
 class FaceMatch:
     def __init__(self, db: Session):
         self.db = db
+        self.threshold = settings.FACE_RECOGNITION_THRESHOLD
 
     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}
 
-    def match_faces(self, new_embeddings, saved_embeddings, threshold=0.6):
+    def match_faces(self, new_embeddings, saved_embeddings):
         new_embeddings = np.array(new_embeddings)
         max_similarity = 0
         identity = None
@@ -22,12 +26,12 @@ class FaceMatch:
                 max_similarity = similarity
                 identity = user_id
 
-        return identity, max_similarity if max_similarity > threshold else (None, 0)
+        return identity, max_similarity if max_similarity > self.threshold else (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'}
+            return {'status': 'Error', 'message': 'No embeddings available in the database'}
 
         identity, similarity = self.match_faces(new_embeddings, embeddings_dict)
         if identity:
@@ -35,10 +39,9 @@ class FaceMatch:
                 'status': 'Success',
                 'message': 'Match Found',
                 'user_id': identity,
-                'similarity': similarity
+                'similarity': float(similarity)  # Convert numpy float to Python float
             }
         return {
             'status': 'Error',
             'message': 'No matching face found'
-        }
-
+        }

services/facial_processing.py

@@ -3,35 +3,41 @@ import os
 import torch
 from facenet_pytorch import MTCNN, InceptionResnetV1
 import logging
+from PIL import Image
 
 logger = logging.getLogger(__name__)
 
-
 class FacialProcessing:
     def __init__(self):
-        # Set the cache directory to a writable location
         os.environ['TORCH_HOME'] = '/tmp/.cache/torch'
-
         self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.mtcnn = MTCNN(keep_all=True, device=self.device)
+        self.resnet = InceptionResnetV1(pretrained='vggface2').eval().to(self.device)
 
-        self.mtcnn = MTCNN(keep_all=True, device=device)
-        self.resnet = InceptionResnetV1(pretrained='vggface2').eval().to(device)
-
-
-    def extract_embeddings_vgg(self, image):
+    def extract_embeddings_vgg(self, image_path):
         try:
-            # Preprocess the image
-            preprocessed_image = self.mtcnn(image)
-
-            if preprocessed_image is None:
-                logger.warning(f"No face detected in image")
+            img = Image.open(image_path)
+            img = img.convert('RGB')
+            
+            # Detect faces
+            boxes, _ = self.mtcnn.detect(img)
+            
+            if boxes is None:
+                logger.warning(f"No face 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]))
+            face = self.mtcnn(img, return_prob=False)
+            
+            if face is None:
+                logger.warning(f"Failed to align face in image: {image_path}")
                 return None
             
-            # Extract the face embeddings
-            embeddings = self.resnet(preprocessed_image.unsqueeze(0)).detach().cpu().numpy().tolist()
-            if embeddings:
-                return embeddings[0]
+            # Extract embeddings
+            embeddings = self.resnet(face).detach().cpu().numpy().flatten()
+            return embeddings.tolist()
             
         except Exception as e:
             logger.error(f"An error occurred while extracting embeddings: {e}")
-            return None
+            return None

users/models.py

@@ -7,16 +7,16 @@ class User(Base):
     __tablename__ = "users"
 
     id = Column(Integer, primary_key=True, index=True)
-    email = Column(String, unique=True, index=True)
-    username = Column(String, unique=True, index=True)
-    hashed_password = Column(String)
+    email = Column(String, unique=True, index=True, nullable=False)
+    username = Column(String, unique=True, index=True, nullable=False)
+    hashed_password = Column(String, nullable=False)
     first_name = Column(String)
     last_name = Column(String)
     age = Column(Integer)
     preferences = Column(ARRAY(String))
     is_active = Column(Boolean, default=True)
     is_admin = Column(Boolean, default=False)
-    updated_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
     created_at = Column(DateTime, default=datetime.utcnow)
 
     orders = relationship("Order", back_populates="user")
@@ -26,7 +26,7 @@ class UserEmbeddings(Base):
     __tablename__ = "user_embeddings"
 
     id = Column(Integer, primary_key=True, index=True)
-    user_id = Column(Integer, ForeignKey("users.id"))
-    embeddings = Column(ARRAY(Float))
+    user_id = Column(Integer, ForeignKey("users.id"), unique=True, nullable=False)
+    embeddings = Column(ARRAY(Float), nullable=False)
 
-    user = relationship("User", back_populates="embeddings")
+    user = relationship("User", back_populates="embeddings")

users/routes.py

@@ -3,7 +3,7 @@ from fastapi.responses import JSONResponse
 from sqlalchemy.orm import Session
 from core.database import get_db
 from core.security import get_current_user, create_access_token
-from users.schemas import UserCreate, UserBase, UserEmbeddingsBase, User
+from users.schemas import UserCreate, UserBase, UserEmbeddingsBase, User, UserUpdate
 from users.services import create_user_account, create_user_embeddings, update_user, update_user_embeddings, get_user_by_id, get_user_by_email
 from services.facial_processing import FacialProcessing
 from services.face_match import FaceMatch
@@ -12,7 +12,6 @@ from datetime import timedelta
 from dotenv import load_dotenv
 from auth.services import get_token
 
-
 load_dotenv()
 
 router = APIRouter(
@@ -21,104 +20,81 @@ router = APIRouter(
     responses={404: {"description": "Not found"}},
 )
 
-@router.get("/health", tags=["Health"])
-def health_check():
-    return {"status": "ok"}
-
 @router.post("/", status_code=status.HTTP_201_CREATED, response_model=UserBase)
 async def create_user(data: UserCreate, db: Session = Depends(get_db)):
-    await create_user_account(data, db)
-    payload = {"message": "User created successfully"}
-    return JSONResponse(content=payload, status_code=status.HTTP_201_CREATED)
-
-
-@router.post("/me",status_code=status.HTTP_200_OK)
-def get_user_details(request: Request):
-    user = request.user
-    return user
+    new_user = await create_user_account(data, db)
+    return new_user
 
 @router.get("/me", response_model=UserBase)
 async def read_users_me(current_user: User = Depends(get_current_user)):
     return current_user
 
 @router.put("/me", response_model=UserBase)
-async def updating_user(user: UserBase, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
-    user = update_user(db, current_user.id, user)
-    return current_user
-
+async def update_user_me(user: UserUpdate, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    updated_user = update_user(db, current_user.id, user)
+    return updated_user
 
-@router.post("/me/face",status_code=status.HTTP_200_OK)
-async def create_face_embeddings(file: UploadFile = File(...), user:User = Depends(get_current_user), db: Session = Depends(get_db)):
+@router.post("/me/face", status_code=status.HTTP_200_OK)
+async def create_face_embeddings(file: UploadFile = File(...), user: User = Depends(get_current_user), db: Session = Depends(get_db)):
     face_processor = FacialProcessing()
 
-    # Process the uploaded image
     image_path = f"faces/{user.id}.jpg"
     with open(image_path, "wb") as buffer:
         buffer.write(await file.read())
 
-    # Extract embeddings
     embeddings = face_processor.extract_embeddings_vgg(image_path)
     if embeddings:
-        create_user_embeddings(user.id, embeddings, db)
+        user_embeddings = UserEmbeddingsBase(embeddings=embeddings)
+        await create_user_embeddings(user.id, user_embeddings, db)
         return {"message": "Face embeddings created successfully"}
 
-    raise HTTPException(status_code=400,
-                        detail="Failed to process face"
-                        )
+    raise HTTPException(status_code=400, detail="Failed to process face")
 
-@router.get("/me/face",status_code=status.HTTP_200_OK)
-async def get_face_embeddings(user:User = Depends(get_current_user), db: Session = Depends(get_db)):
+@router.get("/me/face", status_code=status.HTTP_200_OK)
+async def get_face_embeddings(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
     face = db.query(UserEmbeddingsBase).filter(UserEmbeddingsBase.user_id == user.id).first()
     if not face:
-        raise HTTPException(status_code=404,
-                            detail="Face embeddings not found"
-                            )
+        raise HTTPException(status_code=404, detail="Face embeddings not found")
     return JSONResponse(content={"embeddings": face.embeddings}, status_code=status.HTTP_200_OK)
 
-@router.put("/me/face",status_code=status.HTTP_200_OK)
-async def updating_face_embeddings(file: UploadFile = File(...), user:User = Depends(get_current_user), db: Session = Depends(get_db)):
+@router.put("/me/face", status_code=status.HTTP_200_OK)
+async def update_face_embeddings(file: UploadFile = File(...), user: User = Depends(get_current_user), db: Session = Depends(get_db)):
     face_processor = FacialProcessing()
 
-    # Process the uploaded image
     image_path = f"faces/{user.id}.jpg"
     with open(image_path, "wb") as buffer:
         buffer.write(await file.read())
 
-    # Extract embeddings
     embeddings = face_processor.extract_embeddings_vgg(image_path)
     if embeddings:
-        update_user_embeddings(user.id, embeddings, db)
+        user_embeddings = UserEmbeddingsBase(embeddings=embeddings)
+        await update_user_embeddings(user.id, user_embeddings, db)
         return {"message": "Face embeddings updated successfully"}
 
-    raise HTTPException(status_code=400,
-                        detail="Failed to process face"
-                        )
+    raise HTTPException(status_code=400, detail="Failed to process face")
 
 @router.post("/login/face")
 async def face_login(file: UploadFile = File(...), db: Session = Depends(get_db)):
     face_processor = FacialProcessing()
     face_matcher = FaceMatch(db)
 
-    # Process the uploaded image
     image_path = f"temp_{file.filename}"
     with open(image_path, "wb") as buffer:
         buffer.write(await file.read())
 
-    # Extract embeddings
     embeddings = await face_processor.extract_embeddings(image_path)
     if not embeddings:
         raise HTTPException(status_code=400, detail="Failed to process face")
     
-    # Match face
     match_result = face_matcher.new_face_matching(embeddings)
     if match_result['status'] == 'Success':
         user = get_user_by_id(match_result['user_id'], db)
         if not user:
             raise HTTPException(status_code=404, detail="User not found")
         
-        access_token_expires = timedelta(minutes=os.getenv("ACCESS_TOKEN"))
-        payload = {"id":user.id, "sub": user.email}
+        access_token_expires = timedelta(minutes=int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "30")))
+        payload = {"id": user.id, "sub": user.email}
         token = get_token(payload, db)
         return JSONResponse(content=token.dict(), status_code=status.HTTP_200_OK)
     
-    raise HTTPException(status_code=401, detail="Face not recognized")
+    raise HTTPException(status_code=401, detail="Face not recognized")

users/schemas.py

@@ -1,25 +1,34 @@
-from pydantic import BaseModel, EmailStr
+from pydantic import BaseModel, EmailStr, Field
 from typing import Optional, List
+from datetime import datetime
 
 class UserBase(BaseModel):
-    username: str
-    first_name: str
-    last_name: str
+    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
-    age: Optional[int] = None
+    age: Optional[int] = Field(None, ge=0, le=120)
     preferences: Optional[List[str]] = None
-    is_active: Optional[bool] = True
-
+    is_active: bool = True
 
 class UserCreate(UserBase):
-    password: str
-
-
-class UserUpdate(UserBase):
-    password: Optional[str] = None
+    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
+    age: Optional[int] = Field(None, ge=0, le=120)
+    preferences: Optional[List[str]] = None
+    password: Optional[str] = Field(None, min_length=8)
 
 class User(UserBase):
     id: int
+    is_active: bool
+    is_admin: bool
+    created_at: datetime
+    updated_at: datetime
 
     class Config:
         orm_mode = True
@@ -30,11 +39,9 @@ class UserEmbeddingsBase(BaseModel):
 class UserEmbeddingsCreate(UserEmbeddingsBase):
     pass
 
-
 class UserEmbeddings(UserEmbeddingsBase):
     id: int
     user_id: int
 
     class Config:
-        orm_mode = True
-
+        orm_mode = True

users/services.py

@@ -1,26 +1,23 @@
 from users.models import User, UserEmbeddings
-from fastapi.exceptions import HTTPException
+from fastapi import HTTPException
 from core.security import get_password_hash
 from datetime import datetime
 from sqlalchemy.orm import Session
-from users.schemas import UserCreate, UserUpdate, UserEmbeddings
+from users.schemas import UserCreate, UserUpdate, UserEmbeddingsBase
 
-
-
-async def create_user_account(data:UserCreate, db:Session):
+async def create_user_account(data: UserCreate, db: Session):
     user = db.query(User).filter(User.email == data.email).first()
     if user:
-        raise HTTPException(status_code=422, detail="Email already registered")
+        raise HTTPException(status_code=400, detail="Email already registered")
     
     new_user = User(
         email=data.email,
+        username=data.username,
         first_name=data.first_name,
         last_name=data.last_name,
         age=data.age,
         preferences=data.preferences,
-        password = get_password_hash(data.password),
-        registered_at=datetime.now(),
-        updated_at=datetime.now(),   
+        hashed_password=get_password_hash(data.password),
     )
 
     db.add(new_user)
@@ -28,58 +25,63 @@ async def create_user_account(data:UserCreate, db:Session):
     db.refresh(new_user)
     return new_user
 
-async def create_user_embeddings(user_id:int, embeddings:UserEmbeddings, db:Session):
+async def create_user_embeddings(user_id: int, embeddings: UserEmbeddingsBase, db: Session):
     user = db.query(User).filter(User.id == user_id).first()
     if not user:
-        embeddings = UserEmbeddings(user_id=user_id, embeddings=embeddings.embeddings)
-        db.add(embeddings)
-        db.commit()
-        db.refresh(embeddings)
-        return embeddings
-        
-def get_user_by_id(user_id, db:Session):
-    return db.query(User).filter(User.id == user_id).first()
-
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    db_embeddings = UserEmbeddings(user_id=user_id, embeddings=embeddings.embeddings)
+    db.add(db_embeddings)
+    db.commit()
+    db.refresh(db_embeddings)
+    return db_embeddings
 
-def get_user_by_email(email, db:Session):
-    return db.query(User).filter(User.email == email).first()
+def get_user_by_id(user_id: int, db: Session):
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
 
+def get_user_by_email(email: str, db: Session):
+    user = db.query(User).filter(User.email == email).first()
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
 
-def get_users(db:Session, skip=0, limit=100):
+def get_users(db: Session, skip: int = 0, limit: int = 100):
     return db.query(User).offset(skip).limit(limit).all()
 
+def update_user(db: Session, user_id: int, user: UserUpdate):
+    db_user = db.query(User).filter(User.id == user_id).first()
+    if not db_user:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    update_data = user.dict(exclude_unset=True)
+    if 'password' in update_data:
+        update_data['hashed_password'] = get_password_hash(update_data['password'])
+        del update_data['password']
+    
+    for key, value in update_data.items():
+        setattr(db_user, key, value)
+    
+    db.commit()
+    db.refresh(db_user)
+    return db_user
 
-def update_user(db:Session, user_id:int, user:UserUpdate):
+def delete_user(user_id: int, db: Session):
     user = db.query(User).filter(User.id == user_id).first()
-    if user:
-        update_data = user.dict(exclude_unset=True)
-        if 'password' in update_data:
-            update_data['password'] = get_password_hash(update_data['password'])
-            del update_data['password']
-        
-        for key, value in update_data.items():
-            setattr(user, key, value)
-        db.commit()
-        db.refresh(user)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    db.delete(user)
+    db.commit()
     return user
 
-
-def delete_user(user_id, db:Session):
-    user = db.query(User).filter(User.id == user_id).first()
-    if user:
-        db.delete(user)
-        db.commit()
-        return user
-    return None
-
-
-async def update_user_embeddings(user_id:int, embeddings:UserEmbeddings, db:Session):
-    embeddings = db.query(UserEmbeddings).filter(UserEmbeddings.user_id == user_id).first()
-    if embeddings:
-        embeddings.embeddings = embeddings.embeddings
-        db.commit()
-        db.refresh(embeddings)
-        return embeddings
-    return None
-
-
+async def update_user_embeddings(user_id: int, embeddings: UserEmbeddingsBase, db: Session):
+    db_embeddings = db.query(UserEmbeddings).filter(UserEmbeddings.user_id == user_id).first()
+    if not db_embeddings:
+        raise HTTPException(status_code=404, detail="User embeddings not found")
+    
+    db_embeddings.embeddings = embeddings.embeddings
+    db.commit()
+    db.refresh(db_embeddings)
+    return db_embeddings