refactor: refactor api project with ruff

api/api/db/logic/account.py

@@ -18,17 +18,19 @@ async def get_user_accaunt_page(connection: AsyncConnection, page, limit) -> Opt
     Получает список ползовелей заданных значениями  page, limit.
     """
 
-    first_user = page*limit-(limit)
+    first_user = page * limit - (limit)
 
     query = (
-        select(account_table.c.id,
+        select(
-               account_table.c.name,
+            account_table.c.id,
-               account_table.c.login,
+            account_table.c.name,
-               account_table.c.email,
+            account_table.c.login,
-               account_table.c.bind_tenant_id,
+            account_table.c.email,
-               account_table.c.role,
+            account_table.c.bind_tenant_id,
-               account_table.c.created_at,
+            account_table.c.role,
-               account_table.c.status)
+            account_table.c.created_at,
+            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

@@ -7,17 +7,18 @@ from api.db.sql_types import UnsignedInt
 from api.db import metadata
 
 
-class AccountRole(str,Enum):
+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'
+class AccountStatus(str, Enum):
-    DISABLED = 'DISABLED'
+    ACTIVE = "ACTIVE"
-    BLOCKED = 'BLOCKED'
+    DISABLED = "DISABLED"
-    DELETED = 'DELETED'
+    BLOCKED = "BLOCKED"
+    DELETED = "DELETED"
 
 
 account_table = Table(
@@ -38,13 +39,14 @@ account_table = Table(
 )
 
 
-class KeyType(str,Enum):
+class KeyType(str, Enum):
     PASSWORD = "PASSWORD"
     ACCESS_TOKEN = "ACCESS_TOKEN"
     REFRESH_TOKEN = "REFRESH_TOKEN"
     API_KEY = "API_KEY"
 
-class KeyStatus(str,Enum):
+
+class KeyStatus(str, Enum):
     ACTIVE = "ACTIVE"
     EXPIRED = "EXPIRED"
     DELETED = "DELETED"

api/api/endpoints/account.py

@@ -10,47 +10,51 @@ 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
 from api.schemas.base import bearer_schema
-from api.schemas.endpoints.account import UserUpdate,AllUserResponse
+from api.schemas.endpoints.account import UserUpdate, AllUserResponse
 from api.services.auth import get_current_user
 
 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)
+
+@api_router.get("", dependencies=[Depends(bearer_schema)], response_model=AllUserResponse)
 async def get_all_account(
-                    page: int = 1,
+    page: int = 1,
-                    limit: int = 10,
+    limit: int = 10,
-                    connection: AsyncConnection = Depends(get_connection_dep),
+    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)
+    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)
+@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,22 +65,16 @@ async def get_account(user_id: int, connection: AsyncConnection = Depends(get_co
     return user
 
 
-
+@api_router.post("", dependencies=[Depends(bearer_schema)], response_model=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)
-        await create_user(connection,user,authorize_user.id)
         user_new = await get_user_by_login(connection, user.login)
         return user_new
 
@@ -86,11 +84,13 @@ async def create_account(
         )
 
 
-@api_router.put("/{user_id}",dependencies=[Depends(bearer_schema)], response_model=User)
+@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)
+
+@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,8 +86,7 @@ async def login_for_access_token(
     return Access(access_token=access_token)
 
 
-
+@api_router.post("/refresh", response_model=Access)
-@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

@@ -13,8 +13,7 @@ from sqlalchemy.ext.asyncio import AsyncConnection
 
 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.logic.keyring import get_key_by_id, create_key, update_key_by_id
-
 
 
 from api.db.tables.account import KeyStatus
@@ -34,14 +33,10 @@ api_router = APIRouter(
 )
 
 
-@api_router.get("/{user_id}/{key_id}",dependencies=[Depends(bearer_schema)], response_model=AccountKeyring)
+@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:
@@ -75,15 +73,14 @@ async def create_keyring(
         )
 
 
-@api_router.put("/{user_id}/{key_id}", dependencies=[Depends(bearer_schema)],response_model=AccountKeyring)
+@api_router.put("/{user_id}/{key_id}", dependencies=[Depends(bearer_schema)], response_model=AccountKeyring)
 async def update_keyring(
     user_id: int,
     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)
-):
 
+@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),
+):
     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

@@ -13,7 +13,7 @@ from fastapi import (
 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,get_user_by_login
+from api.db.logic.account import get_user_by_id, update_user_by_id, get_user_by_login
 from api.schemas.base import bearer_schema
 from api.services.auth import get_current_user
 from api.services.update_data_validation import update_user_data_changes
@@ -28,12 +28,10 @@ api_router = APIRouter(
 )
 
 
-@api_router.get("",dependencies=[Depends(bearer_schema)],response_model=User)
+@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:
@@ -42,13 +40,12 @@ async def get_profile(
     return user
 
 
-@api_router.put("", dependencies=[Depends(bearer_schema)],response_model=User)
+@api_router.put("", dependencies=[Depends(bearer_schema)], response_model=User)
 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

@@ -2,10 +2,11 @@ import datetime
 from datetime import datetime
 from typing import Optional
 from pydantic import EmailStr, Field
-from api.db.tables.account import AccountRole,AccountStatus
+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

@@ -2,10 +2,11 @@ import datetime
 from typing import Optional
 from pydantic import Field
 from datetime import datetime
-from api.db.tables.account import KeyType,KeyStatus
+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/base.py

@@ -3,7 +3,7 @@ from pydantic import BaseModel, ConfigDict
 from pydantic.alias_generators import to_camel
 
 
-bearer_schema = HTTPBearer() # схема для авторизации в swagger
+bearer_schema = HTTPBearer()  # схема для авторизации в swagger
 
 
 class Base(BaseModel):

api/api/schemas/endpoints/account.py

@@ -2,7 +2,7 @@ from typing import Optional, List
 from datetime import datetime
 from pydantic import EmailStr, Field, TypeAdapter
 
-from api.db.tables.account import AccountRole,AccountStatus
+from api.db.tables.account import AccountRole, AccountStatus
 
 from api.schemas.base import Base
 
@@ -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

@@ -2,10 +2,11 @@ import datetime
 from typing import Optional
 from pydantic import Field
 from datetime import datetime
-from api.db.tables.account import KeyType,KeyStatus
+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/update_data_validation.py

@@ -1,9 +1,9 @@
 from enum import Enum
 from typing import Optional
 from api.schemas.endpoints.account import UserUpdate
-from api.db.tables.account import KeyType,KeyStatus
+from api.db.tables.account import KeyType, KeyStatus
 from api.schemas.endpoints.account_keyring import AccountKeyringUpdate
-from api.db.tables.account import AccountRole,AccountStatus
+from api.db.tables.account import AccountRole, AccountStatus
 
 
 def update_user_data_changes(update_data: UserUpdate, user) -> Optional[dict]:

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