fix: apply ruff formating

Author: VictoriaTskhondia

backend/src/auth/auth0_api.py

@@ -8,7 +8,7 @@
 from src.dependencies.auth0 import (
     get_auth0_service,
     get_current_user,
-    get_current_user_claims
+    get_current_user_claims,
 )
 from src.services.auth0 import Auth0Service
 from src.users.auth0 import get_or_create_user_from_auth0
@@ -20,8 +20,7 @@
 
 @router.get("/login")
 async def login(
-    request: Request,
-    auth_service: Annotated[Auth0Service, Depends(get_auth0_service)]
+    request: Request, auth_service: Annotated[Auth0Service, Depends(get_auth0_service)]
 ) -> RedirectResponse:
     return await auth_service.login(request)
 
@@ -30,7 +29,7 @@ async def login(
 async def callback(
     request: Request,
     session: Annotated[Session, Depends(get_db)],
-    auth_service: Annotated[Auth0Service, Depends(get_auth0_service)]
+    auth_service: Annotated[Auth0Service, Depends(get_auth0_service)],
 ) -> RedirectResponse:
     try:
         # Exchange auth code for tokens
@@ -58,28 +57,25 @@ async def callback(
 
 @router.get("/logout")
 async def logout(
-    auth_service: Annotated[Auth0Service, Depends(get_auth0_service)]
+    auth_service: Annotated[Auth0Service, Depends(get_auth0_service)],
 ) -> RedirectResponse:
     return auth_service.logout()
 
 
 @router.get("/me", response_model=UserPublic)
 async def read_users_me(
-    current_user: Annotated[User, Depends(get_current_user)]
+    current_user: Annotated[User, Depends(get_current_user)],
 ) -> User:
     return current_user
 
 
 @router.get("/validate")
 async def validate_token(
-    claims: Annotated[dict[str, Any], Depends(get_current_user_claims)]
+    claims: Annotated[dict[str, Any], Depends(get_current_user_claims)],
 ) -> dict[str, Any]:
     return claims
 
 
 @router.get("/error")
 async def auth_error(message: str = "Authentication error"):
-    raise HTTPException(
-        status_code=401,
-        detail=message
-    )
+    raise HTTPException(status_code=401, detail=message)

backend/src/dependencies/auth0.py

@@ -27,7 +27,7 @@ def get_auth0_service() -> Auth0Service:
 
 
 async def get_token_from_header(
-    credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)]
+    credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)],
 ) -> str:
     """
     Extract and return the JWT token from Authorization header.
@@ -37,7 +37,7 @@ async def get_token_from_header(
 
 async def get_current_user_claims(
     token: Annotated[str, Depends(get_token_from_header)],
-    auth_service: Annotated[Auth0Service, Depends(get_auth0_service)]
+    auth_service: Annotated[Auth0Service, Depends(get_auth0_service)],
 ) -> dict[str, Any]:
     """
     Validate token and return the user claims.
@@ -51,12 +51,12 @@ async def get_current_user_info(
     request: Request,
     token: Annotated[str, Depends(get_token_from_header)],
     claims: Annotated[dict[str, Any], Depends(get_current_user_claims)],
-    auth_service: Annotated[Auth0Service, Depends(get_auth0_service)]
+    auth_service: Annotated[Auth0Service, Depends(get_auth0_service)],
 ) -> UserInfo:
     """
     Get user information from Auth0.
     """
-    # Access token should be available in the request's session 
+    # Access token should be available in the request's session
     # after the callback flow
     access_token = request.session.get("access_token")
     if not access_token:
@@ -69,7 +69,7 @@ async def get_current_user_info(
 async def get_current_user(
     request: Request,
     session: Annotated[Session, Depends(get_db)],
-    user_info: Annotated[UserInfo, Depends(get_current_user_info)]
+    user_info: Annotated[UserInfo, Depends(get_current_user_info)],
 ) -> User:
     """
     Get the current user from the database.
@@ -104,6 +104,5 @@ async def get_current_user(
 
     except Exception as e:
         raise HTTPException(
-            status_code=401,
-            detail=f"User integration failed: {str(e)}"
+            status_code=401, detail=f"User integration failed: {str(e)}"
         )

backend/src/services/auth0.py

@@ -30,26 +30,23 @@ class Auth0Service:
     def __init__(self):
         self.oauth = OAuth()
         self.oauth.register(
-            'auth0',
+            "auth0",
             client_id=settings.AUTH0_CLIENT_ID,
             client_secret=settings.AUTH0_CLIENT_SECRET,
             server_metadata_url=(
-                f'https://{settings.AUTH0_DOMAIN}/'
-                '.well-known/openid-configuration'
+                f"https://{settings.AUTH0_DOMAIN}/.well-known/openid-configuration"
             ),
             client_kwargs={
-                'scope': 'openid profile email',
-                'audience': settings.AUTH0_AUDIENCE,
+                "scope": "openid profile email",
+                "audience": settings.AUTH0_AUDIENCE,
             },
         )
         self._jwks = None
 
     async def _get_jwks(self) -> dict[str, Any]:
         if self._jwks is None:
             try:
-                jwks_url = (
-                    f"https://{settings.AUTH0_DOMAIN}/.well-known/jwks.json"
-                )
+                jwks_url = f"https://{settings.AUTH0_DOMAIN}/.well-known/jwks.json"
                 async with httpx.AsyncClient() as client:
                     response = await client.get(jwks_url)
                     response.raise_for_status()
@@ -58,8 +55,7 @@ async def _get_jwks(self) -> dict[str, Any]:
             except Exception as e:
                 logger.error(f"Failed to fetch JWKS: {str(e)}")
                 raise HTTPException(
-                    status_code=500, 
-                    detail="Authentication configuration error"
+                    status_code=500, detail="Authentication configuration error"
                 )
         return self._jwks
 
@@ -73,8 +69,7 @@ async def login(self, request: Request) -> RedirectResponse:
         except Exception as e:
             logger.error(f"Failed to initiate login: {str(e)}")
             raise HTTPException(
-                status_code=500,
-                detail="Failed to initiate login. Please try again."
+                status_code=500, detail="Failed to initiate login. Please try again."
             )
 
     async def callback(self, request: Request) -> TokenResponse:
@@ -85,8 +80,7 @@ async def callback(self, request: Request) -> TokenResponse:
         except Exception as e:
             logger.error(f"Failed to exchange code for token: {str(e)}")
             raise HTTPException(
-                status_code=401,
-                detail="Authentication failed. Please try again."
+                status_code=401, detail="Authentication failed. Please try again."
             )
 
     async def validate_token(self, token: str) -> dict[str, Any]:
@@ -100,52 +94,36 @@ async def validate_token(self, token: str) -> dict[str, Any]:
                 jwks,
                 claims_options={
                     "iss": {"essential": True, "value": settings.AUTH0_ISSUER},
-                    "aud": {
-                        "essential": True,
-                        "value": settings.AUTH0_AUDIENCE
-                    },
+                    "aud": {"essential": True, "value": settings.AUTH0_AUDIENCE},
                     "exp": {"essential": True},
-                }
+                },
             )
             jwt.validate_claims(
                 claims,
                 {
                     "iss": {"essential": True, "value": settings.AUTH0_ISSUER},
-                    "aud": {
-                        "essential": True,
-                        "value": settings.AUTH0_AUDIENCE
-                    },
+                    "aud": {"essential": True, "value": settings.AUTH0_AUDIENCE},
                     "exp": {"essential": True},
-                }
+                },
             )
 
             # Additional validation
-            if not claims.get('sub'):
+            if not claims.get("sub"):
                 logger.warning("Token validation failed: missing subject")
                 raise HTTPException(
-                    status_code=401,
-                    detail="Invalid token: missing subject"
+                    status_code=401, detail="Invalid token: missing subject"
                 )
 
             return claims
         except jwt.ExpiredTokenError:
             logger.warning("Token has expired")
-            raise HTTPException(
-                status_code=401,
-                detail="Token has expired"
-            )
+            raise HTTPException(status_code=401, detail="Token has expired")
         except jwt.InvalidTokenError as e:
             logger.warning(f"Invalid token: {str(e)}")
-            raise HTTPException(
-                status_code=401,
-                detail="Invalid token"
-            )
+            raise HTTPException(status_code=401, detail="Invalid token")
         except Exception as e:
             logger.error(f"Token validation failed: {str(e)}")
-            raise HTTPException(
-                status_code=401,
-                detail="Invalid token"
-            )
+            raise HTTPException(status_code=401, detail="Invalid token")
 
     async def get_user_info(self, access_token: str) -> UserInfo:
         try:
@@ -156,8 +134,7 @@ async def get_user_info(self, access_token: str) -> UserInfo:
         except Exception as e:
             logger.error(f"Failed to get user info: {str(e)}")
             raise HTTPException(
-                status_code=401,
-                detail="Failed to retrieve user information"
+                status_code=401, detail="Failed to retrieve user information"
             )
 
     def logout(self) -> RedirectResponse: