Commit from GitHub Actions (Reformat code)

github-actions[bot] · github-actions[bot] · commit 6f7e3f446334 · 2024-07-20T08:02:47.000Z
diff --git a/app/__init__.py b/app/__init__.py
@@ -14,9 +14,9 @@
     root_path=settings.APP_PATH,
     version=settings.APP_VERSION,
     contact={
-        "name": "Fast Code",
-        "url": "https://fast-code.pro/",
-        "email": "fast.code.auth@gmail.com",
+        'name': 'Fast Code',
+        'url': 'https://fast-code.pro/',
+        'email': 'fast.code.auth@gmail.com',
     },
 )
 
@@ -27,5 +27,5 @@
 async def exception_handler(request, exc: exps.BaseException):
     return JSONResponse(
         status_code=exc.status_code,
-        content={"detail": exc.message},
+        content={'detail': exc.message},
     )
diff --git a/app/api/deps.py b/app/api/deps.py
@@ -19,7 +19,7 @@ async def get_logic() -> _Logic:
 
 
 async def get_user(
-    token: Annotated[str, Depends(APIKeyHeader(name="access-token"))],
+    token: Annotated[str, Depends(APIKeyHeader(name='access-token'))],
     logic: Logic,
 ) -> _User | None:
     return await logic.users.retrieve_by_token(token)
