arpakitlib 1.8.14__py3-none-any.whl → 1.8.16__py3-none-any.whl

arpakitlib/_arpakit_project_template_v_4/project/sqlalchemy_db_/sqlalchemy_model/user.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import TYPE_CHECKING, Any
+
+import sqlalchemy
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_type_util import raise_for_type
+from project.sqlalchemy_db_.sqlalchemy_model.common import SimpleDBM
+
+if TYPE_CHECKING:
+    from project.sqlalchemy_db_.sqlalchemy_model.user_token import UserTokenDBM
+
+
+class UserDBM(SimpleDBM):
+    __tablename__ = "user"
+
+    class Roles(Enumeration):
+        admin = "admin"
+        client = "client"
+
+    mail: Mapped[str] = mapped_column(
+        sqlalchemy.TEXT,
+        index=True,
+        insert_default=None,
+        nullable=True
+    )
+    roles: Mapped[list[str]] = mapped_column(
+        sqlalchemy.ARRAY(sqlalchemy.TEXT),
+        insert_default=[Roles.client],
+        index=True,
+        nullable=False
+    )
+    is_enabled: Mapped[bool] = mapped_column(
+        sqlalchemy.Boolean,
+        index=True,
+        insert_default=True,
+        server_default="true",
+        nullable=False
+    )
+    tg_id: Mapped[int | None] = mapped_column(
+        sqlalchemy.BIGINT,
+        unique=True,
+        nullable=True
+    )
+    tg_bot_last_action_dt: Mapped[dt.datetime | None] = mapped_column(
+        sqlalchemy.TIMESTAMP(timezone=True),
+        insert_default=None,
+        nullable=True
+    )
+    tg_data: Mapped[dict[str, Any] | None] = mapped_column(
+        sqlalchemy.JSON,
+        insert_default={},
+        server_default="{}",
+        nullable=True
+    )
+
+    user_tokens: Mapped[list[UserTokenDBM]] = relationship(
+        "UserTokenDBM",
+        uselist=True,
+        back_populates="user",
+        foreign_keys="UserTokenDBM.user_id"
+    )
+
+    @property
+    def roles_has_admin(self) -> bool:
+        return self.Roles.admin in self.roles
+
+    @property
+    def sdp_roles_has_admin(self) -> bool:
+        return self.roles_has_admin
+
+    @property
+    def roles_has_client(self) -> bool:
+        return self.Roles.client in self.roles
+
+    @property
+    def sdp_roles_has_client(self) -> bool:
+        return self.roles_has_client
+
+    def compare_roles(self, roles: list[str] | str) -> bool:
+        if isinstance(roles, str):
+            roles = [roles]
+        raise_for_type(roles, list)
+        return bool(set(roles) & set(self.roles))

arpakitlib/_arpakit_project_template_v_4/project/sqlalchemy_db_/sqlalchemy_model/user_token.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import sqlalchemy
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from project.sqlalchemy_db_.sqlalchemy_model.common import SimpleDBM
+
+if TYPE_CHECKING:
+    from project.sqlalchemy_db_.sqlalchemy_model.user import UserDBM
+
+
+class UserTokenDBM(SimpleDBM):
+    __tablename__ = "user_token"
+
+    value: Mapped[str] = mapped_column(
+        sqlalchemy.TEXT,
+        index=True,
+        nullable=False
+    )
+    user_id: Mapped[int] = mapped_column(
+        sqlalchemy.INTEGER,
+        sqlalchemy.ForeignKey("user.id", ondelete="CASCADE"),
+        index=True,
+        nullable=False
+    )
+    is_enabled: Mapped[bool] = mapped_column(
+        sqlalchemy.Boolean,
+        index=True,
+        insert_default=True,
+        server_default="true",
+        nullable=False
+    )
+
+    user: Mapped[UserDBM] = relationship(
+        "UserDBM",
+        uselist=False,
+        back_populates="user_tokens",
+        foreign_keys=[user_id]
+    )

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

@@ -0,0 +1,45 @@
+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)
+        return emojize(res.strip())
+
+    def user_dbm(self, *, user_dbm: UserDBM | None) -> str:
+        if user_dbm is None:
+            return "None"
+        return user_dbm.simple_dict_json(include_sd_properties=True)
+
+
+def create_admin_tg_bot_blank() -> AdminTgBotBlank:
+    return AdminTgBotBlank()
+
+
+@lru_cache()
+def get_cached_admin_tg_bot_blank() -> AdminTgBotBlank:
+    return AdminTgBotBlank()
+
+
+def __example():
+    print(
+        get_cached_admin_tg_bot_blank().arpakit_project_template_info(
+            arpakitlib_project_template_info=get_arpakitlib_project_template_info()
+        )
+    )
+
+
+if __name__ == '__main__':
+    __example()

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

