arpakitlib 1.8.36__py3-none-any.whl → 1.8.37__py3-none-any.whl

arpakitlib/_arpakit_project_template_v_5/command/emojize.py

@@ -0,0 +1,9 @@
+from emoji import emojize
+
+
+def __command():
+    print(emojize(input("text: ").strip()))
+
+
+if __name__ == '__main__':
+    __command()

arpakitlib/_arpakit_project_template_v_5/project/api/create_api_app.py

@@ -1,6 +1,7 @@
 import logging
 import os
 
+import starlette.types
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
@@ -53,14 +54,23 @@ def create_api_app(*, prefix: str = "/api") -> FastAPI:
         router=main_api_router
     )
 
+    class _CustomStaticFiles(StaticFiles):
+        async def get_response(self, path: str, scope: starlette.types.Scope):
+            if os.path.isfile(os.path.join(self.directory, path)):
+                headers = {"Content-Disposition": f"attachment; filename={os.path.basename(path)}"}
+                response = await super().get_response(path, scope)
+                response.headers.update(headers)
+                return response
+            return await super().get_response(path, scope)
+
     if get_cached_settings().media_dirpath is not None:
         if not os.path.exists(get_cached_settings().media_dirpath):
             os.makedirs(get_cached_settings().media_dirpath, exist_ok=True)
-        api_app.mount("/media", StaticFiles(directory=get_cached_settings().media_dirpath), name="media")
+        api_app.mount("/media", _CustomStaticFiles(directory=get_cached_settings().media_dirpath), name="media")
 
     if not os.path.exists(ProjectPaths.static_dirpath):
         os.makedirs(ProjectPaths.static_dirpath, exist_ok=True)
-    api_app.mount("/static", StaticFiles(directory=ProjectPaths.static_dirpath), name="static")
+    api_app.mount("/static", _CustomStaticFiles(directory=ProjectPaths.static_dirpath), name="static")
 
     if get_cached_settings().api_enable_sqladmin:
         from project.sqladmin_.add_admin_in_app import add_sqladmin_in_app

arpakitlib/_arpakit_project_template_v_5/project/api/exception_handler.py

@@ -214,7 +214,7 @@ def create_story_log_func_before_in_api_exception_handler(
                 level=StoryLogDBM.Levels.error,
                 type=StoryLogDBM.Types.error_in_api,
                 title=f"{status_code}, {type(exception)}",
-                data={
+                extra_data={
                     "exception": str(exception),
                     "error_common_so": error_common_so.model_dump(),
                     "exception_traceback": exception_to_traceback_str(exception=exception)

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/create_operation.py

@@ -0,0 +1,78 @@
+from typing import Any
+
+import fastapi
+from fastapi import APIRouter
+
+from arpakitlib.ar_type_util import NotSet, is_set
+from project.api.authorize import require_api_key_dbm_api_authorize_middleware, \
+    require_user_token_dbm_api_authorize_middleware, APIAuthorizeData, api_authorize
+from project.api.schema.common import BaseRouteSO, BaseSI
+from project.api.schema.out.admin.operation import OperationAdmin1SO
+from project.api.schema.out.common.error import ErrorCommonSO
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM, OperationDBM
+
+
+class CreateOperationAdminSI(BaseSI):
+    slug: str | None = NotSet
+    type: str
+    title: str | None = NotSet
+    input_data: dict[str, Any] = NotSet
+
+
+class CreateOperationRouteSO(BaseRouteSO, OperationAdmin1SO):
+    pass
+
+
+api_router = APIRouter()
+
+
+@api_router.post(
+    "",
+    name="Create operation",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=CreateOperationRouteSO | None | ErrorCommonSO,
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+        api_auth_data: APIAuthorizeData = fastapi.Depends(api_authorize(middlewares=[
+            require_api_key_dbm_api_authorize_middleware(
+                require_active=True
+            ),
+            require_user_token_dbm_api_authorize_middleware(
+                require_active_user_token=True,
+                require_user_roles=[UserDBM.Roles.admin]
+            )
+        ])),
+        create_operation_admin_si: CreateOperationAdminSI = fastapi.Body()
+):
+    operation_dbm = OperationDBM(
+        status=OperationDBM.Statuses.waiting_for_execution
+    )
+
+    if is_set(create_operation_admin_si.slug):
+        operation_dbm.slug = create_operation_admin_si.slug
+    else:
+        operation_dbm.slug = None
+
+    if is_set(create_operation_admin_si.type):
+        operation_dbm.type = create_operation_admin_si.type
+
+    if is_set(create_operation_admin_si.title):
+        operation_dbm.title = create_operation_admin_si.title
+    else:
+        operation_dbm.title = None
+
+    if is_set(create_operation_admin_si.input_data):
+        operation_dbm.input_data = create_operation_admin_si.input_data
+    else:
+        operation_dbm.input_data = {}
+
+    async with get_cached_sqlalchemy_db().new_async_session() as async_session:
+        async_session.add(operation_dbm)
+        await async_session.commit()
+        await async_session.refresh(operation_dbm)
+
+    return CreateOperationRouteSO.from_dbm(simple_dbm=operation_dbm)

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/get_arpakitlib_project_template_info.py

@@ -3,11 +3,17 @@ from fastapi import APIRouter
 
 from project.api.authorize import require_user_token_dbm_api_authorize_middleware, APIAuthorizeData, \
     api_authorize, require_api_key_dbm_api_authorize_middleware
+from project.api.schema.common import BaseRouteSO
 from project.api.schema.out.common.error import ErrorCommonSO
 from project.api.schema.out.common.raw_data import RawDataCommonSO
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 from project.util.arpakitlib_project_template import get_arpakitlib_project_template_info
 
+
+class GetArpakitlibProjectTemplateInfoRouteSO(BaseRouteSO, RawDataCommonSO):
+    pass
+
+
 api_router = APIRouter()
 
 
@@ -15,7 +21,7 @@ api_router = APIRouter()
     "",
     name="Get arpakitlib project template info",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=RawDataCommonSO | ErrorCommonSO
+    response_model=GetArpakitlibProjectTemplateInfoRouteSO | ErrorCommonSO
 )
 async def _(
         *,
@@ -31,4 +37,4 @@ async def _(
         ]))
 ):
     arpakitlib_project_template_data = get_arpakitlib_project_template_info()
-    return RawDataCommonSO(data=arpakitlib_project_template_data)
+    return GetArpakitlibProjectTemplateInfoRouteSO(data=arpakitlib_project_template_data)

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/get_auth_data.py

@@ -4,10 +4,16 @@ from fastapi import APIRouter
 from arpakitlib.ar_json_util import transfer_data_to_json_str_to_data
 from project.api.authorize import APIAuthorizeData, api_authorize, require_user_token_dbm_api_authorize_middleware, \
     require_api_key_dbm_api_authorize_middleware
+from project.api.schema.common import BaseRouteSO
 from project.api.schema.out.common.error import ErrorCommonSO
 from project.api.schema.out.common.raw_data import RawDataCommonSO
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 
+
+class GetAuthDataRouteSO(BaseRouteSO, RawDataCommonSO):
+    pass
+
+
 api_router = APIRouter()
 
 
@@ -15,7 +21,7 @@ api_router = APIRouter()
     path="",
     name="Get auth data",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=RawDataCommonSO | ErrorCommonSO,
+    response_model=GetAuthDataRouteSO | ErrorCommonSO,
 )
 async def _(
         *,
@@ -31,4 +37,4 @@ async def _(
             )
         ]))
 ):
-    return RawDataCommonSO(data=transfer_data_to_json_str_to_data(api_auth_data.model_dump()))
+    return GetAuthDataRouteSO(data=transfer_data_to_json_str_to_data(api_auth_data.model_dump()))

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/get_operation.py

