arpakitlib 1.8.85__py3-none-any.whl → 1.8.88__py3-none-any.whl

arpakitlib/_arpakit_project_template_v_5/arpakitlib_project_template_info.json

@@ -1,4 +1,4 @@
 {
   "arpakitlib_project_template_version": "5",
-  "arpakitlib_project_template_subversion": "19"
+  "arpakitlib_project_template_subversion": "20"
 }

arpakitlib/_arpakit_project_template_v_5/command/show_arpakitlib_project_template_info.py

@@ -0,0 +1,9 @@
+from project.util.arpakitlib_project_template import get_arpakitlib_project_template_info
+
+
+def __command():
+    print(get_arpakitlib_project_template_info())
+
+
+if __name__ == '__main__':
+    __command()

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

@@ -3,9 +3,9 @@ import datetime as dt
 import fastapi
 from fastapi import APIRouter
 
+from arpakitlib.ar_datetime_util import now_utc_dt
 from project.api.schema.common import BaseSO
 from project.api.schema.out.common.error import ErrorCommonSO
-from project.core.util import now_local_dt
 
 
 class _HealthcheckGeneralRouteSO(BaseSO):
@@ -27,4 +27,4 @@ async def _(
         request: fastapi.requests.Request,
         response: fastapi.responses.Response
 ):
-    return _HealthcheckGeneralRouteSO(is_ok=True, datetime=now_local_dt())
+    return _HealthcheckGeneralRouteSO(is_ok=True, datetime=now_utc_dt())

arpakitlib/_arpakit_project_template_v_5/project/core/settings.py

@@ -152,6 +152,8 @@ class Settings(SimpleSettings):
 
     tg_bot_admin_tg_ids: list[int] = [269870432]
 
+    tg_bot_set_commands: bool = True
+
     var_dirpath: str | None = os.path.join(ProjectPaths.base_dirpath, "var")
 
     log_filepath: str | None = os.path.join(var_dirpath, "story.log")

arpakitlib/_arpakit_project_template_v_5/project/sandbox/sandbox_1.py

@@ -1,10 +1,5 @@
 import asyncio
 
-from pydantic import BaseModel
-
-from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
-from project.sqlalchemy_db_.sqlalchemy_model import ApiKeyDBM
-
 
 def __sandbox():
     pass

arpakitlib/_arpakit_project_template_v_5/project/sqladmin_/model_view/user.py

@@ -7,7 +7,18 @@ from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 class UserMV(SimpleMV, model=UserDBM):
     name = "User"
     name_plural = "Users"
-    column_list = sqlalchemy.inspect(UserDBM).columns
+    column_list = [
+        UserDBM.id,
+        UserDBM.long_id,
+        UserDBM.slug,
+        UserDBM.creation_dt,
+        UserDBM.email,
+        UserDBM.username,
+        UserDBM.roles,
+        UserDBM.is_active,
+        UserDBM.password,
+        UserDBM.extra_data
+    ]
     form_columns = [
         UserDBM.slug,
         UserDBM.email,
@@ -15,9 +26,6 @@ class UserMV(SimpleMV, model=UserDBM):
         UserDBM.roles,
         UserDBM.is_active,
         UserDBM.password,
-        UserDBM.tg_id,
-        UserDBM.tg_bot_last_action_dt,
-        UserDBM.tg_data,
         UserDBM.extra_data
     ]
     column_sortable_list = sqlalchemy.inspect(UserDBM).columns
@@ -28,6 +36,7 @@ class UserMV(SimpleMV, model=UserDBM):
         UserDBM.id,
         UserDBM.long_id,
         UserDBM.slug,
-        UserDBM.tg_id,
+        UserDBM.email,
+        UserDBM.username,
         UserDBM.password
     ]

arpakitlib/_arpakit_project_template_v_5/project/sqladmin_/model_view/user_token.py

@@ -7,7 +7,16 @@ from project.sqlalchemy_db_.sqlalchemy_model import UserTokenDBM
 class UserTokenMV(SimpleMV, model=UserTokenDBM):
     name = "UserToken"
     name_plural = "UserTokens"
