refactor: refactor api project with ruff

api/api/db/logic/account.py

@@ -21,14 +21,16 @@ async def get_user_accaunt_page(connection: AsyncConnection, page, limit) -> Opt
     first_user = page * limit - (limit)
 
     query = (
-        select(account_table.c.id,
+        select(
+            account_table.c.id,
             account_table.c.name,
             account_table.c.login,
             account_table.c.email,
             account_table.c.bind_tenant_id,
             account_table.c.role,
             account_table.c.created_at,
-               account_table.c.status)
+            account_table.c.status,
+        )
         .order_by(account_table.c.id)
         .offset(first_user)
         .limit(limit)
@@ -45,11 +47,7 @@ async def get_user_accaunt_page(connection: AsyncConnection, page, limit) -> Opt
 
     validated_users = all_user_adapter.validate_python(users_data)
 
-    return AllUserResponse(
+    return AllUserResponse(users=validated_users, amount_count=total_count, amount_pages=total_pages)
-        users=validated_users,
-        amount_count=total_count,
-        amount_pages=total_pages
-    )
 
 
 async def get_user_by_id(connection: AsyncConnection, id: int) -> Optional[User]:

api/api/db/logic/keyring.py

@@ -10,8 +10,6 @@ from api.db.tables.account import account_keyring_table
 from api.schemas.account.account_keyring import AccountKeyring
 
 
-
-
 async def get_key_by_id(connection: AsyncConnection, key_id: str) -> Optional[AccountKeyring]:
     """
     Получает key по key_id.

api/api/db/tables/account.py

@@ -8,16 +8,17 @@ from api.db import metadata
 
 
 class AccountRole(str, Enum):
-    OWNER = 'OWNER'
+    OWNER = "OWNER"
-    ADMIN = 'ADMIN'
+    ADMIN = "ADMIN"
-    EDITOR = 'EDITOR'
+    EDITOR = "EDITOR"
-    VIEWER = 'VIEWER'
+    VIEWER = "VIEWER"
+
 
 class AccountStatus(str, Enum):
-    ACTIVE = 'ACTIVE'
+    ACTIVE = "ACTIVE"
-    DISABLED = 'DISABLED'
+    DISABLED = "DISABLED"
-    BLOCKED = 'BLOCKED'
+    BLOCKED = "BLOCKED"
-    DELETED = 'DELETED'
+    DELETED = "DELETED"
 
 
 account_table = Table(
@@ -44,6 +45,7 @@ class KeyType(str,Enum):
     REFRESH_TOKEN = "REFRESH_TOKEN"
     API_KEY = "API_KEY"
 
+
 class KeyStatus(str, Enum):
     ACTIVE = "ACTIVE"
     EXPIRED = "EXPIRED"

api/api/endpoints/account.py

@@ -10,7 +10,13 @@ from sqlalchemy.ext.asyncio import AsyncConnection
 
 from api.db.connection.session import get_connection_dep
 
-from api.db.logic.account import get_user_by_id, update_user_by_id, create_user,get_user_by_login,get_user_accaunt_page
+from api.db.logic.account import (
+    get_user_by_id,
+    update_user_by_id,
+    create_user,
+    get_user_by_login,
+    get_user_accaunt_page,
+)
 
 from api.schemas.account.account import User
 from api.db.tables.account import AccountStatus
@@ -22,35 +28,33 @@ from api.services.user_role_validation import db_user_role_validation
 from api.services.update_data_validation import update_user_data_changes
 
 
-
 api_router = APIRouter(
     prefix="/account",
     tags=["User accountModel"],
 )
 
+
 @api_router.get("", dependencies=[Depends(bearer_schema)], response_model=AllUserResponse)
 async def get_all_account(
     page: int = 1,
     limit: int = 10,
     connection: AsyncConnection = Depends(get_connection_dep),
-                    current_user = Depends(get_current_user)
+    current_user=Depends(get_current_user),
 ):
-
-
     authorize_user = await db_user_role_validation(connection, current_user)
 
     user_list = await get_user_accaunt_page(connection, page, limit)
 
     if user_list is None:
-        raise HTTPException(
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Accounts not found")
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Accounts not found")
 
     return user_list
 
 
 @api_router.get("/{user_id}", dependencies=[Depends(bearer_schema)], response_model=User)
-async def get_account(user_id: int, connection: AsyncConnection = Depends(get_connection_dep), current_user = Depends(get_current_user)):
+async def get_account(
+    user_id: int, connection: AsyncConnection = Depends(get_connection_dep), current_user=Depends(get_current_user)
+):
     authorize_user = await db_user_role_validation(connection, current_user)
 
     user = await get_user_by_id(connection, user_id)
@@ -61,21 +65,15 @@ async def get_account(user_id: int, connection: AsyncConnection = Depends(get_co
     return user
 
 
-
 @api_router.post("", dependencies=[Depends(bearer_schema)], response_model=User)
 async def create_account(
-                        user: UserUpdate,
+    user: UserUpdate, connection: AsyncConnection = Depends(get_connection_dep), current_user=Depends(get_current_user)
-                        connection: AsyncConnection = Depends(get_connection_dep),
-    current_user = Depends(get_current_user)
 ):
-
-
     authorize_user = await db_user_role_validation(connection, current_user)
 
     user_validation = await get_user_by_login(connection, user.login)
 
     if user_validation is None:
-
         await create_user(connection, user, authorize_user.id)
         user_new = await get_user_by_login(connection, user.login)
         return user_new
@@ -88,9 +86,11 @@ async def create_account(
 
 @api_router.put("/{user_id}", dependencies=[Depends(bearer_schema)], response_model=User)
 async def update_account(
-    user_id: int, user_update: UserUpdate, connection: AsyncConnection = Depends(get_connection_dep), current_user = Depends(get_current_user)
+    user_id: int,
+    user_update: UserUpdate,
+    connection: AsyncConnection = Depends(get_connection_dep),
+    current_user=Depends(get_current_user),
 ):
-
     authorize_user = await db_user_role_validation(connection, current_user)
 
     user = await get_user_by_id(connection, user_id)
@@ -106,20 +106,15 @@ async def update_account(
 
     await update_user_by_id(connection, update_values, user)
 
-
     user = await get_user_by_id(connection, user_id)
 
     return user
 
+
 @api_router.delete("/{user_id}", dependencies=[Depends(bearer_schema)], response_model=User)
 async def delete_account(
-                        user_id: int,
+    user_id: int, connection: AsyncConnection = Depends(get_connection_dep), current_user=Depends(get_current_user)
-                        connection: AsyncConnection = Depends(get_connection_dep),
-    current_user = Depends(get_current_user)
 ):
-
-
-
     authorize_user = await db_user_role_validation(connection, current_user)
 
     user = await get_user_by_id(connection, user_id)
@@ -133,10 +128,8 @@ async def delete_account(
     if update_values is None:
         return user
 
-
     await update_user_by_id(connection, update_values, user)
 
-
     user = await get_user_by_id(connection, user_id)
 
     return user

api/api/endpoints/auth.py

@@ -86,7 +86,6 @@ async def login_for_access_token(
     return Access(access_token=access_token)
 
 
-
 @api_router.post("/refresh", response_model=Access)
 async def refresh(
     request: Request, connection: AsyncConnection = Depends(get_connection_dep), Authorize: AuthJWT = Depends()

api/api/endpoints/keyring.py

@@ -16,7 +16,6 @@ from api.db.connection.session import get_connection_dep
 from api.db.logic.keyring import get_key_by_id, create_key, update_key_by_id
 
 
-
 from api.db.tables.account import KeyStatus
 from api.schemas.base import bearer_schema
 from api.schemas.endpoints.account_keyring import AccountKeyringUpdate
@@ -36,12 +35,8 @@ api_router = APIRouter(
 
 @api_router.get("/{user_id}/{key_id}", dependencies=[Depends(bearer_schema)], response_model=AccountKeyring)
 async def get_keyring(
-                    key_id: str,
+    key_id: str, connection: AsyncConnection = Depends(get_connection_dep), current_user=Depends(get_current_user)
-                    connection: AsyncConnection = Depends(get_connection_dep),
-    current_user = Depends(get_current_user)
 ):
-
-
     authorize_user = await db_user_role_validation(connection, current_user)
 
     keyring = await get_key_by_id(connection, key_id)
@@ -58,15 +53,18 @@ async def create_keyring(
     key_id: str,
     key: AccountKeyringUpdate,
     connection: AsyncConnection = Depends(get_connection_dep),
-    current_user = Depends(get_current_user)
+    current_user=Depends(get_current_user),
 ):
-
     authorize_user = await db_user_role_validation(connection, current_user)
 
     keyring = await get_key_by_id(connection, key_id)
 
     if keyring is None:
-        keyring_new = await create_key(connection,key, key_id, )
+        keyring_new = await create_key(
+            connection,
+            key,
+            key_id,
+        )
         return keyring_new
 
     else:
@@ -81,9 +79,8 @@ async def update_keyring(
     key_id: str,
     keyring_update: AccountKeyringUpdate,
     connection: AsyncConnection = Depends(get_connection_dep),
-    current_user = Depends(get_current_user)
+    current_user=Depends(get_current_user),
 ):
-
     authorize_user = await db_user_role_validation(connection, current_user)
 
     keyring = await get_key_by_id(connection, key_id)
@@ -99,16 +96,18 @@ async def update_keyring(
 
     await update_key_by_id(connection, update_values, keyring)
 
-
     keyring = await get_key_by_id(connection, key_id)
 
     return keyring
 
+
 @api_router.delete("/{user_id}/{key_id}", dependencies=[Depends(bearer_schema)], response_model=AccountKeyring)
 async def delete_keyring(
-    user_id: int, key_id: str,  connection: AsyncConnection = Depends(get_connection_dep), current_user = Depends(get_current_user)
+    user_id: int,
+    key_id: str,
+    connection: AsyncConnection = Depends(get_connection_dep),
+    current_user=Depends(get_current_user),
 ):
-
     authorize_user = await db_user_role_validation(connection, current_user)
 
     keyring = await get_key_by_id(connection, key_id)
@@ -124,7 +123,6 @@ async def delete_keyring(
 
     await update_key_by_id(connection, update_values, keyring)
 
-
     keyring = await get_key_by_id(connection, key_id)
 
     return keyring

api/api/endpoints/profile.py

@@ -30,10 +30,8 @@ api_router = APIRouter(
 
 @api_router.get("", dependencies=[Depends(bearer_schema)], response_model=User)
 async def get_profile(
-    connection: AsyncConnection = Depends(get_connection_dep),
+    connection: AsyncConnection = Depends(get_connection_dep), current_user=Depends(get_current_user)
-    current_user = Depends(get_current_user)
 ):
-
     user = await get_user_by_login(connection, current_user)
 
     if user is None:
@@ -46,9 +44,8 @@ async def get_profile(
 async def update_profile(
     user_updata: UserUpdate,
     connection: AsyncConnection = Depends(get_connection_dep),
-    current_user = Depends(get_current_user)
+    current_user=Depends(get_current_user),
 ):
-
     user = await get_user_by_login(connection, current_user)
     if user is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Account not found")

api/api/schemas/account/account.py

@@ -6,6 +6,7 @@ from api.db.tables.account import AccountRole,AccountStatus
 
 from api.schemas.base import Base
 
+
 class User(Base):
     id: Optional[int] = None
     name: str = Field(..., max_length=100)

api/api/schemas/account/account_keyring.py

@@ -6,6 +6,7 @@ from api.db.tables.account import KeyType,KeyStatus
 
 from api.schemas.base import Base
 
+
 class AccountKeyring(Base):
     owner_id: int
     key_type: KeyType

api/api/schemas/endpoints/account.py

@@ -19,6 +19,7 @@ class UserUpdate(Base):
     created_at: Optional[datetime] = None
     status: Optional[AccountStatus] = None
 
+
 class AllUser(Base):
     id: int
     name: str
@@ -35,4 +36,5 @@ class AllUserResponse(Base):
     amount_count: int
     amount_pages: int
 
+
 all_user_adapter = TypeAdapter(List[AllUser])

api/api/schemas/endpoints/account_keyring.py

@@ -6,6 +6,7 @@ from api.db.tables.account import KeyType,KeyStatus
 
 from api.schemas.base import Base
 
+
 class AccountKeyringUpdate(Base):
     owner_id: Optional[int] = None
     key_type: Optional[KeyType] = None

api/api/schemas/endpoints/auth.py

@@ -7,8 +7,10 @@ class Auth(Base):
     login: str
     password: str
 
+
 class Refresh(Base):
     refresh_token: str
 
+
 class Access(Base):
     access_token: str

api/api/services/user_role_validation.py

@@ -6,12 +6,8 @@ from api.db.logic.account import get_user_by_login
 from api.db.tables.account import AccountRole
 
 
-
 async def db_user_role_validation(connection, current_user):
-
     authorize_user = await get_user_by_login(connection, current_user)
     if authorize_user.role not in {AccountRole.OWNER, AccountRole.ADMIN}:
-        raise HTTPException(
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You do not have enough permissions")
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="You do not have enough permissions")
     return authorize_user