@@ -0,0 +1,63 @@
+import fastapi.requests
+import sqlalchemy
+from fastapi import APIRouter
+
+from arpakitlib.ar_str_util import strip_if_not_none, make_none_if_blank
+from project.api.authorize import APIAuthorizeData, api_authorize, require_user_token_dbm_api_authorize_middleware, \
+    require_api_key_dbm_api_authorize_middleware
+from project.api.schema.common import BaseRouteSO
+from project.api.schema.out.admin.operation import OperationAdmin1SO
+from project.api.schema.out.common.error import ErrorCommonSO
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM, OperationDBM
+
+
+class GetOperationRouteSO(BaseRouteSO, OperationAdmin1SO):
+    pass
+
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    name="Get story log",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=GetOperationRouteSO | None | ErrorCommonSO,
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+        api_auth_data: APIAuthorizeData = fastapi.Depends(api_authorize(middlewares=[
+            require_api_key_dbm_api_authorize_middleware(
+                require_active=True
+            ),
+            require_user_token_dbm_api_authorize_middleware(
+                require_active_user_token=True,
+                require_user_roles=[UserDBM.Roles.admin]
+            )
+        ])),
+        filter_id: int | None = fastapi.Query(default=None),
+        filter_long_id: str | None = fastapi.Query(default=None),
+        filter_slug: str | None = fastapi.Query(default=None),
+):
+    filter_long_id = make_none_if_blank(strip_if_not_none(filter_long_id))
+    filter_slug = make_none_if_blank(strip_if_not_none(filter_slug))
+
+    if filter_id is None and filter_long_id is None and filter_slug is None:
+        return None
+
+    query = sqlalchemy.select(OperationDBM)
+    if filter_id is not None:
+        query = query.filter(OperationDBM.id == filter_id)
+    if filter_long_id is not None:
+        query = query.filter(OperationDBM.long_id == filter_long_id)
+    if filter_slug is not None:
+        query = query.filter(OperationDBM.slug == filter_slug)
+
+    async with get_cached_sqlalchemy_db().new_async_session() as async_session:
+        result = await async_session.scalar(query)
+        if result is None:
+            return None
+        return GetOperationRouteSO.from_dbm(simple_dbm=result)

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/get_operation_allowed_statuses.py

@@ -0,0 +1,40 @@
+import fastapi.requests
+from fastapi import APIRouter
+
+from project.api.authorize import APIAuthorizeData, api_authorize, require_api_key_dbm_api_authorize_middleware, \
+    require_user_token_dbm_api_authorize_middleware
+from project.api.schema.common import BaseRouteSO
+from project.api.schema.out.common.error import ErrorCommonSO
+from project.sqlalchemy_db_.sqlalchemy_model import OperationDBM, UserDBM
+
+
+class GetOperationAllowedStatusesRouteSO(BaseRouteSO):
+    allowed_statuses: list[str]
+
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    name="Get operation allowed statuses",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=GetOperationAllowedStatusesRouteSO | ErrorCommonSO,
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+        api_auth_data: APIAuthorizeData = fastapi.Depends(api_authorize(middlewares=[
+            require_api_key_dbm_api_authorize_middleware(
+                require_active=True
+            ),
+            require_user_token_dbm_api_authorize_middleware(
+                require_active_user_token=True,
+                require_user_roles=[UserDBM.Roles.admin]
+            )
+        ]))
+):
+    return GetOperationAllowedStatusesRouteSO(
+        allowed_statuses=OperationDBM.Statuses.values_list()
+    )

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/get_operation_allowed_types.py

@@ -0,0 +1,40 @@
+import fastapi.requests
+from fastapi import APIRouter
+
+from project.api.authorize import APIAuthorizeData, api_authorize, require_api_key_dbm_api_authorize_middleware, \
+    require_user_token_dbm_api_authorize_middleware
+from project.api.schema.common import BaseRouteSO
+from project.api.schema.out.common.error import ErrorCommonSO
+from project.sqlalchemy_db_.sqlalchemy_model import OperationDBM, UserDBM
+
+
+class GetOperationAllowedTypesRouteSO(BaseRouteSO):
+    allowed_types: list[str]
+
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    name="Get operation allowed types",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=GetOperationAllowedTypesRouteSO | ErrorCommonSO,
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+        api_auth_data: APIAuthorizeData = fastapi.Depends(api_authorize(middlewares=[
+            require_api_key_dbm_api_authorize_middleware(
+                require_active=True
+            ),
+            require_user_token_dbm_api_authorize_middleware(
+                require_active_user_token=True,
+                require_user_roles=[UserDBM.Roles.admin]
+            )
+        ]))
+):
+    return GetOperationAllowedTypesRouteSO(
+        allowed_types=OperationDBM.Types.values_list()
+    )

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/get_sqlalchemy_db_table_name_to_amount.py

@@ -0,0 +1,39 @@
+import fastapi
+from fastapi import APIRouter
+
+from project.api.authorize import require_user_token_dbm_api_authorize_middleware, APIAuthorizeData, \
+    api_authorize, require_api_key_dbm_api_authorize_middleware
+from project.api.schema.common import BaseRouteSO
+from project.api.schema.out.common.error import ErrorCommonSO
+from project.api.schema.out.common.raw_data import RawDataCommonSO
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+
+
+class GetAuthDataRouteSO(BaseRouteSO, RawDataCommonSO):
+    pass
+
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    name="Get sqlalchemy db table name to amount",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=GetAuthDataRouteSO | ErrorCommonSO
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+        api_auth_data: APIAuthorizeData = fastapi.Depends(api_authorize(middlewares=[
+            require_api_key_dbm_api_authorize_middleware(
+                require_active=True
+            ), require_user_token_dbm_api_authorize_middleware(
+                require_active_user_token=True,
+                require_user_roles=[UserDBM.Roles.admin]
+            )
+        ]))
+):
+    return GetAuthDataRouteSO(data=await get_cached_sqlalchemy_db().async_get_table_name_to_amount())

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/get_story_log.py

@@ -2,13 +2,20 @@ import fastapi.requests
 import sqlalchemy
 from fastapi import APIRouter
 
+from arpakitlib.ar_str_util import make_none_if_blank, strip_if_not_none
 from project.api.authorize import APIAuthorizeData, api_authorize, require_user_token_dbm_api_authorize_middleware, \
     require_api_key_dbm_api_authorize_middleware
-from project.api.schema.out.admin.story_log import StoryLogAdminSO
+from project.api.schema.common import BaseRouteSO
+from project.api.schema.out.admin.story_log import StoryLogAdmin1SO
 from project.api.schema.out.common.error import ErrorCommonSO
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM, StoryLogDBM
 
+
+class GetStoryLogRouteSO(BaseRouteSO, StoryLogAdmin1SO):
+    pass
+
+
 api_router = APIRouter()
 
 
@@ -16,7 +23,7 @@ api_router = APIRouter()
     "",
     name="Get story log",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=StoryLogAdminSO | None | ErrorCommonSO,
+    response_model=GetStoryLogRouteSO | None | ErrorCommonSO,
 )
 async def _(
         *,
@@ -35,7 +42,10 @@ async def _(
         filter_long_id: str | None = fastapi.Query(default=None),
         filter_slug: str | None = fastapi.Query(default=None),
 ):
-    if filter_id is None and filter_long_id is None:
+    filter_long_id = make_none_if_blank(strip_if_not_none(filter_long_id))
+    filter_slug = make_none_if_blank(strip_if_not_none(filter_slug))
+
+    if filter_id is None and filter_long_id is None and filter_slug is None:
         return None
 
     query = sqlalchemy.select(StoryLogDBM)
@@ -50,4 +60,4 @@ async def _(
         result = await async_session.scalar(query)
         if result is None:
             return None
-        return StoryLogAdminSO.from_dbm(simple_dbm=result)
+        return GetStoryLogRouteSO.from_dbm(simple_dbm=result)

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/init_sqlalchemy_db.py

@@ -3,11 +3,17 @@ from fastapi import APIRouter
 
 from project.api.authorize import APIAuthorizeData, api_authorize, require_user_token_dbm_api_authorize_middleware, \
     require_api_key_dbm_api_authorize_middleware, require_not_prod_mode_api_authorize_middleware
+from project.api.schema.common import BaseRouteSO
 from project.api.schema.out.common.error import ErrorCommonSO
 from project.api.schema.out.common.raw_data import RawDataCommonSO
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 
+
+class InitSqlalchemyDbRouteSO(BaseRouteSO, RawDataCommonSO):
+    pass
+
+
 api_router = APIRouter()
 
 
@@ -15,7 +21,7 @@ api_router = APIRouter()
     path="",
     name="Init sqlalchemy db",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=RawDataCommonSO | ErrorCommonSO,
+    response_model=InitSqlalchemyDbRouteSO | ErrorCommonSO,
 )
 async def _(
         *,
@@ -33,4 +39,4 @@ async def _(
         ]))
 ):
     get_cached_sqlalchemy_db().init()