@@ -0,0 +1,44 @@
+from functools import lru_cache
+
+from emoji import emojize
+
+from project.tg_bot.blank.common import SimpleBlankTgBot
+
+
+class ClientTgBotBlank(SimpleBlankTgBot):
+
+    def command_to_desc(self) -> dict[str, str]:
+        return {}
+
+    def but_hello_world(self) -> str:
+        res = "hello_world"
+        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 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/project/tg_bot/blank/common.py

@@ -0,0 +1,5 @@
+from arpakitlib.ar_blank_util import BaseBlank
+
+
+class SimpleBlankTgBot(BaseBlank):
+    pass

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

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

arpakitlib/{_arpakit_project_template_v_2/project/tg_bot/kb/inline_/callback.py → _arpakit_project_template_v_4/project/tg_bot/callback/common.py}

@@ -1,13 +1,13 @@
 from aiogram.filters.callback_data import CallbackData
 
-_used_cd_prefixes = set()
+_USED_CD_PREFIXES = set()
 
 
 def get_used_cd_prefixes() -> set[str]:
-    return _used_cd_prefixes
+    return _USED_CD_PREFIXES
 
 
-def generate_callback_data_prefix(string: str) -> str:
+def generate_tg_bot_callback_data_prefix(string: str) -> str:
     res = 0
     for s_ in string:
         res += ord(s_)
@@ -23,12 +23,12 @@ class BaseCD(CallbackData, prefix="BaseCD"):
             raise ValueError("callback data class should ends with CD")
 
         if "prefix" not in kwargs:
-            kwargs["prefix"] = str(generate_callback_data_prefix(cls.__name__.lower().removesuffix("cd")))
+            kwargs["prefix"] = str(generate_tg_bot_callback_data_prefix(cls.__name__.lower().removesuffix("cd")))
         prefix = kwargs["prefix"]
 
-        if prefix in _used_cd_prefixes:
-            raise ValueError(f"prefix({prefix}) already in _used_cd_prefixes({_used_cd_prefixes})")
-        _used_cd_prefixes.add(prefix)
+        if prefix in _USED_CD_PREFIXES:
+            raise ValueError(f"prefix({prefix}) already in _used_cd_prefixes({_USED_CD_PREFIXES})")
+        _USED_CD_PREFIXES.add(prefix)
 
         super().__init_subclass__(**kwargs)
 

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/tg_bot/const.py

@@ -1,22 +1,38 @@
 from arpakitlib.ar_enumeration_util import Enumeration
 
 
-class TgBotCommands(Enumeration):
-    # public
-    healthcheck = "healthcheck"
-    arpakitlib_project_template_info = "arpakitlib_project_template_info"
+class ClientTgBotCommands(Enumeration):
     start = "start"
     about = "about"
+    healthcheck = "healthcheck"
+    hello_world = "hello_world"
 
-    # private
+
+class AdminTgBotCommands(Enumeration):
+    arpakitlib_project_template_info = "arpakitlib_project_template_info"
     init_db = "init_db"
-    reinit_db = "reinit_db"
+    reinit_sqlalchemy_db = "reinit_sqlalchemy_db"
     drop_db = "drop_db"
     set_tg_bot_commands = "set_tg_bot_commands"
     raise_fake_err = "raise_fake_err"
+    me = "me"
     log_file = "log_file"
     clear_log_file = "clear_log_file"
     kb_with_old_data = "kb_with_old_data"
     kb_with_not_modified = "kb_with_not_modified"
     kb_with_fake_error = "kb_with_fake_error"
     kb_with_remove_message = "kb_with_remove_message"
+
+
+def __example():
+    print("ClientCommandsTgBot:")
+    for v in ClientTgBotCommands.values_list():
+        print(f"- {v}")
+    print()
+    print("AdminCommandsTgBot:")
+    for v in AdminTgBotCommands.values_list():
+        print(f"- {v}")
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/error_handler.py

@@ -0,0 +1,37 @@
+import logging
+
+import aiogram
+from aiogram import Router
+
+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.middleware.common import MiddlewareDataTgBot
+
+_logger = logging.getLogger(__name__)
+
+tg_bot_router = Router()
+
+
+@tg_bot_router.error()
+async def _(
+        event: aiogram.types.ErrorEvent,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    _logger.exception(event.exception)
+
+    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(event.exception)}",
+                data={
+                    "exception_str": str(event.exception),
+                    "exception_traceback_str": exception_to_traceback_str(exception=event.exception)
+                }
+            )
+        session.add(story_log_dbm)
+        await session.commit()
+        await session.refresh(story_log_dbm)

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/tg_bot/event.py

@@ -12,11 +12,15 @@ from project.json_db.json_db import get_cached_json_db
 from project.operation_execution.operation_executor_worker import create_operation_executor_worker
 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
 
 _logger = logging.getLogger(__name__)
 
 
-async def on_startup():
+# TG BOT STARTUP EVENTS
+
+
+async def startup_tg_bot_event():
     _logger.info("start")
 
     if get_cached_media_file_storage_in_dir() is not None:
@@ -30,23 +34,39 @@ async def on_startup():
 
     if (
             get_cached_sqlalchemy_db() is not None
-            and get_cached_settings().api_init_sqlalchemy_db
+            and get_cached_settings().tg_bot_init_sqlalchemy_db
     ):
         get_cached_sqlalchemy_db().init()
 
     if (
             get_cached_json_db() is not None
-            and get_cached_settings().api_init_json_db
+            and get_cached_settings().tg_bot_init_json_db
     ):
         get_cached_json_db().init()
 
-    if get_cached_settings().api_start_operation_executor_worker:
+    if get_cached_settings().tg_bot_drop_pending_updates:
+        await get_cached_tg_bot().delete_webhook(drop_pending_updates=True)
+
+    if get_cached_settings().tg_bot_webhook_enabled:
+        await get_cached_tg_bot().delete_webhook(drop_pending_updates=True)
+        await get_cached_tg_bot().set_webhook(
+            (
+                f"{get_cached_settings().tg_bot_webhook_url.removesuffix('/')}"
+                f"/"
+                f"{get_cached_settings().tg_bot_webhook_path.removeprefix('/')}"
+            ),
+            secret_token=get_cached_settings().tg_bot_webhook_secret,
+            drop_pending_updates=True,
+            allowed_updates=[]
+        )
+
+    if get_cached_settings().tg_bot_start_operation_executor_worker:
         _ = safe_run_worker_in_background(
             worker=create_operation_executor_worker(),
             mode=SafeRunInBackgroundModes.thread
         )
 
-    if get_cached_settings().api_start_scheduled_operation_creator_worker:
+    if get_cached_settings().tg_bot_start_scheduled_operation_creator_worker:
         _ = safe_run_worker_in_background(
             worker=create_scheduled_operation_creator_worker(),
             mode=SafeRunInBackgroundModes.async_task
@@ -55,23 +75,33 @@ async def on_startup():
     _logger.info("finish")
 
 
-async def on_shutdown(*args, **kwargs):
+def get_startup_tg_bot_events() -> list[Callable]:
+    res = [startup_tg_bot_event]
+    return res
+
+
+# TG BOT SHUTDOWN EVENTS
+
+
+async def shutdown_tg_bot_event(*args, **kwargs):
     _logger.info("start")
+
+    if get_cached_settings().tg_bot_webhook_enabled:
+        await get_cached_tg_bot().delete_webhook(drop_pending_updates=True)
+
     _logger.info("finish")
 
 
-def get_tg_bot_startup_events() -> list[Callable]:
-    res = [on_startup]
+def get_shutdown_tg_bot_events() -> list[Callable]:
+    res = [shutdown_tg_bot_event]
     return res
 
 
-def get_tg_bot_shutdown_events() -> list[Callable]:
-    res = [on_shutdown]
-    return res
+#
 
 
 def add_events_to_tg_bot_dispatcher(*, tg_bot_dispatcher: Dispatcher):
-    for tg_bot_event in get_tg_bot_startup_events():
+    for tg_bot_event in get_startup_tg_bot_events():
         tg_bot_dispatcher.startup.register(tg_bot_event)
-    for tg_bot_event in get_tg_bot_shutdown_events():
+    for tg_bot_event in get_shutdown_tg_bot_events():
         tg_bot_dispatcher.shutdown.register(tg_bot_event)

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/filter_/is_private_chat.py

@@ -0,0 +1,12 @@
+import aiogram.types
+from aiogram.filters import Filter
+
+
+class IsPrivateChatTgBotFilter(Filter):
+    async def __call__(self, update: aiogram.types.Message | aiogram.types.CallbackQuery) -> bool:
+        if isinstance(update, aiogram.types.Message):
+            return update.chat.type == aiogram.enums.ChatType.PRIVATE
+        elif isinstance(update, aiogram.types.CallbackQuery):
+            return update.message.chat.type == aiogram.enums.ChatType.PRIVATE
+        else:
+            return False

arpakitlib/{_arpakit_project_template_v_2/project/tg_bot/filter_.py → _arpakit_project_template_v_4/project/tg_bot/filter_/message_text.py}

@@ -4,20 +4,9 @@ import aiogram.types
 from aiogram.filters import Filter
 
 from arpakitlib.ar_type_util import raise_for_type
-from project.core.settings import get_cached_settings
 
 
-class NotProdModeFilterTgBotFilter(Filter):
-    async def __call__(self, *args, **kwargs) -> bool:
-        return get_cached_settings().is_mode_type_not_prod
-
-
-class ProdModeFilterTgBotFilter(Filter):
-    async def __call__(self, *args, **kwargs) -> bool:
-        return get_cached_settings().is_mode_type_prod
-
-
-class TextFilterTgBotFilter(Filter):
+class MessageTextTgBotFilter(Filter):
 
     def __init__(
             self,
@@ -57,13 +46,3 @@ class TextFilterTgBotFilter(Filter):
             text = text.lower()
 
         return text in self.texts
-
-
-class IsPrivateChatTgBotFilter(Filter):
-    async def __call__(self, update: aiogram.types.Message | aiogram.types.CallbackQuery) -> bool:
-        if isinstance(update, aiogram.types.Message):
-            return update.chat.type == aiogram.enums.ChatType.PRIVATE
-        elif isinstance(update, aiogram.types.CallbackQuery):
-            return update.message.chat.type == aiogram.enums.ChatType.PRIVATE
-        else:
-            return False

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/filter_/not_prod_mode_filter.py

@@ -0,0 +1,8 @@
+from aiogram.filters import Filter
+
+from project.core.settings import get_cached_settings
+
+
+class NotProdModeTgBotFilter(Filter):
+    async def __call__(self, *args, **kwargs) -> bool:
+        return not get_cached_settings().prod_mode

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/filter_/prod_mode_filter.py

@@ -0,0 +1,8 @@
+from aiogram.filters import Filter
+
+from project.core.settings import get_cached_settings
+
+
+class ProdModeTgBotFilter(Filter):
+    async def __call__(self, *args, **kwargs) -> bool:
+        return get_cached_settings().is_mode_type_prod

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

@@ -0,0 +1,27 @@
+import aiogram.types
+from aiogram.filters import Filter
+
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+
+
+class UserRolesHasAdminTgBotFilter(Filter):
+
+    async def __call__(
+            self, update: aiogram.types.Message | aiogram.types.CallbackQuery | aiogram.types.TelegramObject, **kwargs
+    ) -> bool:
+        tg_user: None | aiogram.types.User = None
+
+        if isinstance(update, aiogram.types.Message) and update.from_user is not None:
+            tg_user = update.from_user
+        if isinstance(update, aiogram.types.CallbackQuery) and update.from_user is not None:
+            tg_user = update.from_user
+
+        if get_cached_sqlalchemy_db() is not None and tg_user is not None:
+            with get_cached_sqlalchemy_db().new_session() as session:
+                user_dbm: UserDBM | None = session.query(UserDBM).filter(UserDBM.tg_id == tg_user.id).one_or_none()
+            if user_dbm is not None:
+                if user_dbm.roles_has_admin:
+                    return True
+
+        return False

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

@@ -0,0 +1,27 @@
+import aiogram.types
+from aiogram.filters import Filter
+
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+
+
+class UserRolesHasClientTgBotFilter(Filter):
+
+    async def __call__(
+            self, update: aiogram.types.Message | aiogram.types.CallbackQuery | aiogram.types.TelegramObject, **kwargs
+    ) -> bool:
+        tg_user: None | aiogram.types.User = None
+
+        if isinstance(update, aiogram.types.Message) and update.from_user is not None:
+            tg_user = update.from_user
+        if isinstance(update, aiogram.types.CallbackQuery) and update.from_user is not None:
+            tg_user = update.from_user
+
+        if get_cached_sqlalchemy_db() is not None and tg_user is not None:
+            with get_cached_sqlalchemy_db().new_session() as session:
+                user_dbm: UserDBM | None = session.query(UserDBM).filter(UserDBM.tg_id == tg_user.id).one_or_none()
+            if user_dbm is not None:
+                if user_dbm.roles_has_client:
+                    return True
+
+        return False

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/kb/inline_/client/hello_world.py

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

arpakitlib/{_arpakit_project_template_v_2/project/tg_bot/kb/static_/common.py → _arpakit_project_template_v_4/project/tg_bot/kb/static_/client/hello_world.py}

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