-    column_list = sqlalchemy.inspect(UserTokenDBM).columns
+    column_list = [
+        UserTokenDBM.id,
+        UserTokenDBM.long_id,
+        UserTokenDBM.slug,
+        UserTokenDBM.creation_dt,
+        UserTokenDBM.value,
+        UserTokenDBM.user,
+        UserTokenDBM.is_active,
+        UserTokenDBM.extra_data,
+    ]
     form_columns = [
         UserTokenDBM.slug,
         UserTokenDBM.creation_dt,

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

@@ -8,8 +8,12 @@ from project.tg_bot.blank.common import SimpleBlankTgBot
 
 
 class AdminTgBotBlank(SimpleBlankTgBot):
+    def but_hello_world(self) -> str:
+        res = "hello_world"
+        return emojize(res.strip())
+
     def good(self) -> str:
-        res = "good"
+        res = "Good"
         return emojize(res.strip())
 
     def user_dbm(self, *, user_dbm: UserDBM | None) -> str:
@@ -18,13 +22,9 @@ class AdminTgBotBlank(SimpleBlankTgBot):
         return transfer_data_to_json_str(user_dbm.simple_dict(), beautify=True)
 
 
-def create_admin_tg_bot_blank() -> AdminTgBotBlank:
-    return AdminTgBotBlank()
-
-
 @lru_cache()
-def get_cached_admin_tg_bot_blank() -> AdminTgBotBlank:
-    return AdminTgBotBlank()
+def get_cached_eng_admin_tg_bot_blank() -> AdminTgBotBlank:
+    return AdminTgBotBlank(lang=AdminTgBotBlank.Languages.rus)
 
 
 def __example():

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

@@ -3,30 +3,27 @@ from functools import lru_cache
 from emoji import emojize
 
 from project.tg_bot.blank.common import SimpleBlankTgBot
-from project.tg_bot.const import GeneralTgBotCommands
+from project.tg_bot.const import ClientTgBotCommands
 
 
 class ClientTgBotBlank(SimpleBlankTgBot):
     def command_to_desc(self) -> dict[str, str]:
         return {
-            GeneralTgBotCommands.start: emojize(":waving_hand: Начать"),
-            GeneralTgBotCommands.about: emojize(":information: О проекте"),
-            GeneralTgBotCommands.author: emojize(":bust_in_silhouette: Авторы"),
-            GeneralTgBotCommands.support: emojize(":red_heart: Поддержка"),
+            ClientTgBotCommands.start: emojize(":waving_hand: Начать"),
+            ClientTgBotCommands.about: emojize(":information: О проекте"),
+            ClientTgBotCommands.author: emojize(":bust_in_silhouette: Авторы"),
+            ClientTgBotCommands.support: emojize(":red_heart: Поддержка"),
+            ClientTgBotCommands.cancel: emojize(":right_arrow_curving_left: Отмена"),
         }
 
-    def but_hello_world(self) -> str:
-        res = "hello_world"
+    def but_support(self) -> str:
+        res = ":red_heart: Поддержка"
         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:"
+        res = ":warning: <b>Упс! Что-то пошло не так...</b> :warning:"
+        res += "\n\n:wrench:  Мы уже работаем над решением проблемы"
+        res += "\n\n:red_heart: Приносим извинения за неудобства :red_heart:"
         return emojize(res.strip())
 
     def healthcheck(self) -> str:
@@ -54,24 +51,25 @@ class ClientTgBotBlank(SimpleBlankTgBot):
 
     def support(self) -> str:
         res = ":red_heart: <b>Поддержка</b> :red_heart:"
+        res += f"\n\n:link: https://t.me/arpakit"
         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()
+    def cancel(self) -> str:
+        res = ":right_arrow_curving_left: <b>Отмена</b>"
+        return emojize(res.strip())
 
 
 @lru_cache()
-def get_cached_client_tg_bot_blank() -> ClientTgBotBlank:
-    return ClientTgBotBlank()
+def get_cached_rus_client_tg_bot_blank() -> ClientTgBotBlank:
+    return ClientTgBotBlank(lang=ClientTgBotBlank.Languages.rus)
 
 
 def __example():
-    print(get_cached_client_tg_bot_blank().author())
+    print(get_cached_rus_client_tg_bot_blank().author())
 
 
 if __name__ == '__main__':

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/callback/admin.py

@@ -0,0 +1,5 @@
+from project.tg_bot.callback.common import BaseCD
+
+
+class HelloWorldAdminCD(BaseCD):
+    hello_world: bool = True

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

@@ -1,9 +1,5 @@
 from project.tg_bot.callback.common import BaseCD
 
 
-class HelloWorldClientCD(BaseCD):
-    hello_world: bool = True
-
-
-class RemoveMessageCD(BaseCD):
+class RemoveMessageClientCD(BaseCD):
     pass

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/const.py

@@ -1,13 +1,13 @@
 from arpakitlib.ar_enumeration_util import Enumeration
 
 
-class GeneralTgBotCommands(Enumeration):
+class ClientTgBotCommands(Enumeration):
     start = "start"
     about = "about"
     author = "author"
     support = "support"
     healthcheck = "healthcheck"
-    hello_world = "hello_world"
+    cancel = "cancel"
 
 
 class AdminTgBotCommands(Enumeration):
@@ -24,11 +24,13 @@ class AdminTgBotCommands(Enumeration):
     kb_with_not_modified = "kb_with_not_modified"
     kb_with_raise_error = "kb_with_raise_error"
     kb_with_remove_message = "kb_with_remove_message"
+    current_state = "current_state"
+    hello_world = "hello_world"
 
 
 def __example():
     print("ClientCommandsTgBot:")
-    for v in GeneralTgBotCommands.values_list():
+    for v in ClientTgBotCommands.values_list():
         print(f"- {v}")
     print()
     print("AdminCommandsTgBot:")

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/event.py

@@ -1,9 +1,11 @@
+import asyncio
 import logging
 from typing import Callable
 
 from aiogram import Dispatcher
 
 from arpakitlib.ar_base_worker_util import safe_run_worker_in_background, SafeRunInBackgroundModes
+from arpakitlib.ar_datetime_util import now_utc_dt
 from project.core.cache_file_storage_in_dir import get_cached_cache_file_storage_in_dir
 from project.core.dump_file_storage_in_dir import get_cached_dump_file_storage_in_dir
 from project.core.media_file_storage_in_dir import get_cached_media_file_storage_in_dir
@@ -13,6 +15,8 @@ from project.operation_execution.operation_executor_worker import create_operati
 from project.operation_execution.scheduled_operation_creator_worker import create_scheduled_operation_creator_worker
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 from project.tg_bot.tg_bot import get_cached_tg_bot
+from project.tg_bot.util.notify_admins import notify_admins
+from project.tg_bot.util.set_tg_bot_commands import set_all_tg_bot_commands
 
 _logger = logging.getLogger(__name__)
 
@@ -23,6 +27,8 @@ _logger = logging.getLogger(__name__)
 async def startup_tg_bot_event():
     _logger.info("start")
 
+    _ = asyncio.create_task(notify_admins(text=f"Start\n{now_utc_dt().isoformat()}"))
+
     if get_cached_media_file_storage_in_dir() is not None:
         get_cached_media_file_storage_in_dir().init()
 
@@ -44,6 +50,9 @@ async def startup_tg_bot_event():
     ):
         get_cached_json_db().init()
 
+    if get_cached_settings().tg_bot_set_commands:
+        await set_all_tg_bot_commands()
+
     if get_cached_settings().tg_bot_drop_pending_updates:
         await get_cached_tg_bot().delete_webhook(drop_pending_updates=True)
 
@@ -89,6 +98,8 @@ async def shutdown_tg_bot_event(*args, **kwargs):
     if get_cached_settings().tg_bot_webhook_enabled:
         await get_cached_tg_bot().delete_webhook(drop_pending_updates=True)
 
+    await notify_admins(text=f"Finish\n{now_utc_dt().isoformat()}")
+
     _logger.info("finish")
 
 
@@ -97,7 +108,7 @@ def get_shutdown_tg_bot_events() -> list[Callable]:
     return res
 
 
-#
+# MAIN
 
 
 def add_events_to_tg_bot_dispatcher(*, tg_bot_dispatcher: Dispatcher):

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/filter_/user_roles_has_admin.py

@@ -12,7 +12,7 @@ class UserRolesHasAdminTgBotFilter(Filter):
             middleware_data_tg_bot: MiddlewareDataTgBot,
             **kwargs
     ) -> bool:
-        if middleware_data_tg_bot.user_dbm is not None:
-            if middleware_data_tg_bot.user_dbm.roles_has_admin:
+        if middleware_data_tg_bot.current_user_dbm is not None:
+            if middleware_data_tg_bot.current_user_dbm.roles_has_admin:
                 return True
         return False

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/filter_/user_roles_has_client.py