-    return RawDataCommonSO()
+    return InitSqlalchemyDbRouteSO()

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/main_router.py

@@ -1,7 +1,8 @@
 from fastapi import APIRouter
 
 from project.api.router.admin import get_auth_data, get_arpakitlib_project_template_info, raise_fake_error, \
-    reinit_sqlalchemy_db, get_story_log, init_sqlalchemy_db
+    reinit_sqlalchemy_db, get_story_log, init_sqlalchemy_db, get_sqlalchemy_db_table_name_to_amount, \
+    get_operation_allowed_statuses, get_operation, create_operation, get_operation_allowed_types
 
 main_admin_api_router = APIRouter()
 
@@ -34,3 +35,28 @@ main_admin_api_router.include_router(
     router=init_sqlalchemy_db.api_router,
     prefix="/init_sqlalchemy_db"
 )
+
+main_admin_api_router.include_router(
+    router=get_sqlalchemy_db_table_name_to_amount.api_router,
+    prefix="/get_sqlalchemy_db_table_name_to_amount"
+)
+
+main_admin_api_router.include_router(
+    router=get_operation_allowed_statuses.api_router,
+    prefix="/get_operation_allowed_statuses"
+)
+
+main_admin_api_router.include_router(
+    router=get_operation_allowed_types.api_router,
+    prefix="/get_operation_allowed_types"
+)
+
+main_admin_api_router.include_router(
+    router=get_operation.api_router,
+    prefix="/get_operation"
+)
+
+main_admin_api_router.include_router(
+    router=create_operation.api_router,
+    prefix="/create_operation"
+)

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/raise_fake_error.py

@@ -4,7 +4,6 @@ from fastapi import APIRouter
 from project.api.authorize import APIAuthorizeData, api_authorize, require_user_token_dbm_api_authorize_middleware, \
     require_api_key_dbm_api_authorize_middleware
 from project.api.schema.out.common.error import ErrorCommonSO
-from project.api.schema.out.common.raw_data import RawDataCommonSO
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 
 api_router = APIRouter()
@@ -14,7 +13,7 @@ api_router = APIRouter()
     path="",
     name="Raise fake error",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=RawDataCommonSO | ErrorCommonSO,
+    response_model=ErrorCommonSO,
 )
 async def _(
         *,

arpakitlib/_arpakit_project_template_v_5/project/api/router/admin/reinit_sqlalchemy_db.py

@@ -4,11 +4,17 @@ from fastapi import APIRouter
 from project.api.authorize import APIAuthorizeData, api_authorize, require_user_token_dbm_api_authorize_middleware, \
     require_not_prod_mode_api_authorize_middleware, \
     require_api_key_dbm_api_authorize_middleware
+from project.api.schema.common import BaseRouteSO
 from project.api.schema.out.common.error import ErrorCommonSO
 from project.api.schema.out.common.raw_data import RawDataCommonSO
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 
+
+class ReinitSqlalchemyDbRouteSO(BaseRouteSO, RawDataCommonSO):
+    pass
+
+
 api_router = APIRouter()
 
 
@@ -16,7 +22,7 @@ api_router = APIRouter()
     path="",
     name="Reinit sqlalchemy db",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=RawDataCommonSO | ErrorCommonSO,
+    response_model=ReinitSqlalchemyDbRouteSO | ErrorCommonSO,
 )
 async def _(
         *,
@@ -34,4 +40,4 @@ async def _(
         ]))
 ):
     get_cached_sqlalchemy_db().reinit()
