Update app.py

app.py

@@ -35,7 +35,7 @@ SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 Base = declarative_base()
 
 # --- Database Models ---
-class User(Base):
+class UserModel(Base):
     __tablename__ = "users"
     id = Column(Integer, primary_key=True, index=True)
     username = Column(String, unique=True, index=True)
@@ -44,7 +44,7 @@ class User(Base):
     is_active = Column(Boolean, default=True)
     is_admin = Column(Boolean, default=False)
 
-class Feedback(Base):
+class FeedbackModel(Base):
     __tablename__ = "feedback"
     id = Column(Integer, primary_key=True, index=True)
     username = Column(String)
@@ -62,7 +62,7 @@ class UserBase(BaseModel):
 class UserCreate(UserBase):
     pass
 
-class User(UserBase):
+class UserResponse(UserBase):
     id: int
     is_active: bool
     is_admin: bool
@@ -82,7 +82,7 @@ class FeedbackBase(BaseModel):
 class FeedbackCreate(FeedbackBase):
     pass
 
-class Feedback(FeedbackBase):
+class FeedbackResponse(FeedbackBase):
     id: int
     created_at: datetime.datetime
     class Config:
@@ -124,12 +124,12 @@ async def get_current_user(db: Session = Depends(get_db), token: str = Depends(o
         )
     return user
 
-async def get_current_active_user(current_user: User = Depends(get_current_user)):
+async def get_current_active_user(current_user: UserResponse = Depends(get_current_user)):
     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: User = Depends(get_current_active_user)):
+async def get_current_admin_user(current_user: UserResponse = Depends(get_current_active_user)):
     if not current_user.is_admin:
         raise HTTPException(status_code=403, detail="Not an administrator")
     return current_user
@@ -137,20 +137,20 @@ async def get_current_admin_user(current_user: User = Depends(get_current_active
 
 # --- CRUD Operations ---
 def get_user(db: Session, user_id: int):
-    return db.query(User).filter(User.id == user_id).first()
+    return db.query(UserModel).filter(UserModel.id == user_id).first()
 
 def get_user_by_username(db: Session, username: str):
-    return db.query(User).filter(User.username == username).first()
+    return db.query(UserModel).filter(UserModel.username == username).first()
 
 def get_user_by_email(db: Session, email: str):
-    return db.query(User).filter(User.email == email).first()
+    return db.query(UserModel).filter(UserModel.email == email).first()
 
 def get_users(db: Session, skip: int = 0, limit: int = 100):
-    return db.query(User).offset(skip).limit(limit).all()
+    return db.query(UserModel).offset(skip).limit(limit).all()
 
 def create_user(db: Session, user: UserCreate):
     hashed_password = pwd_context.hash(user.password)
-    db_user = User(username=user.username, email=user.email, hashed_password=hashed_password)
+    db_user = UserModel(username=user.username, email=user.email, hashed_password=hashed_password)
     db.add(db_user)
     db.commit()
     db.refresh(db_user)
@@ -177,14 +177,14 @@ def verify_password(plain_password, hashed_password):
     return pwd_context.verify(plain_password, hashed_password)
 
 def create_feedback(db: Session, feedback: FeedbackCreate):
-    db_feedback = Feedback(**feedback.dict())
+    db_feedback = FeedbackModel(**feedback.dict())
     db.add(db_feedback)
     db.commit()
     db.refresh(db_feedback)
     return db_feedback
 
 def get_feedback(db: Session, skip: int = 0, limit: int = 100):
-    return db.query(Feedback).order_by(Feedback.created_at.desc()).offset(skip).limit(limit).all()
+    return db.query(FeedbackModel).order_by(FeedbackModel.created_at.desc()).offset(skip).limit(limit).all()
 
 
 
@@ -340,7 +340,7 @@ async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(
     access_token = user.username
     return {"access_token": access_token, "token_type": "bearer"}
 
-@app.post("/signup", response_model=User)
+@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:
@@ -352,7 +352,7 @@ async def signup(user: UserCreate = Depends(), db: Session = Depends(get_db)):
 
 # OCR Endpoint
 @app.post("/process/", response_model=OCRResponse)
-async def process(file: UploadFile = File(...),  current_user: User = Depends(get_current_active_user)):
+async def process(file: UploadFile = File(...),  current_user: UserResponse = Depends(get_current_active_user)):
     if not file.content_type.startswith("image/"):
         raise HTTPException(status_code=400, detail="File must be an image")
 
@@ -382,52 +382,52 @@ async def process(file: UploadFile = File(...),  current_user: User = Depends(ge
         os.unlink(temp_file.name)
 
 @app.get("/word-detection/")
-async def get_word_detection(current_user: User = Depends(get_current_active_user)):
+async def get_word_detection(current_user: UserResponse = 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: User = Depends(get_current_active_user)):
+async def get_prediction(current_user: UserResponse = 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=Feedback)
-async def create_feedback_route(feedback: FeedbackCreate,  current_user: User = Depends(get_current_active_user),db: Session = Depends(get_db)):
+@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)):
     return create_feedback(db=db, feedback=feedback)
 
 # Admin Endpoints
-@app.get("/admin/users/", response_model=List[User])
-async def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db), current_user: User = Depends(get_current_admin_user)):
+@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)):
     users = get_users(db, skip=skip, limit=limit)
     return users
 
-@app.get("/admin/users/{user_id}", response_model=User)
-async def read_user(user_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_admin_user)):
+@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)):
     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=User)
-async def update_user_route(user_id: int, user: UserUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_admin_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)):
     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: User = Depends(get_current_admin_user)):
+async def delete_user_route(user_id: int, db: Session = Depends(get_db), current_user: UserResponse = Depends(get_current_admin_user)):
     if delete_user(db=db, user_id=user_id):
         return {"message": "User deleted successfully"}
     else:
         raise HTTPException(status_code=404, detail="User not found")
 
 
-@app.get("/admin/feedback/", response_model=List[Feedback])
-async def read_feedback(skip: int = 0, limit: int = 100, db: Session = Depends(get_db), current_user: User = Depends(get_current_admin_user)):
+@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)):
     feedback = get_feedback(db, skip=skip, limit=limit)
     return feedback