arpakitlib 1.8.17__py3-none-any.whl → 1.8.19__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 → _arpakit_project_template_v_5}/project/api/auth.py

@@ -9,7 +9,7 @@ from fastapi import Security
 from fastapi.security import APIKeyHeader
 from pydantic import BaseModel, ConfigDict
 
-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 arpakitlib.ar_type_util import raise_for_type
 from project.api.const import APIErrorCodes
@@ -199,12 +199,12 @@ def api_auth(
         # is_api_key_correct_func
 
         if is_api_key_correct_func is not None:
-            if is_async_callable(is_api_key_correct_func):
+            if is_async_func(is_api_key_correct_func):
                 await is_api_key_correct_func(
                     api_auth_data=api_auth_data,
                     request=request
                 )
-            elif is_sync_function(is_api_key_correct_func):
+            elif is_sync_func(is_api_key_correct_func):
                 is_api_key_correct_func(
                     api_auth_data=api_auth_data,
                     request=request
@@ -215,12 +215,12 @@ def api_auth(
         # is_user_token_correct_func
 
         if is_user_token_correct_func is not None:
-            if is_async_callable(is_user_token_correct_func):
+            if is_async_func(is_user_token_correct_func):
                 await is_user_token_correct_func(
                     api_auth_data=api_auth_data,
                     request=request
                 )
-            elif is_sync_function(is_user_token_correct_func):
+            elif is_sync_func(is_user_token_correct_func):
                 is_user_token_correct_func(
                     api_auth_data=api_auth_data,
                     request=request

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

@@ -4,15 +4,18 @@ 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 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 +24,18 @@ class APIAuthData(BaseModel):
     api_key_string: str | None = None
     user_token_string: str | None = None
 
+    api_key_dbm: ApiKeyDBM | None = None
+    user_token_dbm: UserTokenDBM | None = None
+
     prod_mode: bool = False
 
 
 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 +52,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 +62,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 +71,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 +108,111 @@ def api_auth(
         if not api_auth_data.user_token_string:
             api_auth_data.user_token_string = None
 
-        # middleware_funcs
+        # middlewares
 
-        for middleware_func in middleware_funcs:
-            if is_async_callable(middleware_func):
-                await middleware_func(
+        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():
     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():
     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():
     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():
     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 try_find_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:
+            return
+        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)
+            )
+
+    return async_func
+
+
+def try_find_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:
+            return
+        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).where(UserTokenDBM.value == api_auth_data.user_token_string)
+            )
+
+    return async_func
+
+
+def 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())
+            )
+
+    return async_func

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

@@ -10,12 +10,12 @@ 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_func_util import raise_if_not_async_func, is_async_func, is_sync_func
 from arpakitlib.ar_json_util import transfer_data_to_json_str
 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 +42,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 +102,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 +114,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 +132,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 +157,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
@@ -192,7 +192,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 +216,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,8 @@
 import fastapi
 from fastapi import APIRouter
 
+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,7 +12,7 @@ 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 _(
         *,

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

@@ -1,8 +1,11 @@
 import fastapi.requests
 from fastapi import APIRouter
-from project.api.schema.out.common.error import ErrorCommonSO
 
+from project.api.auth2 import APIAuthData, api_auth, require_api_key_string_api_middleware, \
+    require_user_token_string_api_middleware, try_find_api_key_dbm_api_middleware, \
+    try_find_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 +20,14 @@ 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_string_api_middleware(),
+            require_user_token_string_api_middleware(),
+            try_find_api_key_dbm_api_middleware(),
+            try_find_user_token_dbm_api_middleware(),
+
+        ]))
 ):
     return ErrorsInfoGeneralSO(
         api_error_codes=APIErrorCodes.values_list(),

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/api/router/client/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,7 +12,7 @@ api_router = APIRouter()
     "",
     name="Now UTC datetime",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=DatetimeCommonSO | ErrorGeneralSO,
+    response_model=DatetimeCommonSO | ErrorCommonSO,
 )
 async def _(
         *,

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_enabled: 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_enabled: 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

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/operation_execution/operation_executor_worker.py

@@ -113,7 +113,7 @@ class OperationExecutorWorker(BaseWorker):
                     operation_dbm.error_data,
                     {
                         "exception_in_execute_operation": str(exception_in_execute_operation),
-                        "traceback_str_in_execute_operation": exception_to_traceback_str(
+                        "traceback_in_execute_operation": exception_to_traceback_str(
                             exception=exception_in_execute_operation
                         ),
                     }
@@ -208,7 +208,7 @@ class OperationExecutorWorker(BaseWorker):
                 operation_dbm.error_data = combine_dicts(
                     {
                         "exception_in_execute_operation": str(exception_in_execute_operation),
-                        "traceback_str_in_execute_operation": exception_to_traceback_str(
+                        "traceback_in_execute_operation": exception_to_traceback_str(
                             exception=exception_in_execute_operation
                         )
                     },

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/sandbox/sandbox_1.py

@@ -2,7 +2,9 @@ import asyncio
 
 
 def __sandbox():
-    pass
+    a = {1, 2, 3}
+    a += [1, 2]
+    print(a)
 
 
 async def __async_sandbox():

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/sqlalchemy_db_/sqlalchemy_model/user.py

@@ -21,7 +21,7 @@ class UserDBM(SimpleDBM):
         admin = "admin"
         client = "client"
 
-    mail: Mapped[str] = mapped_column(
+    mail: Mapped[str | None] = mapped_column(
         sqlalchemy.TEXT,
         index=True,
         insert_default=None,

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/tg_bot/blank/admin.py

@@ -1,21 +1,15 @@
 from functools import lru_cache
-from typing import Any
 
 from emoji import emojize
 
-from arpakitlib.ar_json_util import transfer_data_to_json_str
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 from project.tg_bot.blank.common import SimpleBlankTgBot
 from project.util.arpakitlib_project_template import get_arpakitlib_project_template_info
 
 
 class AdminTgBotBlank(SimpleBlankTgBot):
-    def done(self) -> str:
-        res = "Done"
-        return emojize(res.strip())
-
-    def arpakit_project_template_info(self, *, arpakitlib_project_template_info: dict[str, Any]) -> str:
-        res = transfer_data_to_json_str(arpakitlib_project_template_info, beautify=True)
+    def good(self) -> str:
+        res = "good"
         return emojize(res.strip())
 
     def user_dbm(self, *, user_dbm: UserDBM | None) -> str:

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/blank/client.py

@@ -0,0 +1,69 @@
+from functools import lru_cache
+
+from emoji import emojize
+
+from project.tg_bot.blank.common import SimpleBlankTgBot
+from project.tg_bot.const import ClientTgBotCommands
+
+
+class ClientTgBotBlank(SimpleBlankTgBot):
+    def command_to_desc(self) -> dict[str, str]:
+        return {
+            ClientTgBotCommands.start: emojize(":waving_hand: Начать"),
+            ClientTgBotCommands.about: emojize(":information: О проекте")
+        }
+
+    def but_hello_world(self) -> str:
+        res = "hello_world"
+        return emojize(res.strip())
+
+    def error(self) -> str:
+        res = ":warning: <b>Произошла неполадка</b> :warning:"
+        res += "\n\n:wrench: Мы уже работаем над исправлением"
+        res += "\n\n:red_heart: Просим прощения :red_heart:"
+        return emojize(res.strip())
+
+    def hello_world(self) -> str:
+        res = ":waving_hand: <b>Hello world</b> :waving_hand:"
+        return emojize(res.strip())
+
+    def healthcheck(self) -> str:
+        res = "healthcheck"
+        return emojize(res.strip())
+
+    def welcome(self) -> str:
+        res = ":waving_hand: <b>Welcome</b> :waving_hand:"
+        return emojize(res.strip())
+
+    def raw_message(self) -> str:
+        res = ":warning: <b>Сообщние не обработано</b> :warning:"
+        return emojize(res.strip())
+
+    def about_project(self) -> str:
+        res = ":information: <b>О проекте</b>"
+        return emojize(res.strip())
+
+    def support_info(self) -> str:
+        res = ":red_heart: <b>Поддержка</b>"
+        return emojize(res.strip())
+
+    def keyboard_is_old(self) -> str:
+        res = ":information: Данная клавиатура устарела :information:"
+        return emojize(res.strip())
+
+
+def create_client_tg_bot_blank() -> ClientTgBotBlank:
+    return ClientTgBotBlank()
+
+
+@lru_cache()
+def get_cached_client_tg_bot_blank() -> ClientTgBotBlank:
+    return ClientTgBotBlank()
+
+
+def __example():
+    print(get_cached_client_tg_bot_blank().welcome())
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/tg_bot/callback/client.py

@@ -3,3 +3,7 @@ from project.tg_bot.callback.common import BaseCD
 
 class HelloWorldClientCD(BaseCD):
     hello_world: bool = True
+
+
+class RemoveMessageCD(BaseCD):
+    pass