-    return RawDataCommonSO()
+    return ReinitSqlalchemyDbRouteSO()

arpakitlib/_arpakit_project_template_v_5/project/api/router/client/get_current_user.py

@@ -1,12 +1,20 @@
+from __future__ import annotations
+
 import fastapi.requests
 from fastapi import APIRouter
 
 from project.api.authorize import APIAuthorizeData, api_authorize, require_user_token_dbm_api_authorize_middleware, \
     require_api_key_dbm_api_authorize_middleware
-from project.api.schema.out.client.user import UserClientSO
+from project.api.schema.common import BaseRouteSO
+from project.api.schema.out.client.user import UserClient1SO
 from project.api.schema.out.common.error import ErrorCommonSO
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 
+
+class GetCurrentUserRouteSO(BaseRouteSO, UserClient1SO):
+    pass
+
+
 api_router = APIRouter()
 
 
@@ -14,7 +22,7 @@ api_router = APIRouter()
     "",
     name="Get current user",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=UserClientSO | ErrorCommonSO,
+    response_model=GetCurrentUserRouteSO | ErrorCommonSO,
 )
 async def _(
         *,
@@ -30,6 +38,6 @@ async def _(
             )
         ]))
 ):
-    return UserClientSO.from_dbm(
+    return GetCurrentUserRouteSO.from_dbm(
         simple_dbm=api_auth_data.user_token_dbm.user
     )

arpakitlib/_arpakit_project_template_v_5/project/api/router/client/get_current_user_token.py

@@ -3,10 +3,17 @@ from fastapi import APIRouter
 
 from project.api.authorize import APIAuthorizeData, api_authorize, require_user_token_dbm_api_authorize_middleware, \
     require_api_key_dbm_api_authorize_middleware
-from project.api.schema.out.client.user_token import UserTokenClientSO
+from project.api.schema.common import BaseRouteSO
+from project.api.schema.out.client.user import UserClient1SO
+from project.api.schema.out.client.user_token import UserTokenClient1SO
 from project.api.schema.out.common.error import ErrorCommonSO
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 
+
+class GetCurrentUserTokenRouteSO(BaseRouteSO, UserTokenClient1SO):
+    user: UserClient1SO
+
+
 api_router = APIRouter()
 
 
@@ -14,7 +21,7 @@ api_router = APIRouter()
     "",
     name="Get current user token",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=UserTokenClientSO | ErrorCommonSO,
+    response_model=GetCurrentUserTokenRouteSO | ErrorCommonSO,
 )
 async def _(
         *,
@@ -30,6 +37,6 @@ async def _(
             )
         ]))
 ):
-    return UserTokenClientSO.from_dbm(
+    return GetCurrentUserTokenRouteSO.from_dbm(
         simple_dbm=api_auth_data.user_token_dbm
     )

arpakitlib/_arpakit_project_template_v_5/project/api/router/client/main_router.py

@@ -1,14 +1,9 @@
 from fastapi import APIRouter
 
-from project.api.router.client import get_errors_info, get_current_user, get_current_user_token, get_current_api_key
+from project.api.router.client import get_current_user, get_current_user_token
 
 main_client_api_router = APIRouter()
 
-main_client_api_router.include_router(
-    router=get_errors_info.api_router,
-    prefix="/get_errors_info"
-)
-
 main_client_api_router.include_router(
     router=get_current_user.api_router,
     prefix="/get_current_user"
@@ -18,8 +13,3 @@ main_client_api_router.include_router(
     router=get_current_user_token.api_router,
     prefix="/get_current_user_token"
 )
-
-main_client_api_router.include_router(
-    router=get_current_api_key.api_router,
-    prefix="/get_current_api_key"
-)