@@ -12,7 +12,7 @@ class UserRolesHasClientTgBotFilter(Filter):
             middleware_data_tg_bot: MiddlewareDataTgBot,
             **kwargs
     ) -> bool:
-        if middleware_data_tg_bot.user_dbm is not None:
-            if middleware_data_tg_bot.user_dbm.roles_has_client:
+        if middleware_data_tg_bot.current_user_dbm is not None:
+            if middleware_data_tg_bot.current_user_dbm.roles_has_client:
                 return True
         return False

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/kb/inline_/admin/hello_world.py

@@ -0,0 +1,16 @@
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from project.tg_bot.blank.admin import get_cached_eng_admin_tg_bot_blank
+from project.tg_bot.callback.admin import HelloWorldAdminCD
+
+
+def hello_world_admin_inline_kb_tg_bot() -> InlineKeyboardMarkup:
+    kb_builder = InlineKeyboardBuilder()
+
+    kb_builder.row(InlineKeyboardButton(
+        text=get_cached_eng_admin_tg_bot_blank().but_hello_world(),
+        callback_data=HelloWorldAdminCD(hello_world=True).pack()
+    ))
+
+    return kb_builder.as_markup()

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/kb/inline_/client/support.py

@@ -0,0 +1,15 @@
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from project.tg_bot.blank.client import get_cached_rus_client_tg_bot_blank
+
+
+def support_client_inline_kb_tg_bot() -> InlineKeyboardMarkup:
+    return InlineKeyboardBuilder(markup=[
+        [
+            InlineKeyboardButton(
+                text=get_cached_rus_client_tg_bot_blank().but_support(),
+                url="https://t.me/arpakit"
+            )
+        ]
+    ]).as_markup()

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/kb/static_/{client → admin}/hello_world.py

@@ -1,14 +1,14 @@
 from aiogram.types import ReplyKeyboardMarkup, KeyboardButton
 from aiogram.utils.keyboard import ReplyKeyboardBuilder
 
-from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.blank.admin import get_cached_eng_admin_tg_bot_blank
 
 
-def hello_world_client_static_kb_tg_bot() -> ReplyKeyboardMarkup:
+def hello_world_admin_static_kb_tg_bot() -> ReplyKeyboardMarkup:
     kb_builder = ReplyKeyboardBuilder()
 
     kb_builder.row(KeyboardButton(
-        text=get_cached_client_tg_bot_blank().but_hello_world()
+        text=get_cached_eng_admin_tg_bot_blank().but_hello_world()
     ))
 
     return kb_builder.as_markup(resize_keyboard=True, one_time_keyboard=False)

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/middleware/common.py

@@ -8,6 +8,6 @@ from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 class MiddlewareDataTgBot(BaseModel):
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
 
-    user_dbm: UserDBM | None = None
-    user_dbm_just_created: bool | None = None
+    current_user_dbm: UserDBM | None = None
+    current_user_dbm_just_created: bool | None = None
     additional_data: dict[str, Any] = {}

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/middleware/init_user.py

@@ -47,38 +47,38 @@ class InitUserTgBotMiddleware(BaseMiddleware):
 
         if tg_user is not None and get_cached_sqlalchemy_db() is not None:
             async with get_cached_sqlalchemy_db().new_async_session() as async_session:
-                middleware_data_tg_bot.user_dbm = await async_session.scalar(
+                middleware_data_tg_bot.current_user_dbm = await async_session.scalar(
                     sqlalchemy.select(UserDBM).filter(UserDBM.tg_id == tg_user.id)
                 )
-                if middleware_data_tg_bot.user_dbm is None:
+                if middleware_data_tg_bot.current_user_dbm is None:
                     roles = [UserDBM.Roles.client]
                     if tg_user.id in get_cached_settings().tg_bot_admin_tg_ids:
                         roles.append(UserDBM.Roles.admin)
-                    middleware_data_tg_bot.user_dbm = UserDBM(
+                    middleware_data_tg_bot.current_user_dbm = UserDBM(
                         creation_dt=now_utc_dt_,
                         roles=roles,
                         tg_id=tg_user.id,
                         tg_data=tg_user.model_dump(mode="json"),
                         tg_bot_last_action_dt=now_utc_dt_
                     )
-                    async_session.add(middleware_data_tg_bot.user_dbm)
+                    async_session.add(middleware_data_tg_bot.current_user_dbm)
                     await async_session.commit()
-                    await async_session.refresh(middleware_data_tg_bot.user_dbm)
-                    middleware_data_tg_bot.user_dbm_just_created = True
-                    _logger.info(f"user_dbm was added, {middleware_data_tg_bot.user_dbm}")
+                    await async_session.refresh(middleware_data_tg_bot.current_user_dbm)
+                    middleware_data_tg_bot.current_user_dbm_just_created = True
+                    _logger.info(f"user_dbm was added, {middleware_data_tg_bot.current_user_dbm}")
                 else:
-                    middleware_data_tg_bot.user_dbm.tg_data = tg_user.model_dump(mode="json")
-                    middleware_data_tg_bot.user_dbm.tg_bot_last_action_dt = now_utc_dt_
+                    middleware_data_tg_bot.current_user_dbm.tg_data = tg_user.model_dump(mode="json")
+                    middleware_data_tg_bot.current_user_dbm.tg_bot_last_action_dt = now_utc_dt_
                     if (
                             tg_user.id in get_cached_settings().tg_bot_admin_tg_ids
-                            and UserDBM.Roles.admin not in middleware_data_tg_bot.user_dbm.roles
+                            and UserDBM.Roles.admin not in middleware_data_tg_bot.current_user_dbm.roles
                     ):
-                        middleware_data_tg_bot.user_dbm.roles = (
-                                middleware_data_tg_bot.user_dbm.roles + [UserDBM.Roles.admin]
+                        middleware_data_tg_bot.current_user_dbm.roles = (
+                                middleware_data_tg_bot.current_user_dbm.roles + [UserDBM.Roles.admin]
                         )
                     await async_session.commit()
-                    await async_session.refresh(middleware_data_tg_bot.user_dbm)
-                    middleware_data_tg_bot.user_dbm_just_created = False
+                    await async_session.refresh(middleware_data_tg_bot.current_user_dbm)
+                    middleware_data_tg_bot.current_user_dbm_just_created = False
 
         _logger.info("finish")
 

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/admin/arpakitlib_project_template_info.py

@@ -1,4 +1,5 @@
 import aiogram.filters
+from aiogram.fsm.context import FSMContext
 
 from arpakitlib.ar_aiogram_util import as_tg_command
 from arpakitlib.ar_json_util import transfer_data_to_json_str
@@ -19,9 +20,11 @@ tg_bot_router = aiogram.Router()
 @as_tg_command()
 async def _(
         m: aiogram.types.Message,
+        state: FSMContext,
         middleware_data_tg_bot: MiddlewareDataTgBot,
         **kwargs
 ):
+    await state.clear()
     await m.answer(
         text=transfer_data_to_json_str(get_arpakitlib_project_template_info(), beautify=True)
     )

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/admin/clear_log_file.py

@@ -1,13 +1,15 @@
 import aiogram
 from aiogram import Router, types
 from aiogram.filters import Command
+from aiogram.fsm.context import FSMContext
 
 from arpakitlib.ar_aiogram_util import as_tg_command
 from project.core.settings import get_cached_settings
-from project.tg_bot.blank.admin import get_cached_admin_tg_bot_blank
+from project.tg_bot.blank.admin import get_cached_eng_admin_tg_bot_blank
 from project.tg_bot.const import AdminTgBotCommands
 from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
 from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
 
 tg_bot_router = Router()
 
@@ -20,14 +22,18 @@ tg_bot_router = Router()
 @as_tg_command(passwd_validator=get_cached_settings().tg_bot_command_passwd)
 async def _(
         m: types.Message,
+        state: FSMContext,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
         **kwargs
 ):
+    await state.clear()
+
     with open(get_cached_settings().log_filepath, mode="r") as f:
         if not f.read():
-            await m.answer(get_cached_admin_tg_bot_blank().good())
+            await m.answer(get_cached_eng_admin_tg_bot_blank().good())
             return
 
     with open(get_cached_settings().log_filepath, mode="w") as f:
         f.write("")
 
-    await m.answer(get_cached_admin_tg_bot_blank().good())
+    await m.answer(get_cached_eng_admin_tg_bot_blank().good())

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/admin/current_state.py

@@ -0,0 +1,31 @@
+import aiogram
+from aiogram import Router, types
+from aiogram.filters import Command
+from aiogram.fsm.context import FSMContext
+
+from arpakitlib.ar_aiogram_util import as_tg_command
+from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
+from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = Router()
+
+
+@tg_bot_router.message(
+    IsPrivateChatTgBotFilter(),
+    UserRolesHasAdminTgBotFilter(),
+    aiogram.filters.Command(AdminTgBotCommands.current_state)
+)
+@as_tg_command()
+async def _(
+        m: types.Message,
+        state: FSMContext,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    state = await state.get_state()
+    await m.answer(text=(
+        f"State:"
+        f"\n<code>{state}</code>"
+    ))

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/admin/drop_sqlalchemy_db.py

@@ -1,9 +1,10 @@
 import aiogram.filters
+from aiogram.fsm.context import FSMContext
 
 from arpakitlib.ar_aiogram_util import as_tg_command
 from project.core.settings import get_cached_settings
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
-from project.tg_bot.blank.admin import get_cached_admin_tg_bot_blank
+from project.tg_bot.blank.admin import get_cached_eng_admin_tg_bot_blank
 from project.tg_bot.const import AdminTgBotCommands
 from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
 from project.tg_bot.filter_.not_prod_mode_filter import NotProdModeTgBotFilter
@@ -22,10 +23,12 @@ tg_bot_router = aiogram.Router()
 @as_tg_command(passwd_validator=get_cached_settings().tg_bot_command_passwd)
 async def _(
         m: aiogram.types.Message,
+        state: FSMContext,
         middleware_data_tg_bot: MiddlewareDataTgBot,
         **kwargs
 ):
+    await state.clear()
     get_cached_sqlalchemy_db().drop()
     await m.answer(
-        text=get_cached_admin_tg_bot_blank().good()
+        text=get_cached_eng_admin_tg_bot_blank().good()
     )

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/admin/hello_world.py

@@ -0,0 +1,73 @@
+import aiogram.filters
+from aiogram.filters import or_f
+from aiogram.fsm.context import FSMContext
+
+from arpakitlib.ar_str_util import remove_html
+from project.tg_bot.blank.admin import get_cached_eng_admin_tg_bot_blank
+from project.tg_bot.blank.client import get_cached_rus_client_tg_bot_blank
+from project.tg_bot.callback.admin import HelloWorldAdminCD
+from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
+from project.tg_bot.filter_.message_text import MessageTextTgBotFilter
+from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
+from project.tg_bot.kb.inline_.admin.hello_world import hello_world_admin_inline_kb_tg_bot
+from project.tg_bot.kb.static_.admin.hello_world import hello_world_admin_static_kb_tg_bot
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+from project.tg_bot.state.client import HelloWorldClientStates
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.message(
+    IsPrivateChatTgBotFilter(),
+    UserRolesHasAdminTgBotFilter(),
+    or_f(
+        aiogram.filters.Command(AdminTgBotCommands.hello_world),
+        MessageTextTgBotFilter(get_cached_eng_admin_tg_bot_blank().but_hello_world())
+    ),
+
+)
+async def _(
+        m: aiogram.types.Message,
+        state: FSMContext,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await state.clear()
+    await m.answer(
+        text=get_cached_rus_client_tg_bot_blank().hello_world(),
+        reply_markup=hello_world_admin_inline_kb_tg_bot()
+    )
+    await m.answer(
+        text=get_cached_rus_client_tg_bot_blank().hello_world(),
+        reply_markup=hello_world_admin_static_kb_tg_bot()
+    )
+    await state.set_state(HelloWorldClientStates.input_text)
+
+
+@tg_bot_router.callback_query(
+    HelloWorldAdminCD.filter()
+)
+async def _(
+        cq: aiogram.types.CallbackQuery,
+        state: FSMContext,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await cq.message.delete_reply_markup()
+    await cq.message.answer(
+        text=remove_html(get_cached_rus_client_tg_bot_blank().hello_world())
+    )
+
+
+@tg_bot_router.message(
+    HelloWorldClientStates.input_text
+)
+async def _(
+        m: aiogram.types.Message,
+        state: FSMContext,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await state.clear()
+    await m.answer("Hello world")