diff --git a/app/api/v1/__init__.py b/app/api/v1/__init__.py
@@ -3,13 +3,14 @@
 """
 
 from pathlib import Path
+
 from fastapi import APIRouter
 
 from . import users
 
-FOLDER_NAME = f"{Path(__file__).parent.name}"
+FOLDER_NAME = f'{Path(__file__).parent.name}'
 
-router = APIRouter(prefix=f"/{FOLDER_NAME}", tags=[FOLDER_NAME])
+router = APIRouter(prefix=f'/{FOLDER_NAME}', tags=[FOLDER_NAME])
 router.include_router(users.router)
 
-__all__ = ["router"]
+__all__ = ['router']
diff --git a/app/api/v1/users/__init__.py b/app/api/v1/users/__init__.py
@@ -6,9 +6,9 @@
 
 from . import auth, create, retrieve
 
-router = APIRouter(prefix="/users", tags=["users"])
+router = APIRouter(prefix='/users', tags=['users'])
 router.include_router(auth.router)
 router.include_router(create.router)
 router.include_router(retrieve.router)
 
-__all__ = ["router"]
+__all__ = ['router']
diff --git a/app/api/v1/users/auth/__init__.py b/app/api/v1/users/auth/__init__.py
@@ -2,7 +2,7 @@
 
 from . import token
 
-router = APIRouter(prefix="/auth", tags=["auth"])
+router = APIRouter(prefix='/auth', tags=['auth'])
 router.include_router(token.router)
 
-__all__ = ["router"]
+__all__ = ['router']
diff --git a/app/api/v1/users/auth/token.py b/app/api/v1/users/auth/token.py
@@ -4,15 +4,15 @@
 from app.models.token import AccessToken
 from app.models.user import UserCreate
 
-router = APIRouter(prefix="/token")
+router = APIRouter(prefix='/token')
 
 
-@router.post("/", response_model=AccessToken)
+@router.post('/', response_model=AccessToken)
 async def token(data: UserCreate, logic: deps.Logic):
     """
     Retrieve new access token
     """
     return await logic.users.auth.generate_token(**data.model_dump())
 
 
-__all__ = ["router"]
+__all__ = ['router']
diff --git a/app/api/v1/users/create.py b/app/api/v1/users/create.py
@@ -3,15 +3,15 @@
 from app.api import deps
 from app.models.user import UserCreate, UserRead
 
-router = APIRouter(prefix="/create")
+router = APIRouter(prefix='/create')
 
 
-@router.post("/", response_model=UserRead)
+@router.post('/', response_model=UserRead)
 async def create(data: UserCreate, logic: deps.Logic):
     """
     Create user
     """
     return await logic.users.create(**data.model_dump())
 
 
-__all__ = ["router"]
+__all__ = ['router']
diff --git a/app/api/v1/users/retrieve.py b/app/api/v1/users/retrieve.py
@@ -10,12 +10,12 @@
 router = APIRouter()
 
 
-@router.get("/", response_model=UserRead)
+@router.get('/', response_model=UserRead)
 async def retrieve(user: deps.User):
     """
     Retrieve user
     """
     return user
 
 
-__all__ = ["router"]
+__all__ = ['router']
diff --git a/app/core/db.py b/app/core/db.py
@@ -1,5 +1,7 @@
-from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
+from sqlalchemy.ext.asyncio import (AsyncEngine, async_sessionmaker,
+                                    create_async_engine)
 from sqlmodel.ext.asyncio.session import AsyncSession
+
 from app import repositories as repos
 from app.core.settings import settings
 
@@ -13,9 +15,11 @@ def __new__(cls, *args, **kwargs):
         return cls._instance
 
     def __init__(
-        self, engine: AsyncEngine | None = None, session: AsyncSession | None = None
+        self,
+        engine: AsyncEngine | None = None,
+        session: AsyncSession | None = None,
     ) -> None:
-        if not hasattr(self, "initialized"):
+        if not hasattr(self, 'initialized'):
             self.engine = engine
             self.session = session
             self.initialized = True
diff --git a/app/core/exps.py b/app/core/exps.py
@@ -13,25 +13,25 @@ def __init__(self, message: str, status_code: int = 500):
 # Users
 class UserExistsException(BaseException):
     def __init__(self):
-        super().__init__("User is already taken.", status_code=409)
+        super().__init__('User is already taken.', status_code=409)
 
 
 class UserNotFoundException(BaseException):
     def __init__(self):
-        super().__init__("User not found.", status_code=404)
+        super().__init__('User not found.', status_code=404)
 
 
 class UserIsCorrectException(BaseException):
     def __init__(self):
-        super().__init__("User is correct.", status_code=401)
+        super().__init__('User is correct.', status_code=401)
 
 
 # Tokens
 class TokenInvalidException(BaseException):
     def __init__(self):
-        super().__init__("Invalid token.", status_code=401)
+        super().__init__('Invalid token.', status_code=401)
 
 
 class TokenExpiredException(BaseException):
     def __init__(self):
-        super().__init__("Token expired.", status_code=401)
+        super().__init__('Token expired.', status_code=401)
diff --git a/app/logic/__init__.py b/app/logic/__init__.py
@@ -1,7 +1,7 @@
 from app.core.db import Database
 
-from .users import Users
 from .security import Security
+from .users import Users
 
 
 class Logic:
@@ -11,9 +11,9 @@ def __init__(self, db: Database):
         self.users = Users(self)
 
     @classmethod
-    async def create(cls) -> "Logic":
+    async def create(cls) -> 'Logic':
         async with Database() as db:
             return cls(db)
 
 
-__all__ = ["Logic"]
+__all__ = ['Logic']
diff --git a/app/logic/users/__init__.py b/app/logic/users/__init__.py
@@ -1,3 +1,3 @@
 from .users import Users
 
-__all__ = ["Users"]
+__all__ = ['Users']
diff --git a/app/logic/users/auth/__init__.py b/app/logic/users/auth/__init__.py
@@ -1,3 +1,3 @@
 from .auth import Auth
 
-__all__ = ["Auth"]
+__all__ = ['Auth']
diff --git a/app/logic/users/auth/auth.py b/app/logic/users/auth/auth.py
@@ -3,19 +3,22 @@
 from app.core import exps
 from app.models.token import AccessToken
 
-
 if TYPE_CHECKING:
     from app.logic import Logic
 
 
 class Auth:
-    def __init__(self, logic: "Logic"):
+    def __init__(self, logic: 'Logic'):
         self.logic = logic
 
-    async def generate_token(self, email: str, password: str) -> AccessToken | None:
+    async def generate_token(
+        self, email: str, password: str
+    ) -> AccessToken | None:
         if user := await self.logic.db.user.retrieve_by_email(email):
             if not self.logic.security.pwd.checkpwd(password, user.password):
                 raise exps.UserIsCorrectException()
-            access_token = self.logic.security.jwt.encode_token({"id": user.id}, 1440)
+            access_token = self.logic.security.jwt.encode_token(
+                {'id': user.id}, 1440
+            )
             return AccessToken(token=access_token)
         raise exps.UserNotFoundException()
diff --git a/app/logic/users/users.py b/app/logic/users/users.py
@@ -10,7 +10,7 @@
 
 
 class Users:
-    def __init__(self, logic: "Logic"):
+    def __init__(self, logic: 'Logic'):
         self.logic = logic
         self.auth = Auth(self.logic)
 
@@ -26,7 +26,9 @@ async def create(self, email: str, password: str) -> User | None:
     async def retrieve_by_token(self, token: str) -> User | None:
         if payload := self.logic.security.jwt.decode_token(token):
             if not (
-                user := await self.logic.db.user.retrieve_one(ident=payload.get("id"))
+                user := await self.logic.db.user.retrieve_one(
+                    ident=payload.get('id')
+                )
             ):
                 raise exps.UserNotFoundException()
             else:
