arpakitlib 1.8.17__py3-none-any.whl → 1.8.19__py3-none-any.whl

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/error_handler.py

@@ -0,0 +1,91 @@
+import logging
+
+import aiogram
+from aiogram import Router
+from aiogram.exceptions import TelegramBadRequest
+
+from arpakitlib.ar_exception_util import exception_to_traceback_str
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import StoryLogDBM
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+_logger = logging.getLogger(__name__)
+
+tg_bot_router = Router()
+
+
+@tg_bot_router.error()
+async def _(
+        error_event: aiogram.types.ErrorEvent,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    need_logging = True
+    need_create_story_log = True
+
+    if (
+            error_event.update.event_type == "message"
+            and isinstance(error_event.update.event, aiogram.types.Message)
+    ):
+        try:
+            await error_event.update.event.answer(
+                text=get_cached_client_tg_bot_blank().error()
+            )
+        except Exception as exception:
+            _logger.error(exception)
+
+    if (
+            error_event.update.event_type == "callback_query"
+            and isinstance(error_event.update.event, aiogram.types.CallbackQuery)
+    ):
+
+        if isinstance(error_event.exception, TelegramBadRequest) and (
+                error_event.exception.message
+                and "message is not modified".lower().strip() in error_event.exception.message.lower().strip()
+        ):
+            error_linked_with_message_not_modified = True
+        else:
+            error_linked_with_message_not_modified = False
+
+        if error_linked_with_message_not_modified:
+            need_logging = False
+            need_create_story_log = False
+
+        try:
+            await error_event.update.event.answer()
+        except Exception as exception:
+            _logger.error(exception)
+
+        if not error_linked_with_message_not_modified:
+
+            try:
+                await error_event.update.event.message.edit_reply_markup(reply_markup=None)
+            except Exception as exception:
+                _logger.error(exception)
+
+            try:
+                await error_event.update.event.message.answer(
+                    text=get_cached_client_tg_bot_blank().error()
+                )
+            except Exception as exception:
+                _logger.error(exception)
+
+    if need_logging:
+        _logger.exception(error_event.exception)
+
+    if need_create_story_log:
+        if get_cached_sqlalchemy_db() is not None:
+            async with get_cached_sqlalchemy_db().new_async_session() as session:
+                story_log_dbm = StoryLogDBM(
+                    level=StoryLogDBM.Levels.error,
+                    type=StoryLogDBM.Types.error_in_tg_bot,
+                    title=f"{type(error_event.exception)}",
+                    data={
+                        "exception": str(error_event.exception),
+                        "exception_traceback": exception_to_traceback_str(exception=error_event.exception)
+                    }
+                )
+                session.add(story_log_dbm)
+                await session.commit()
+                await session.refresh(story_log_dbm)

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

@@ -7,7 +7,9 @@ from project.tg_bot.middleware.common import MiddlewareDataTgBot
 tg_bot_router = aiogram.Router()
 
 
-@tg_bot_router.message(aiogram.filters.Command(ClientTgBotCommands.healthcheck))
+@tg_bot_router.message(
+    aiogram.filters.Command(ClientTgBotCommands.healthcheck),
+)
 async def _(
         m: aiogram.types.Message,
         middleware_data_tg_bot: MiddlewareDataTgBot,

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

@@ -17,7 +17,8 @@ tg_bot_router = aiogram.Router()
     or_f(
         aiogram.filters.Command(ClientTgBotCommands.hello_world),
         MessageTextTgBotFilter(get_cached_client_tg_bot_blank().but_hello_world())
-    )
+    ),
+
 )
 async def _(
         m: aiogram.types.Message,
@@ -34,7 +35,9 @@ async def _(
     )
 
 
-@tg_bot_router.callback_query(HelloWorldClientCD.filter())
+@tg_bot_router.callback_query(
+    HelloWorldClientCD.filter()
+)
 async def _(
         cq: aiogram.types.CallbackQuery,
         middleware_data_tg_bot: MiddlewareDataTgBot,

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/raw_callback_query.py

@@ -0,0 +1,30 @@
+import logging
+
+import aiogram.filters
+from aiogram.exceptions import AiogramError
+
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+_logger = logging.getLogger(__name__)
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.callback_query()
+async def _(
+        cq: aiogram.types.CallbackQuery,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    try:
+        await cq.answer(
+            text=get_cached_client_tg_bot_blank().keyboard_is_old(),
+            show_alert=True
+        )
+    except AiogramError as exception:
+        _logger.error(exception)
+
+    try:
+        await cq.message.edit_reply_markup(reply_markup=None)
+    except AiogramError as e:
+        _logger.error(e)

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/raw_inline_query.py

@@ -0,0 +1,14 @@
+import aiogram.filters
+
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.inline_query()
+async def _(
+        iq: aiogram.types.InlineQuery,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    pass

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/raw_message.py

@@ -0,0 +1,15 @@
+import aiogram.filters
+
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.message()
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await m.answer(text=get_cached_client_tg_bot_blank().raw_message())

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/remove_message.py

@@ -0,0 +1,28 @@
+import logging
+
+from aiogram import Router, types
+from aiogram.exceptions import AiogramError
+
+from project.tg_bot.callback.client import RemoveMessageCD
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+_logger = logging.getLogger(__name__)
+tg_bot_router = Router()
+
+
+@tg_bot_router.callback_query(
+    RemoveMessageCD.filter(),
+)
+async def _(
+        cq: types.CallbackQuery,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    try:
+        await cq.message.delete()
+    except AiogramError as exception:
+        _logger.error(exception)
+        try:
+            await cq.answer()
+        except AiogramError as exception:
+            _logger.error(exception)

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

@@ -17,13 +17,14 @@ _logger = logging.getLogger(__name__)
     or_f(
         Command(ClientTgBotCommands.start),
         MessageTextTgBotFilter([
+            ClientTgBotCommands.start,
             "начать",
             "старт",
             "привет",
             "запуск",
-            "start",
         ], ignore_case=True)
-    )
+    ),
+
 )
 async def _(
         m: aiogram.types.Message,

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/support.py

@@ -0,0 +1,30 @@
+import logging
+
+import aiogram
+from aiogram import Router
+from aiogram.filters import Command, or_f
+
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.const import ClientTgBotCommands
+from project.tg_bot.filter_.message_text import MessageTextTgBotFilter
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = Router()
+_logger = logging.getLogger(__name__)
+
+
+@tg_bot_router.message(
+    or_f(
+        Command(ClientTgBotCommands.support),
+        MessageTextTgBotFilter([
+            ClientTgBotCommands.support,
+            "поддержка"
+        ], ignore_case=True)
+    )
+)
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await m.answer(text=get_cached_client_tg_bot_blank().support_info())

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/main_router.py

@@ -0,0 +1,36 @@
+from aiogram import Router
+
+from project.tg_bot.router.admin import reinit_sqlalchemy_db, arpakitlib_project_template_info, raise_fake_error, me, \
+    log_file, clear_log_file, set_tg_bot_commands, init_sqlalchemy_db, drop_sqlalchemy_db, kb_with_remove_message, \
+    kb_with_old_cd, kb_with_raise_error, kb_with_not_modified
+from project.tg_bot.router.client import remove_message, start, about, healthcheck, hello_world, \
+    support, error_handler, raw_callback_query, raw_message, raw_inline_query
+
+main_tg_bot_router = Router()
+
+# admin
+main_tg_bot_router.include_router(router=reinit_sqlalchemy_db.tg_bot_router)
+main_tg_bot_router.include_router(router=arpakitlib_project_template_info.tg_bot_router)
+main_tg_bot_router.include_router(router=raise_fake_error.tg_bot_router)
+main_tg_bot_router.include_router(router=me.tg_bot_router)
+main_tg_bot_router.include_router(router=log_file.tg_bot_router)
+main_tg_bot_router.include_router(router=clear_log_file.tg_bot_router)
+main_tg_bot_router.include_router(router=set_tg_bot_commands.tg_bot_router)
+main_tg_bot_router.include_router(router=init_sqlalchemy_db.tg_bot_router)
+main_tg_bot_router.include_router(router=drop_sqlalchemy_db.tg_bot_router)
+main_tg_bot_router.include_router(router=kb_with_remove_message.tg_bot_router)
+main_tg_bot_router.include_router(router=kb_with_old_cd.tg_bot_router)
+main_tg_bot_router.include_router(router=kb_with_raise_error.tg_bot_router)
+main_tg_bot_router.include_router(router=kb_with_not_modified.tg_bot_router)
+
+# client
+main_tg_bot_router.include_router(router=error_handler.tg_bot_router)
+main_tg_bot_router.include_router(router=remove_message.tg_bot_router)
+main_tg_bot_router.include_router(router=start.tg_bot_router)
+main_tg_bot_router.include_router(router=about.tg_bot_router)
+main_tg_bot_router.include_router(router=healthcheck.tg_bot_router)
+main_tg_bot_router.include_router(router=hello_world.tg_bot_router)
+main_tg_bot_router.include_router(router=support.tg_bot_router)
+main_tg_bot_router.include_router(router=raw_message.tg_bot_router)
+main_tg_bot_router.include_router(router=raw_inline_query.tg_bot_router)
+main_tg_bot_router.include_router(router=raw_callback_query.tg_bot_router)

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/util/notify_admins.py

@@ -0,0 +1,58 @@
+import asyncio
+import logging
+
+import sqlalchemy
+from aiogram.exceptions import AiogramError
+from emoji import emojize
+
+from arpakitlib.ar_str_util import remove_tags_and_html
+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
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+from project.tg_bot.tg_bot import get_cached_tg_bot
+
+_logger = logging.getLogger(__name__)
+
+
+async def notify_admins(text: str):
+    text = emojize(text.strip())
+
+    admin_tg_ids = set()
+
+    if get_cached_sqlalchemy_db() is not None:
+        async with get_cached_sqlalchemy_db().new_async_session() as async_session:
+            admin_user_dbms: list[UserDBM] = (await async_session.scalars(
+                sqlalchemy.select(UserDBM).filter(UserDBM.roles.any(UserDBM.Roles.admin))
+            )).all()
+        for admin_user_dbm in admin_user_dbms:
+            admin_tg_ids.add(admin_user_dbm.tg_id)
+
+    for tg_id in get_cached_settings().tg_bot_admin_tg_ids:
+        admin_tg_ids.add(tg_id)
+
+    for admin_tg_id in admin_tg_ids:
+        try:
+            await get_cached_tg_bot().send_message(
+                chat_id=admin_tg_id,
+                text=text
+            )
+        except AiogramError as exception:
+            _logger.error(exception)
+            try:
+                await get_cached_tg_bot().send_message(
+                    chat_id=admin_tg_id,
+                    text=remove_tags_and_html(text)
+                )
+            except AiogramError as exception:
+                _logger.error(exception)
+
+
+async def __async_example():
+    setup_logging()
+    await notify_admins("Hello world")
+    await get_cached_tg_bot().session.close()
+
+
+if __name__ == '__main__':
+    asyncio.run(__async_example())

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/tg_bot/util/set_tg_bot_commands.py

@@ -4,6 +4,7 @@ import logging
 from aiogram.types import BotCommand, BotCommandScopeChat
 
 from arpakitlib.ar_str_util import return_str_if_none
+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
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
@@ -29,6 +30,13 @@ def get_client_tg_bot_commands_to_set() -> list[BotCommand]:
                 get_cached_client_tg_bot_blank().command_to_desc().get(ClientTgBotCommands.about),
                 ClientTgBotCommands.about
             )
+        ),
+        BotCommand(
+            command=ClientTgBotCommands.support,
+            description=return_str_if_none(
+                get_cached_client_tg_bot_blank().command_to_desc().get(ClientTgBotCommands.support),
+                ClientTgBotCommands.support
+            )
         )
     ]
     return res
@@ -53,18 +61,32 @@ async def set_client_tg_bot_commands():
 async def set_admin_tg_bot_commands():
     _logger.info(f"start")
 
-    with get_cached_sqlalchemy_db().new_session() as session:
-        user_dbms: list[UserDBM] = session.query(UserDBM).filter(UserDBM.roles.any(UserDBM.Roles.admin)).all()
+    user_tg_ids = set()
+    for tg_bot_admin_tg_id in get_cached_settings().tg_bot_admin_tg_ids:
+        user_tg_ids.add(tg_bot_admin_tg_id)
+
+    if get_cached_sqlalchemy_db() is not None:
+        with get_cached_sqlalchemy_db().new_session() as session:
+            user_dbms: list[UserDBM] = session.query(UserDBM).filter(UserDBM.roles.any(UserDBM.Roles.admin)).all()
+            for user_dbm in user_dbms:
+                user_tg_ids.add(user_dbm.tg_id)
 
-    for user_dbm in user_dbms:
+    for user_tg_id in user_tg_ids:
         await get_cached_tg_bot().set_my_commands(
             commands=get_client_tg_bot_commands_to_set() + get_admin_tg_bot_commands_to_set(),
-            scope=BotCommandScopeChat(chat_id=user_dbm.tg_id)
+            scope=BotCommandScopeChat(chat_id=user_tg_id)
         )
 
     _logger.info("finish")
 
 
+async def set_all_tg_bot_commands():
+    _logger.info(f"start")
+    await set_client_tg_bot_commands()
+    await set_admin_tg_bot_commands()
+    _logger.info("finish")
+
+
 async def __async_example():
     setup_logging()
     await set_client_tg_bot_commands()

arpakitlib/ar_base_worker_util.py

@@ -11,7 +11,7 @@ from typing import Any
 from uuid import uuid4
 
 from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_func_util import is_async_callable, is_sync_function, is_async_object
+from arpakitlib.ar_func_util import is_async_func, is_sync_func, is_coroutine
 from arpakitlib.ar_sleep_util import sync_safe_sleep, async_safe_sleep
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
@@ -48,14 +48,14 @@ class BaseWorker(ABC):
     def sync_run_startup_funcs(self):
         self._logger.info("start")
         for startup_func in self.startup_funcs:
-            if is_async_callable(startup_func):
+            if is_async_func(startup_func):
                 asyncio.run(startup_func())
-            elif is_async_object(startup_func):
+            elif is_coroutine(startup_func):
                 async def __func():
                     await startup_func
 
                 asyncio.run(__func())
-            elif is_sync_function(startup_func):
+            elif is_sync_func(startup_func):
                 startup_func()
             else:
                 raise TypeError("unknown startup_func type")
@@ -93,11 +93,11 @@ class BaseWorker(ABC):
     async def async_run_startup_funcs(self):
         self._logger.info("start")
         for startup_func in self.startup_funcs:
-            if is_async_callable(startup_func):
+            if is_async_func(startup_func):
                 await startup_func()
-            elif is_async_object(startup_func):
+            elif is_coroutine(startup_func):
                 await startup_func
-            elif is_sync_function(startup_func):
+            elif is_sync_func(startup_func):
                 startup_func()
             else:
                 raise TypeError("unknown startup_func type")

arpakitlib/ar_blank_util.py

@@ -4,5 +4,5 @@ _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
 class BaseBlank:
-    def __init__(self, **kwargs):
-        pass
+    def __init__(self, lang: str = "ru", **kwargs):
+        self.lang = lang

arpakitlib/ar_func_util.py

@@ -5,36 +5,43 @@ from typing import Callable
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-def is_async_callable(obj: Callable) -> bool:
-    if inspect.ismethod(obj) or inspect.isfunction(obj):
-        return inspect.iscoroutinefunction(obj)
-    if isinstance(obj, (staticmethod, classmethod)):
-        return inspect.iscoroutinefunction(obj.__func__)
+def is_async_func(func: Callable) -> bool:
+    if inspect.ismethod(func) or inspect.isfunction(func):
+        return inspect.iscoroutinefunction(func)
+    if isinstance(func, (staticmethod, classmethod)):
+        return inspect.iscoroutinefunction(func.__func__)
     return False
 
 
-def raise_if_not_async_callable(obj: Callable):
-    if not is_async_callable(obj):
-        raise TypeError(f"The provided callable '{obj.__name__}' is not an async")
+def raise_if_not_async_func(func: Callable):
+    if not is_async_func(func):
+        raise TypeError(f"the provided callable '{func.__name__}' is not an async")
 
 
 # ---
 
 
-def is_async_object(obj: object) -> bool:
+def is_coroutine(obj: object) -> bool:
     return asyncio.iscoroutine(obj)
 
 
 # ---
 
 
-def is_sync_function(obj: Callable) -> bool:
-    return callable(obj) and not is_async_callable(obj=obj)
+def is_sync_func(func: Callable) -> bool:
+    return callable(func) and not is_async_func(func=func)
 
 
-def raise_if_not_sync_callable(obj: Callable):
-    if not is_sync_function(obj):
-        raise TypeError(f"The provided callable '{obj.__name__}' is not an sync")
+def raise_if_not_sync_func(func: Callable):
+    if not is_sync_func(func):
+        raise TypeError(f"the provided callable '{func.__name__}' is not an sync")
+
+
+#
+
+
+def get_func_name(func: Callable) -> str:
+    return func.__name__
 
 
 def __example():

arpakitlib/ar_logging_util.py

@@ -33,8 +33,8 @@ def setup_normal_logging(log_filepath: Optional[str] = None):
     stream_handler = logging.StreamHandler()
     stream_handler.setLevel(logging.INFO)
     stream_formatter = logging.Formatter(
-        "%(asctime)s | %(levelname)s | %(filename)s | %(funcName)s:%(lineno)d - %(message)s",
-        datefmt="%d.%m.%Y %I:%M:%S%p"
+        "%(asctime)s %(msecs)03d | %(levelname)s | %(filename)s | %(funcName)s:%(lineno)d - %(message)s",
+        datefmt="%d.%m.%Y %I:%M:%S %p"
     )
     stream_handler.setFormatter(stream_formatter)
     logger.addHandler(stream_handler)

arpakitlib/ar_sqlalchemy_util.py

@@ -189,16 +189,22 @@ class SQLAlchemyDb:
 
     def init(self):
         self.base_dbm.metadata.create_all(bind=self.engine, checkfirst=True)
-        self._logger.info("db was inited")
+        self._logger.info("inited")
 
     def drop(self):
         self.base_dbm.metadata.drop_all(bind=self.engine, checkfirst=True)
-        self._logger.info("db was dropped")
+        self._logger.info("dropped")
 
     def reinit(self):
         self.base_dbm.metadata.drop_all(bind=self.engine, checkfirst=True)
         self.base_dbm.metadata.create_all(bind=self.engine, checkfirst=True)
-        self._logger.info("db was reinited")
+        self._logger.info("reinited")
+
+    def reinit_all(self):
+        self.reinit()
+        self.remove_alembic_tables_data()
+        self.remove_celery_tables_data()
+        self._logger.info("all reinited")
 
     def check_conn(self):
         self.engine.connect()

{arpakitlib-1.8.17.dist-info → arpakitlib-1.8.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arpakitlib
-Version: 1.8.17
+Version: 1.8.19
 Summary: arpakitlib
 License: Apache-2.0
 Keywords: arpakitlib,arpakit,arpakit-company,arpakitcompany,arpakit_company