feat(jobs): remove pages for results_wanted

api/auth/auth_utils.py

@@ -12,7 +12,12 @@ load_dotenv()
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/token")
 
 
-def create_access_token(data: dict):
+def create_access_token(data: dict) -> str:
+    """
+    Creates a JWT token based on the data provided.
+    :param data
+    :return: encoded_jwt
+    """
     to_encode = data.copy()
     expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
     to_encode.update({"exp": expire})
@@ -21,6 +26,12 @@ def create_access_token(data: dict):
 
 
 async def get_current_user(token: str = Depends(oauth2_scheme)):
+    """
+    Returns the current user associated with the provided JWT token.
+    :param token
+    :raises HTTPException: If the token is invalid or the user does not exist.
+    :return: The UserInDB instance associated with the token.
+    """
     credential_exception = HTTPException(
         status_code=status.HTTP_401_UNAUTHORIZED,
         detail="Could not validate credentials",
@@ -42,6 +53,13 @@ async def get_current_user(token: str = Depends(oauth2_scheme)):
 
 
 async def get_active_current_user(current_user: UserInDB = Depends(get_current_user)):
+    """
+    Returns the current user if the user account is active.
+
+    :param current_user: A UserInDB instance representing the current user.
+    :raises HTTPException: If the user account is inactive.
+    :return: The UserInDB instance if the user account is active.
+    """
     if current_user.disabled:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED, detail="Inactive user."

api/auth/db_utils.py

@@ -1,3 +1,5 @@
+from typing import Optional, Union
+
 from passlib.context import CryptContext
 from supabase_py import create_client, Client
 from fastapi import HTTPException, status
@@ -10,6 +12,13 @@ supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
 
 
 def create_user(user_create: UserInDB):
+    """
+    Creates a new user record in the 'users' table in Supabase.
+
+    :param user_create: The data of the user to be created.
+    :raises HTTPException: If an error occurs while creating the user.
+    :return: The result of the insert operation.
+    """
     result = supabase.table("users").insert(user_create.dict()).execute()
     print(f"Insert result: {result}")
 
@@ -22,7 +31,13 @@ def create_user(user_create: UserInDB):
     return result
 
 
-def get_user(username: str):
+def get_user(username: str) -> Optional[UserInDB]:
+    """
+    Retrieves a user from the 'users' table by their username.
+
+    :param username: The username of the user to retrieve.
+    :return: The user data if found, otherwise None.
+    """
     result = supabase.table("users").select().eq("username", username).execute()
 
     if "error" in result and result["error"]:
@@ -36,15 +51,35 @@ def get_user(username: str):
             return None
 
 
-def verify_password(password: str, hashed_password: str):
+def verify_password(password: str, hashed_password: str) -> bool:
+    """
+    Verifies a password against a hashed password using the bcrypt hashing algorithm.
+
+    :param password: The plaintext password to verify.
+    :param hashed_password: The hashed password to compare against.
+    :return: True if the password matches the hashed password, otherwise False.
+    """
     return pwd_context.verify(password, hashed_password)
 
 
-def get_password_hash(password):
+def get_password_hash(password: str) -> str:
+    """
+    Hashes a password using the bcrypt hashing algorithm.
+
+    :param password: The plaintext password to hash.
+    :return: The hashed password
+    """
     return pwd_context.hash(password)
 
 
-def authenticate_user(username: str, password: str):
+def authenticate_user(username: str, password: str) -> Union[UserInDB, bool]:
+    """
+    Authenticates a user based on their username and password.
+
+    :param username: The username of the user to authenticate.
+    :param password: The plaintext password to authenticate.
+    :return: The authenticated user if the username and password are correct, otherwise False.
+    """
     user = get_user(username)
     if not user:
         return False

api/auth/register/__init__.py

@@ -5,8 +5,14 @@ from api.auth.db_utils import get_user, get_password_hash, create_user
 router = APIRouter(prefix="/register", tags=["register"])
 
 
-@router.post("/")
-async def register_new_user(user: UserCreate):
+@router.post("/", response_model=dict)
+async def register_new_user(user: UserCreate) -> dict:
+    """
+    Creates new user
+    :param user:
+    :raises HTTPException: If the username already exists.
+    :return: A dictionary containing a detail key with a success message.
+    """
     existing_user = get_user(user.username)
     if existing_user is not None:
         raise HTTPException(
@@ -15,7 +21,6 @@ async def register_new_user(user: UserCreate):
         )
 
     hashed_password = get_password_hash(user.password)
-    print(f"Hashed password: {hashed_password}")
     user_create = UserInDB(
         username=user.username,
         email=user.email,

api/auth/token/__init__.py

@@ -9,7 +9,15 @@ router = APIRouter(prefix="/token", tags=["token"])
 
 
 @router.post("/", response_model=Token)
-async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
+async def login_for_access_token(
+    form_data: OAuth2PasswordRequestForm = Depends(),
+) -> Token:
+    """
+    Authenticates a user and provides an access token.
+    :param form_data: OAuth2PasswordRequestForm object containing the user's credentials.
+    :raises HTTPException: If the user cannot be authenticated.
+    :return: A Token object containing the access token and the token type.
+    """
     user = authenticate_user(form_data.username, form_data.password)
     if not user:
         raise HTTPException(
@@ -19,4 +27,4 @@ async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(
         )
 
     access_token = create_access_token(data={"sub": user.username})
-    return {"access_token": access_token, "token_type": "bearer"}
+    return Token(access_token=access_token, token_type="bearer")