arpakitlib 1.8.18__py3-none-any.whl → 1.8.20__py3-none-any.whl

arpakitlib/_arpakit_project_template_v_5/arpakitlib_project_template_info.json

@@ -0,0 +1,3 @@
+{
+  "arpakitlib_project_template_version": "5"
+}

arpakitlib/_arpakit_project_template_v_5/command/alembic_revision_autogenerate.sh

@@ -0,0 +1,2 @@
+cd ..
+alembic revision --autogenerate -m "ar"

arpakitlib/_arpakit_project_template_v_5/command/reinit_all_sqlalchemy_db.py

@@ -0,0 +1,13 @@
+from project.core.settings import get_cached_settings
+from project.core.util import setup_logging
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+
+
+def __command():
+    setup_logging()
+    get_cached_settings().raise_if_prod_mode()
+    get_cached_sqlalchemy_db().reinit_all()
+
+
+if __name__ == '__main__':
+    __command()

arpakitlib/{_arpakit_project_template_v_4/project/api/auth2.py → _arpakit_project_template_v_5/project/api/auth.py}

@@ -1,18 +1,23 @@
-from typing import Callable
+import functools
+from typing import Callable, Any
 
 import fastapi
 import fastapi.exceptions
 import fastapi.responses
 import fastapi.security
+import sqlalchemy
 from fastapi import Security
 from fastapi.security import APIKeyHeader
 from pydantic import BaseModel, ConfigDict
+from sqlalchemy.orm import joinedload
 
-from arpakitlib.ar_func_util import is_async_callable, is_sync_function
+from arpakitlib.ar_func_util import is_async_func, is_sync_func
 from arpakitlib.ar_json_util import transfer_data_to_json_str_to_data
 from project.api.const import APIErrorCodes
 from project.api.exception import APIException
 from project.core.settings import get_cached_settings
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import ApiKeyDBM, UserTokenDBM
 
 
 class APIAuthData(BaseModel):
@@ -21,15 +26,22 @@ class APIAuthData(BaseModel):
     api_key_string: str | None = None
     user_token_string: str | None = None
 
+    is_api_key_correct: bool | None = None
+
+    api_key_dbm: ApiKeyDBM | None = None
+    user_token_dbm: UserTokenDBM | None = None
+
     prod_mode: bool = False
 
+    extra_data: dict[str, Any] = {}
+
 
 def api_auth(
         *,
-        middleware_funcs: list[Callable] | None = None
+        middlewares: list[Callable] | None = None
 ) -> Callable:
-    if middleware_funcs is None:
-        middleware_funcs = []
+    if middlewares is None:
+        middlewares = []
 
     async def async_func(
             *,
@@ -46,7 +58,7 @@ def api_auth(
             prod_mode=get_cached_settings().prod_mode
         )
 
-        # parse api_key
+        # parse api_key_string
 
         api_auth_data.api_key_string = api_key_string
 
@@ -56,6 +68,8 @@ def api_auth(
             api_auth_data.api_key_string = request.headers["api-key"]
         if not api_auth_data.api_key_string and "apikey" in request.headers.keys():
             api_auth_data.api_key_string = request.headers["apikey"]
+        if not api_auth_data.api_key_string and "api_key_string" in request.headers.keys():
+            api_auth_data.api_key_string = request.headers["api_key_string"]
 
         if not api_auth_data.api_key_string and "api_key" in request.query_params.keys():
             api_auth_data.api_key_string = request.query_params["api_key"]
@@ -63,13 +77,15 @@ def api_auth(
             api_auth_data.api_key_string = request.query_params["api-key"]
         if not api_auth_data.api_key_string and "apikey" in request.query_params.keys():
             api_auth_data.api_key_string = request.query_params["apikey"]
+        if not api_auth_data.api_key_string and "api_key_string" in request.query_params.keys():
+            api_auth_data.api_key_string = request.query_params["api_key_string"]
 
         if api_auth_data.api_key_string:
             api_auth_data.api_key_string = api_auth_data.api_key_string.strip()
         if not api_auth_data.api_key_string:
             api_auth_data.api_key_string = None
 
-        # parse user_token
+        # parse user_token_string
 
         api_auth_data.user_token_string = ac.credentials if ac and ac.credentials and ac.credentials.strip() else None
 
@@ -98,74 +114,165 @@ def api_auth(
         if not api_auth_data.user_token_string:
             api_auth_data.user_token_string = None
 
-        # middleware_funcs
+        # is_api_key_correct
+
+        if api_auth_data.api_key_string is not None:
+            if get_cached_settings().api_correct_api_keys is None:
+                api_auth_data.is_api_key_correct = None
+            else:
+                api_auth_data.is_api_key_correct = api_auth_data.api_key_string in get_cached_settings().api_correct_api_keys
+
+        # api_key_dbm
+
+        if api_auth_data.api_key_string is not None:
+            if get_cached_sqlalchemy_db() is not None:
+                async with get_cached_sqlalchemy_db().new_async_session() as async_session:
+                    api_auth_data.api_key_dbm = await async_session.scalar(
+                        sqlalchemy.select(ApiKeyDBM).where(ApiKeyDBM.value == api_auth_data.api_key_string)
+                    )
+
+        # user_token_dbm
 
-        for middleware_func in middleware_funcs:
-            if is_async_callable(middleware_func):
-                await middleware_func(
+        if api_auth_data.api_key_string is not None:
+            if get_cached_sqlalchemy_db() is not None:
+                async with get_cached_sqlalchemy_db().new_async_session() as async_session:
+                    api_auth_data.user_token_dbm = await async_session.scalar(
+                        sqlalchemy.select(UserTokenDBM)
+                        .options(joinedload(UserTokenDBM.user))
+                        .where(UserTokenDBM.value == api_auth_data.user_token_string)
+                    )
+
+        # middlewares
+
+        for middleware in middlewares:
+            api_auth_data.extra_data[middleware.__name__] = True
+
+        for middleware in middlewares:
+            if is_async_func(middleware):
+                await middleware(
                     api_auth_data=api_auth_data,
                     request=request
                 )
-            elif is_sync_function(middleware_func):
-                middleware_func(
+            elif is_sync_func(middleware):
+                middleware(
                     api_auth_data=api_auth_data,
                     request=request
                 )
             else:
-                raise TypeError("unknown middleware_func type")
+                raise TypeError(f"unknown middleware type, {middleware.__name__}")
 
         return api_auth_data
 
     return async_func
 
 
-def require_api_key_string_middleware_func():
+def require_prod_mode_api_middleware():
+    @functools.wraps(require_prod_mode_api_middleware)
     def func(*, api_auth_data: APIAuthData, request: fastapi.requests.Request):
-        if api_auth_data.api_key_string is None:
+        if not get_cached_settings().prod_mode:
             raise APIException(
                 status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
                 error_code=APIErrorCodes.cannot_authorize,
-                error_description="api_key string is required",
+                error_description=f"prod_mode={get_cached_settings().prod_mode}",
                 error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
             )
 
     return func
 
 
-def require_user_token_string_middleware_func():
+def require_not_prod_mode_api_middleware():
+    @functools.wraps(require_not_prod_mode_api_middleware)
     def func(*, api_auth_data: APIAuthData, request: fastapi.requests.Request):
-        if api_auth_data.user_token_string is None:
+        if get_cached_settings().prod_mode:
             raise APIException(
                 status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
                 error_code=APIErrorCodes.cannot_authorize,
-                error_description="user_token string is required",
+                error_description=f"prod_mode={get_cached_settings().prod_mode}",
                 error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
             )
 
     return func
 
 
-def require_prod_mode_middleware_func():
+def require_api_key_string_api_middleware():
+    @functools.wraps(require_api_key_string_api_middleware)
     def func(*, api_auth_data: APIAuthData, request: fastapi.requests.Request):
-        if not get_cached_settings().prod_mode:
+        if api_auth_data.api_key_string is None:
             raise APIException(
                 status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
                 error_code=APIErrorCodes.cannot_authorize,
-                error_description=f"prod_mode={get_cached_settings().prod_mode}",
+                error_description="api_key_string is required",
                 error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
             )
 
     return func
 
 
-def require_not_prod_mode_middleware_func():
+def require_user_token_string_api_middleware():
+    @functools.wraps(require_user_token_string_api_middleware)
     def func(*, api_auth_data: APIAuthData, request: fastapi.requests.Request):
-        if get_cached_settings().prod_mode:
+        if api_auth_data.user_token_string is None:
             raise APIException(
                 status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
                 error_code=APIErrorCodes.cannot_authorize,
-                error_description=f"prod_mode={get_cached_settings().prod_mode}",
+                error_description="user_token_string is required",
                 error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
             )
 
     return func
+
+
+def require_correct_api_key_dbm_api_middleware():
+    @functools.wraps(require_correct_api_key_dbm_api_middleware)
+    def func(*, api_auth_data: APIAuthData, request: fastapi.requests.Request):
+        if not api_auth_data.is_api_key_correct:
+            raise APIException(
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
+                error_code=APIErrorCodes.cannot_authorize,
+                error_description="api_key_string is not correct",
+                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
+            )
+
+    return func
+
+
+def require_api_key_dbm_api_middleware(*, require_active: bool = True):
+    @functools.wraps(require_api_key_dbm_api_middleware)
+    async def async_func(*, api_auth_data: APIAuthData, request: fastapi.requests.Request):
+        if api_auth_data.api_key_dbm is None:
+            raise APIException(
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
+                error_code=APIErrorCodes.cannot_authorize,
+                error_description="api_key_dbm is required",
+                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
+            )
+        if require_active and not api_auth_data.api_key_dbm.is_active:
+            raise APIException(
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
+                error_code=APIErrorCodes.cannot_authorize,
+                error_description="api_key_dbm is not active",
+                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
+            )
+
+    return async_func
+
+
+def require_user_token_dbm_api_middleware(*, require_active: bool = True):
+    @functools.wraps(require_user_token_dbm_api_middleware)
+    async def async_func(*, api_auth_data: APIAuthData, request: fastapi.requests.Request):
+        if api_auth_data.user_token_dbm is None:
+            raise APIException(
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
+                error_code=APIErrorCodes.cannot_authorize,
+                error_description="user_key_dbm is required",
+                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
+            )
+        if require_active and not api_auth_data.user_token_dbm.is_active:
+            raise APIException(
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
+                error_code=APIErrorCodes.cannot_authorize,
+                error_description="user_key_dbm is not active",
+                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
+            )
+
+    return async_func

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/api/exception_handler.py

@@ -10,12 +10,11 @@ import starlette.exceptions
 from arpakitlib.ar_datetime_util import now_utc_dt
 from arpakitlib.ar_dict_util import combine_dicts
 from arpakitlib.ar_exception_util import exception_to_traceback_str
-from arpakitlib.ar_func_util import raise_if_not_async_callable, is_async_callable, is_sync_function
-from arpakitlib.ar_json_util import transfer_data_to_json_str
+from arpakitlib.ar_func_util import raise_if_not_async_func, is_async_func, is_sync_func
 from project.api.const import APIErrorCodes
 from project.api.exception import APIException
 from project.api.response import APIJSONResponse
-from project.api.schema.out.general.error import ErrorGeneralSO
+from project.api.schema.out.common.error import ErrorCommonSO
 from project.core.settings import get_cached_settings
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 from project.sqlalchemy_db_.sqlalchemy_model import StoryLogDBM
@@ -42,7 +41,7 @@ def create_api_exception_handler(
     ) -> APIJSONResponse:
         status_code = fastapi.status.HTTP_500_INTERNAL_SERVER_ERROR
 
-        error_common_so = ErrorGeneralSO(
+        error_common_so = ErrorCommonSO(
             has_error=True,
             error_code=APIErrorCodes.unknown_error,
             error_data={
@@ -102,7 +101,7 @@ def create_api_exception_handler(
 
         _transmitted_kwargs = {}
         for func_before in funcs_before:
-            if is_async_callable(func_before):
+            if is_async_func(func_before):
                 try:
                     await func_before(
                         request=request,
@@ -114,7 +113,7 @@ def create_api_exception_handler(
                 except Exception as exception_:
                     _logger.exception(exception_)
                     raise exception_
-            elif is_sync_function(func_before):
+            elif is_sync_func(func_before):
                 try:
                     func_before(
                         request=request,
@@ -132,7 +131,7 @@ def create_api_exception_handler(
         # async_funcs_after
 
         for async_func_after in async_funcs_after:
-            raise_if_not_async_callable(async_func_after)
+            raise_if_not_async_func(async_func_after)
             _ = asyncio.create_task(async_func_after(
                 request=request, status_code=status_code, error_common_so=error_common_so, exception=exception
             ))
@@ -157,7 +156,7 @@ def logging_func_before_in_api_exception_handler(
             *,
             request: fastapi.requests.Request,
             status_code: int,
-            error_common_so: ErrorGeneralSO,
+            error_common_so: ErrorCommonSO,
             exception: Exception,
             transmitted_kwargs: dict[str, Any],
             **kwargs
@@ -175,7 +174,7 @@ def logging_func_before_in_api_exception_handler(
         ):
             return
 
-        _logger.error(transfer_data_to_json_str(error_common_so.model_dump()), exc_info=False)
+        _logger.exception(exception)
 
     return func
 
@@ -192,7 +191,7 @@ def create_story_log_func_before_in_api_exception_handler(
             *,
             request: fastapi.requests.Request,
             status_code: int,
-            error_common_so: ErrorGeneralSO,
+            error_common_so: ErrorCommonSO,
             exception: Exception,
             transmitted_kwargs: dict[str, Any],
             **kwargs
@@ -216,9 +215,9 @@ def create_story_log_func_before_in_api_exception_handler(
                 type=StoryLogDBM.Types.error_in_api,
                 title=f"{status_code}, {type(exception)}",
                 data={
-                    "exception_str": str(exception),
+                    "exception": str(exception),
                     "error_common_so": error_common_so.model_dump(),
-                    "error_traceback_str": exception_to_traceback_str(exception=exception)
+                    "exception_traceback": exception_to_traceback_str(exception=exception)
                 }
             )
             session.add(story_log_dbm)

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/api/router/admin/get_arpakitlib_project_template_info.py

@@ -1,8 +1,10 @@
 import fastapi
 from fastapi import APIRouter
 
+from project.api.auth import require_user_token_dbm_api_middleware, require_api_key_dbm_api_middleware, APIAuthData, \
+    api_auth
+from project.api.schema.out.common.error import ErrorCommonSO
 from project.api.schema.out.common.raw_data import RawDataCommonSO
-from project.api.schema.out.general.error import ErrorGeneralSO
 from project.util.arpakitlib_project_template import get_arpakitlib_project_template_info
 
 api_router = APIRouter()
@@ -12,12 +14,16 @@ api_router = APIRouter()
     "",
     name="Get arpakitlib project template info",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=RawDataCommonSO | ErrorGeneralSO
+    response_model=RawDataCommonSO | ErrorCommonSO
 )
 async def _(
         *,
         request: fastapi.requests.Request,
-        response: fastapi.responses.Response
+        response: fastapi.responses.Response,
+        api_auth_data: APIAuthData = fastapi.Depends(api_auth(middlewares=[
+            require_api_key_dbm_api_middleware(require_active=True),
+            require_user_token_dbm_api_middleware(require_active=True)
+        ]))
 ):
     arpakitlib_project_template_data = get_arpakitlib_project_template_info()
     return RawDataCommonSO(data=arpakitlib_project_template_data)

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/api/router/admin/get_auth_data.py

@@ -1,9 +1,10 @@
 import fastapi.requests
 from fastapi import APIRouter
-from project.api.schema.out.common.error import ErrorCommonSO
 
 from arpakitlib.ar_json_util import transfer_data_to_json_str_to_data
-from project.api.auth import APIAuthData, api_auth
+from project.api.auth import APIAuthData, api_auth, require_user_token_dbm_api_middleware, \
+    require_api_key_dbm_api_middleware
+from project.api.schema.out.common.error import ErrorCommonSO
 from project.api.schema.out.common.raw_data import RawDataCommonSO
 
 api_router = APIRouter()
@@ -19,12 +20,9 @@ async def _(
         *,
         request: fastapi.requests.Request,
         response: fastapi.responses.Response,
-        api_auth_data: APIAuthData = fastapi.Depends(api_auth(
-            require_not_prod_mode=True,
-            try_find_api_key_dbm_from_sqlalchemy_db=True,
-            try_find_user_token_dbm_from_sqlalchemy_db=True,
-            require_api_key_dbm_from_sqlalchemy_db=True,
-            require_user_token_dbm_from_sqlalchemy_db=True
-        ))
+        api_auth_data: APIAuthData = fastapi.Depends(api_auth(middlewares=[
+            require_api_key_dbm_api_middleware(require_active=True),
+            require_user_token_dbm_api_middleware(require_active=True)
+        ]))
 ):
     return RawDataCommonSO(data=transfer_data_to_json_str_to_data(api_auth_data.model_dump()))

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

@@ -0,0 +1,20 @@
+from fastapi import APIRouter
+
+from project.api.router.admin import get_auth_data, get_arpakitlib_project_template_info, raise_fake_error
+
+main_admin_api_router = APIRouter()
+
+main_admin_api_router.include_router(
+    router=get_arpakitlib_project_template_info.api_router,
+    prefix="/get_arpakitlib_project_template_info"
+)
+
+main_admin_api_router.include_router(
+    router=get_auth_data.api_router,
+    prefix="/get_auth_data"
+)
+
+main_admin_api_router.include_router(
+    router=raise_fake_error.api_router,
+    prefix="/raise_fake_error"
+)

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

@@ -0,0 +1,27 @@
+import fastapi.requests
+from fastapi import APIRouter
+
+from project.api.auth import APIAuthData, api_auth, require_user_token_dbm_api_middleware, \
+    require_api_key_dbm_api_middleware
+from project.api.schema.out.common.error import ErrorCommonSO
+from project.api.schema.out.common.raw_data import RawDataCommonSO
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    path="",
+    name="Raise fake error",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=RawDataCommonSO | ErrorCommonSO,
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+        api_auth_data: APIAuthData = fastapi.Depends(api_auth(middlewares=[
+            require_api_key_dbm_api_middleware(require_active=True),
+            require_user_token_dbm_api_middleware(require_active=True)
+        ]))
+):
+    raise Exception("fake error")

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/api/router/client/get_errors_info.py

@@ -1,8 +1,10 @@
 import fastapi.requests
 from fastapi import APIRouter
-from project.api.schema.out.common.error import ErrorCommonSO
 
+from project.api.auth import APIAuthData, api_auth, require_api_key_dbm_api_middleware, \
+    require_user_token_dbm_api_middleware
 from project.api.const import APIErrorCodes, APIErrorSpecificationCodes
+from project.api.schema.out.common.error import ErrorCommonSO
 from project.api.schema.out.general.errors_info_general import ErrorsInfoGeneralSO
 
 api_router = APIRouter()
@@ -17,7 +19,11 @@ api_router = APIRouter()
 async def _(
         *,
         request: fastapi.requests.Request,
-        response: fastapi.responses.Response
+        response: fastapi.responses.Response,
+        api_auth_data: APIAuthData = fastapi.Depends(api_auth(middlewares=[
+            require_api_key_dbm_api_middleware(require_active=True),
+            require_user_token_dbm_api_middleware(require_active=True)
+        ]))
 ):
     return ErrorsInfoGeneralSO(
         api_error_codes=APIErrorCodes.values_list(),

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

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+from project.api.router.client import get_errors_info
+
+main_client_api_router = APIRouter()
+
+main_client_api_router.include_router(
+    router=get_errors_info.api_router,
+    prefix="/get_errors_info"
+)

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

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+
+from project.api.router.general import healthcheck, now_utc_datetime
+
+main_general_api_router = APIRouter()
+
+main_general_api_router.include_router(
+    router=healthcheck.api_router,
+    prefix="/healthcheck"
+)
+main_general_api_router.include_router(
+    router=now_utc_datetime.api_router,
+    prefix="/now_utc_datetime"
+)

arpakitlib/{_arpakit_project_template_v_4/project/api/router/client → _arpakit_project_template_v_5/project/api/router/general}/now_utc_datetime.py

@@ -3,7 +3,7 @@ from fastapi import APIRouter
 
 from arpakitlib.ar_datetime_util import now_utc_dt
 from project.api.schema.out.common.datetime_ import DatetimeCommonSO
-from project.api.schema.out.general.error import ErrorGeneralSO
+from project.api.schema.out.common.error import ErrorCommonSO
 
 api_router = APIRouter()
 
@@ -12,11 +12,11 @@ api_router = APIRouter()
     "",
     name="Now UTC datetime",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=DatetimeCommonSO | ErrorGeneralSO,
+    response_model=DatetimeCommonSO | ErrorCommonSO,
 )
 async def _(
         *,
         request: fastapi.requests.Request,
-        response: fastapi.responses.Response
+        response: fastapi.responses.Response,
 ):
     return DatetimeCommonSO.from_datetime(datetime_=now_utc_dt())

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/api/schema/out/admin/common.py

@@ -3,7 +3,7 @@ import datetime as dt
 from project.api.schema.common import BaseSO
 
 
-class SimpleDBMAdminCommonSO(BaseSO):
+class SimpleDBMAdminSO(BaseSO):
     id: int
     long_id: str
     slug: str | None

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/api/schema/out/admin/operation.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import datetime as dt
 from typing import Any
 
-from project.api.schema.out.admin.common import SimpleDBMAdminCommonSO
+from project.api.schema.out.admin.common import SimpleDBMAdminSO
 from project.sqlalchemy_db_.sqlalchemy_model import OperationDBM
 
 
-class OperationAdminSO(SimpleDBMAdminCommonSO):
+class OperationAdminSO(SimpleDBMAdminSO):
     execution_start_dt: dt.datetime | None
     execution_finish_dt: dt.datetime | None
     status: str

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/api/schema/out/admin/story_log.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 from typing import Any
 
-from project.api.schema.out.admin.common import SimpleDBMAdminCommonSO
+from project.api.schema.out.admin.common import SimpleDBMAdminSO
 from project.sqlalchemy_db_.sqlalchemy_model import StoryLogDBM
 
 
-class StoryLogAdminSO(SimpleDBMAdminCommonSO):
+class StoryLogAdminSO(SimpleDBMAdminSO):
     level: str
     type: str | None
     title: str | None

arpakitlib/_arpakit_project_template_v_5/project/api/schema/out/admin/user.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import Any
+
+from project.api.schema.out.admin.common import SimpleDBMAdminSO
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+
+
+class UserDBMSAdminSO(SimpleDBMAdminSO):
+    mail: str | None
+    roles: list[str]
+    is_active: bool
+    tg_id: int | None
+    tg_bot_last_action_dt: dt.datetime | None
+    tg_data: dict[str, Any] | None
+    roles_has_admin: bool
+    roles_has_client: bool
+
+    @classmethod
+    def from_user_dbm(cls, *, user_dbm: UserDBM) -> UserDBMSAdminSO:
+        return cls.model_validate(user_dbm.simple_dict_with_sd_properties())

arpakitlib/_arpakit_project_template_v_5/project/api/schema/out/admin/user_token.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from project.api.schema.out.admin.common import SimpleDBMAdminSO
+from project.sqlalchemy_db_.sqlalchemy_model import UserTokenDBM
+
+
+class UserTokenDBMSAdminSO(SimpleDBMAdminSO):
+    value: str
+    user_id: int
+    is_active: bool
+
+    @classmethod
+    def from_user_token_dbm(cls, *, user_dbm: UserTokenDBM) -> UserTokenDBMSAdminSO:
+        return cls.model_validate(user_dbm.simple_dict_with_sd_properties())

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/api/schema/out/client/common.py

@@ -3,7 +3,7 @@ import datetime as dt
 from project.api.schema.common import BaseSO
 
 
-class SimpleDBMClientCommonSO(BaseSO):
+class SimpleDBMClientSO(BaseSO):
     id: int
     long_id: str
     slug: str | None

arpakitlib/{_arpakit_project_template_v_4/project/api/schema/out/general → _arpakit_project_template_v_5/project/api/schema/out/common}/error.py

@@ -3,7 +3,7 @@ from typing import Any
 from project.api.schema.common import BaseSO
 
 
-class ErrorGeneralSO(BaseSO):
+class ErrorCommonSO(BaseSO):
     has_error: bool = True
     error_code: str | None = None
     error_specification_code: str | None = None