Update app.py

app.py

@@ -5,7 +5,7 @@ from fastapi.responses import FileResponse, JSONResponse, HTMLResponse
 from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
 from fastapi.templating import Jinja2Templates
 from pydantic import BaseModel, EmailStr, Field
-from typing import List, Optional # Import Optional from typing
+from typing import List, Optional  # Import Optional from typing
 import cv2
 import numpy as np
 import tensorflow as tf
@@ -92,7 +92,7 @@ class Token(BaseModel):
     token_type: str
 
 class TokenData(BaseModel):
-    username: Optional[str] = None # Use Optional[str] instead of str | None
+    username: Optional[str] = None  # Use Optional[str] instead of str | None
 
 class OCRResponse(BaseModel):
     sakshi_output: str
@@ -114,6 +114,7 @@ def get_db():
         db.close()
 
 async def get_current_user(db: Session = Depends(get_db), token: str = Depends(oauth2_scheme)):
+    # Correctly retrieve user by matching token with username.
     user = get_user_by_username(db, username=token)
     if not user:
         raise HTTPException(
@@ -123,17 +124,19 @@ async def get_current_user(db: Session = Depends(get_db), token: str = Depends(o
         )
     return user
 
-async def get_current_active_user(current_user: UserResponse = Depends(get_current_user)):
+
+async def get_current_active_user(current_user: UserModel = Depends(get_current_user)):  #Use UserModel
     if not current_user.is_active:
         raise HTTPException(status_code=400, detail="Inactive user")
     return current_user
 
-async def get_current_admin_user(current_user: UserResponse = Depends(get_current_active_user)):
+async def get_current_admin_user(current_user: UserModel = Depends(get_current_active_user)):  #Use UserModel
     if not current_user.is_admin:
         raise HTTPException(status_code=403, detail="Not an administrator")
     return current_user
 
 
+
 # --- CRUD Operations ---
 def get_user(db: Session, user_id: int):
     return db.query(UserModel).filter(UserModel.id == user_id).first()
@@ -340,18 +343,20 @@ async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(
     return {"access_token": access_token, "token_type": "bearer"}
 
 @app.post("/signup", response_model=UserResponse)
-async def signup(user: UserCreate = Depends(), db: Session = Depends(get_db)):
-    db_user = get_user_by_username(db, username=user.username)
-    if db_user:
-        raise HTTPException(status_code=400, detail="Username already registered")
-    db_user = get_user_by_email(db, email=user.email)
-    if db_user:
-        raise HTTPException(status_code=400, detail="Email already registered")
-    return create_user(db=db, user=user)
+async def signup(user: UserCreate, db: Session = Depends(get_db)):
+    db_user_username = get_user_by_username(db, username=user.username)
+    if db_user_username:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Username already registered")
+    db_user_email = get_user_by_email(db, email=user.email)
+    if db_user_email:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Email already registered")
+    created =  create_user(db=db, user=user)
+    return created
+
 
 # OCR Endpoint
 @app.post("/process/", response_model=OCRResponse)
-async def process(file: UploadFile = File(...),  current_user: UserResponse = Depends(get_current_active_user)):
+async def process(file: UploadFile = File(...),  current_user: UserModel = Depends(get_current_active_user)):
     if not file.content_type.startswith("image/"):
         raise HTTPException(status_code=400, detail="File must be an image")
 
@@ -381,44 +386,44 @@ async def process(file: UploadFile = File(...),  current_user: UserResponse = De
         os.unlink(temp_file.name)
 
 @app.get("/word-detection/")
-async def get_word_detection(current_user: UserResponse = Depends(get_current_active_user)):
+async def get_word_detection(current_user: UserModel = Depends(get_current_active_user)):
     if 'word_detection' not in session_files or not os.path.exists(session_files['word_detection']):
         raise HTTPException(status_code=404, detail="Word detection image not found")
     return FileResponse(session_files['word_detection'])
 
 @app.get("/prediction/")
-async def get_prediction(current_user: UserResponse = Depends(get_current_active_user)):
+async def get_prediction(current_user: UserModel = Depends(get_current_active_user)):
     if 'prediction' not in session_files or not os.path.exists(session_files['prediction']):
         raise HTTPException(status_code=404, detail="Prediction image not found")
     return FileResponse(session_files['prediction'])
 
 # Feedback Endpoint
 @app.post("/feedback/", response_model=FeedbackResponse)
-async def create_feedback_route(feedback: FeedbackCreate,  current_user: UserResponse = Depends(get_current_active_user),db: Session = Depends(get_db)):
+async def create_feedback_route(feedback: FeedbackCreate,  current_user: UserModel = Depends(get_current_active_user),db: Session = Depends(get_db)):
     return create_feedback(db=db, feedback=feedback)
 
 # Admin Endpoints
 @app.get("/admin/users/", response_model=List[UserResponse])
-async def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db), current_user: UserResponse = Depends(get_current_admin_user)):
+async def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db), current_user: UserModel = Depends(get_current_admin_user)):
     users = get_users(db, skip=skip, limit=limit)
     return users
 
 @app.get("/admin/users/{user_id}", response_model=UserResponse)
-async def read_user(user_id: int, db: Session = Depends(get_db), current_user: UserResponse = Depends(get_current_admin_user)):
+async def read_user(user_id: int, db: Session = Depends(get_db), current_user: UserModel = Depends(get_current_admin_user)):
     db_user = get_user(db, user_id=user_id)
     if db_user is None:
         raise HTTPException(status_code=404, detail="User not found")
     return db_user
 
 @app.put("/admin/users/{user_id}", response_model=UserResponse)
-async def update_user_route(user_id: int, user: UserUpdate, db: Session = Depends(get_db), current_user: UserResponse = Depends(get_current_admin_user)):
+async def update_user_route(user_id: int, user: UserUpdate, db: Session = Depends(get_db), current_user: UserModel = Depends(get_current_admin_user)):
     updated_user = update_user(db=db, user_id=user_id, user=user)
     if updated_user is None:
         raise HTTPException(status_code=404, detail="User not found")
     return updated_user
 
 @app.delete("/admin/users/{user_id}", response_model=dict)
-async def delete_user_route(user_id: int, db: Session = Depends(get_db), current_user: UserResponse = Depends(get_current_admin_user)):
+async def delete_user_route(user_id: int, db: Session = Depends(get_db), current_user: UserModel = Depends(get_current_admin_user)):
     if delete_user(db=db, user_id=user_id):
         return {"message": "User deleted successfully"}
     else:
@@ -426,7 +431,7 @@ async def delete_user_route(user_id: int, db: Session = Depends(get_db), current
 
 
 @app.get("/admin/feedback/", response_model=List[FeedbackResponse])
-async def read_feedback(skip: int = 0, limit: int = 100, db: Session = Depends(get_db), current_user: UserResponse = Depends(get_current_admin_user)):
+async def read_feedback(skip: int = 0, limit: int = 100, db: Session = Depends(get_db), current_user: UserModel = Depends(get_current_admin_user)):
     feedback = get_feedback(db, skip=skip, limit=limit)
     return feedback