telegrinder 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

telegrinder/__init__.py

@@ -7,6 +7,7 @@ Modern visionary telegram bot framework.
 * Ready to use scenarios and rules
 * Fast models built on msgspec
 * Both low-level and high-level API
+* Support [optional dependecies](https://github.com/timoniq/telegrinder/blob/dev/docs/guide/optional_dependencies.md)
 
 Basic example:
 
@@ -23,9 +24,7 @@ logger.set_level("INFO")
 @bot.on.message(Text("/start"))
 async def start(message: Message):
     me = (await api.get_me()).unwrap()
-    await message.answer(
-        f"Hello, {message.from_user.full_name}! I'm {me.full_name}."
-    )
+    await message.answer(f"Hello, {message.from_user.full_name}! I'm {me.full_name}.")
 
 
 bot.run_forever()
@@ -45,6 +44,7 @@ from .bot import (
     ABCScenario,
     ABCStateView,
     ABCView,
+    AudioReplyHandler,
     BaseCute,
     BaseReturnManager,
     BaseStateView,
@@ -60,21 +60,27 @@ from .bot import (
     ChatMemberView,
     Checkbox,
     Choice,
+    Context,
     Dispatch,
+    DocumentReplyHandler,
     FuncHandler,
     InlineQueryCute,
     InlineQueryReturnManager,
     InlineQueryRule,
+    MediaGroupReplyHandler,
     MessageCute,
     MessageReplyHandler,
     MessageReturnManager,
     MessageRule,
     MessageView,
+    PhotoReplyHandler,
     Polling,
     RawEventView,
     ShortState,
+    StickerReplyHandler,
     Telegrinder,
     UpdateCute,
+    VideoReplyHandler,
     ViewBox,
     WaiterMachine,
     register_manager,
@@ -126,7 +132,6 @@ Bot: typing.TypeAlias = Telegrinder
 
 
 __all__ = (
-    "API",
     "ABCClient",
     "ABCDispatch",
     "ABCErrorHandler",
@@ -138,6 +143,7 @@ __all__ = (
     "ABCReturnManager",
     "ABCRule",
     "ABCScenario",
+    "ABCStateStorage",
     "ABCStateView",
     "ABCTranslator",
     "ABCTranslatorMiddleware",
@@ -156,17 +162,17 @@ __all__ = (
     "CallbackQuery",
     "CallbackQueryCute",
     "CallbackQueryReturnManager",
+    "CallbackQueryRule",
     "CallbackQueryView",
     "ChatJoinRequest",
     "ChatJoinRequestCute",
-    "CallbackQueryRule",
     "ChatJoinRequestRule",
-    "InlineQueryRule",
     "ChatJoinRequestView",
     "ChatMemberUpdated",
     "ChatMemberUpdatedCute",
     "ChatMemberView",
     "Checkbox",
+    "Choice",
     "CtxVar",
     "DelayedTask",
     "Dispatch",
@@ -181,38 +187,43 @@ __all__ = (
     "InlineQuery",
     "InlineQueryCute",
     "InlineQueryReturnManager",
+    "InlineQueryRule",
     "Keyboard",
     "KeyboardSetBase",
     "KeyboardSetYAML",
     "Lifespan",
     "LoopWrapper",
+    "MediaGroupReplyHandler",
+    "MemoryStateStorage",
     "Message",
     "MessageCute",
     "MessageReplyHandler",
+    "MessageReplyHandler",
     "MessageReturnManager",
     "MessageRule",
     "MessageView",
     "Model",
     "ParseMode",
+    "PhotoReplyHandler",
     "Polling",
     "RawEventView",
     "RowButtons",
     "ShortState",
     "SimpleI18n",
     "SimpleTranslator",
-    "Choice",
+    "StateData",
+    "StateMeta",
+    "StickerReplyHandler",
     "Telegrinder",
     "Token",
     "Update",
     "UpdateCute",
+    "VideoReplyHandler",
     "ViewBox",
     "WaiterMachine",
     "ctx_var",
     "logger",
     "magic_bundle",
     "register_manager",
-    "ABCStateStorage",
-    "MemoryStateStorage",
-    "StateData",
-    "StateMeta",
+    "Context",
 )

telegrinder/bot/__init__.py

@@ -15,6 +15,7 @@ from telegrinder.bot.dispatch import (
     ABCReturnManager,
     ABCStateView,
     ABCView,
+    AudioReplyHandler,
     BaseReturnManager,
     BaseStateView,
     BaseView,
@@ -24,14 +25,19 @@ from telegrinder.bot.dispatch import (
     ChatMemberView,
     Context,
     Dispatch,
+    DocumentReplyHandler,
     FuncHandler,
     InlineQueryReturnManager,
     Manager,
+    MediaGroupReplyHandler,
     MessageReplyHandler,
     MessageReturnManager,
     MessageView,
+    PhotoReplyHandler,
     RawEventView,
     ShortState,
+    StickerReplyHandler,
+    VideoReplyHandler,
     ViewBox,
     WaiterMachine,
     clear_wm_storage_worker,
@@ -57,6 +63,7 @@ __all__ = (
     "ABCScenario",
     "ABCStateView",
     "ABCView",
+    "AudioReplyHandler",
     "BaseCute",
     "BaseReturnManager",
     "BaseStateView",
@@ -65,32 +72,37 @@ __all__ = (
     "CallbackQueryReturnManager",
     "CallbackQueryRule",
     "CallbackQueryView",
-    "ChatJoinRequestRule",
-    "InlineQueryRule",
     "ChatJoinRequestCute",
+    "ChatJoinRequestRule",
     "ChatJoinRequestView",
     "ChatMemberUpdatedCute",
     "ChatMemberView",
     "Checkbox",
+    "Choice",
     "Context",
     "Dispatch",
+    "DocumentReplyHandler",
     "FuncHandler",
     "InlineQueryCute",
     "InlineQueryReturnManager",
+    "InlineQueryRule",
     "Manager",
+    "MediaGroupReplyHandler",
     "MessageCute",
     "MessageReplyHandler",
     "MessageReturnManager",
     "MessageRule",
     "MessageView",
+    "PhotoReplyHandler",
     "Polling",
     "RawEventView",
     "ShortState",
-    "Choice",
+    "StickerReplyHandler",
     "Telegrinder",
     "UpdateCute",
+    "VideoReplyHandler",
     "ViewBox",
     "WaiterMachine",
-    "register_manager",
     "clear_wm_storage_worker",
+    "register_manager",
 )

telegrinder/bot/cute_types/chat_member_updated.py

@@ -245,6 +245,6 @@ class ChatMemberUpdatedCute(
 
 
 __all__ = (
-    "ChatMemberUpdatedCute",
     "ChatMemberShortcuts",
+    "ChatMemberUpdatedCute",
 )

telegrinder/bot/cute_types/message.py

@@ -42,7 +42,6 @@ if typing.TYPE_CHECKING:
 
     from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
 
-
 MediaType: typing.TypeAlias = typing.Literal[
     "animation",
     "audio",
@@ -50,6 +49,7 @@ MediaType: typing.TypeAlias = typing.Literal[
     "photo",
     "video",
 ]
+InputMediaType: typing.TypeAlias = InputMedia | tuple[MediaType, InputFile | str]
 ReplyMarkup: typing.TypeAlias = InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply
 
 
@@ -1676,14 +1676,14 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     )
     async def answer_media_group(
         self,
-        media: list[InputMedia | tuple[MediaType, InputFile | str]],
+        media: InputMediaType | list[InputMediaType],
         chat_id: int | str | None = None,
         business_connection_id: str | None = None,
         message_thread_id: int | None = None,
         message_effect_id: str | None = None,
-        caption: str | None = None,
-        parse_mode: str | None = None,
-        caption_entities: list[MessageEntity] | None = None,
+        caption: str | list[str] | None = None,
+        parse_mode: str | list[str] | None = None,
+        caption_entities: list[MessageEntity] | list[list[MessageEntity]] | None = None,
         disable_notification: bool | None = None,
         protect_content: bool | None = None,
         reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
@@ -1724,7 +1724,14 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
 
         :param reply_parameters: Description of the message to reply to."""
 
+        media = [media] if not isinstance(media, list) else media
         params = get_params(locals())
+        caption_entities_lst = typing.cast(
+            list[list[MessageEntity]],
+            [caption_entities]
+            if caption_entities and len(caption_entities) == 1 and not isinstance(caption_entities[0], list)
+            else caption_entities,
+        )
 
         for i, m in enumerate(media[:]):
             if isinstance(m, tuple):
@@ -1732,9 +1739,9 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
                     i,
                     input_media(  # type: ignore
                         *media.pop(i),  # type: ignore
-                        caption=caption,
-                        caption_entities=caption_entities,
-                        parse_mode=parse_mode,
+                        caption=caption if not isinstance(caption, list) else caption[i],
+                        caption_entities=caption_entities_lst[i] if caption_entities_lst else None,
+                        parse_mode=parse_mode if not isinstance(parse_mode, list) else parse_mode[i],
                     ),
                 )
 
@@ -2873,13 +2880,13 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     )
     async def reply_media_group(
         self,
-        media: list[InputMedia | tuple[MediaType, InputFile | str]],
+        media: InputMediaType | list[InputMediaType],
         chat_id: int | str | None = None,
         business_connection_id: str | None = None,
         message_thread_id: int | None = None,
         message_effect_id: str | None = None,
-        caption: str | None = None,
-        parse_mode: str | None = None,
+        caption: str | list[str] | None = None,
+        parse_mode: str | list[str] | None = None,
         caption_entities: list[MessageEntity] | None = None,
         disable_notification: bool | None = None,
         protect_content: bool | None = None,

telegrinder/bot/dispatch/__init__.py

@@ -1,7 +1,17 @@
 from telegrinder.bot.dispatch.abc import ABCDispatch
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.dispatch import Dispatch, TelegrinderContext
-from telegrinder.bot.dispatch.handler import ABCHandler, FuncHandler, MessageReplyHandler
+from telegrinder.bot.dispatch.handler import (
+    ABCHandler,
+    AudioReplyHandler,
+    DocumentReplyHandler,
+    FuncHandler,
+    MediaGroupReplyHandler,
+    MessageReplyHandler,
+    PhotoReplyHandler,
+    StickerReplyHandler,
+    VideoReplyHandler,
+)
 from telegrinder.bot.dispatch.middleware import ABCMiddleware
 from telegrinder.bot.dispatch.process import check_rule, process_inner
 from telegrinder.bot.dispatch.return_manager import (
@@ -35,6 +45,7 @@ __all__ = (
     "ABCReturnManager",
     "ABCStateView",
     "ABCView",
+    "AudioReplyHandler",
     "BaseReturnManager",
     "BaseStateView",
     "BaseView",
@@ -44,20 +55,25 @@ __all__ = (
     "ChatMemberView",
     "Context",
     "Dispatch",
+    "DocumentReplyHandler",
     "FuncHandler",
     "InlineQueryReturnManager",
     "InlineQueryView",
     "Manager",
+    "MediaGroupReplyHandler",
     "MessageReplyHandler",
     "MessageReturnManager",
     "MessageView",
+    "PhotoReplyHandler",
     "RawEventView",
     "ShortState",
+    "StickerReplyHandler",
     "TelegrinderContext",
+    "VideoReplyHandler",
     "ViewBox",
     "WaiterMachine",
     "check_rule",
+    "clear_wm_storage_worker",
     "process_inner",
     "register_manager",
-    "clear_wm_storage_worker",
 )

telegrinder/bot/dispatch/abc.py

@@ -1,7 +1,7 @@
 import typing
 from abc import ABC, abstractmethod
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.tools.global_context.abc import ABCGlobalContext
 from telegrinder.types.objects import Update
 

telegrinder/bot/dispatch/context.py

@@ -2,7 +2,7 @@ import enum
 import typing
 from reprlib import recursive_repr
 
-from telegrinder.types import Update
+from telegrinder.types.objects import Update
 
 T = typing.TypeVar("T")
 
@@ -63,7 +63,7 @@ class Context(dict[str, AnyValue]):
         return key if isinstance(key, str) else str(key.value)
 
     def copy(self) -> typing.Self:
-        return self.__class__(**self)
+        return self.__class__(**dict.copy(self))
 
     def set(self, key: Key, value: AnyValue) -> None:
         self[key] = value

telegrinder/bot/dispatch/dispatch.py

@@ -3,7 +3,7 @@ import typing
 
 from vbml.patcher import Patcher
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.abc import ABCDispatch

telegrinder/bot/dispatch/handler/__init__.py

@@ -1,5 +1,21 @@
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.handler.audio_reply import AudioReplyHandler
+from telegrinder.bot.dispatch.handler.document_reply import DocumentReplyHandler
 from telegrinder.bot.dispatch.handler.func import FuncHandler
+from telegrinder.bot.dispatch.handler.media_group_reply import MediaGroupReplyHandler
 from telegrinder.bot.dispatch.handler.message_reply import MessageReplyHandler
+from telegrinder.bot.dispatch.handler.photo_reply import PhotoReplyHandler
+from telegrinder.bot.dispatch.handler.sticker_reply import StickerReplyHandler
+from telegrinder.bot.dispatch.handler.video_reply import VideoReplyHandler
 
-__all__ = ("ABCHandler", "FuncHandler", "MessageReplyHandler")
+__all__ = (
+    "ABCHandler",
+    "AudioReplyHandler",
+    "DocumentReplyHandler",
+    "FuncHandler",
+    "MediaGroupReplyHandler",
+    "MessageReplyHandler",
+    "PhotoReplyHandler",
+    "StickerReplyHandler",
+    "VideoReplyHandler",
+)

telegrinder/bot/dispatch/handler/audio_reply.py

@@ -0,0 +1,44 @@
+import typing
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.objects import InputFile
+
+
+class AudioReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        audio: InputFile | str,
+        *rules: ABCRule,
+        caption: str | None = None,
+        parse_mode: str | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.audio = audio
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_audio if not self.as_reply else event.reply_audio
+        await method(
+            audio=self.audio,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("AudioReplyHandler",)

telegrinder/bot/dispatch/handler/base.py

@@ -0,0 +1,57 @@
+import abc
+import typing
+
+from fntypes.result import Result
+
+from telegrinder.api.api import API
+from telegrinder.api.error import APIError
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.modules import logger
+from telegrinder.types.objects import Update
+
+APIMethod: typing.TypeAlias = typing.Callable[
+    typing.Concatenate[MessageCute, ...], typing.Awaitable[Result[typing.Any, APIError]]
+]
+
+
+class BaseReplyHandler(ABCHandler[MessageCute], abc.ABC):
+    def __init__(
+        self,
+        *rules: ABCRule,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.rules = list(rules)
+        self.as_reply = as_reply
+        self.is_blocking = is_blocking
+        self.default_params = default_params
+        self.preset_context = preset_context or Context()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__qualname__}>"
+
+    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
+        ctx = Context(raw_update=event) if ctx is None else ctx
+        temp_ctx = ctx.copy()
+        temp_ctx |= self.preset_context
+
+        for rule in self.rules:
+            if not await check_rule(api, rule, event, ctx):
+                logger.debug("Rule {!r} failed!", rule)
+                return False
+
+        ctx |= temp_ctx
+        return True
+
+    @abc.abstractmethod
+    async def run(self, api: API, event: MessageCute, ctx: Context) -> typing.Any:
+        pass
+
+
+__all__ = ("BaseReplyHandler",)

telegrinder/bot/dispatch/handler/document_reply.py

@@ -0,0 +1,44 @@
+import typing
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.objects import InputFile
+
+
+class DocumentReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        document: InputFile | str,
+        *rules: ABCRule,
+        caption: str | None = None,
+        parse_mode: str | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.document = document
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_document if not self.as_reply else event.reply_document
+        await method(
+            document=self.document,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("DocumentReplyHandler",)

telegrinder/bot/dispatch/handler/func.py

@@ -3,7 +3,7 @@ from functools import cached_property
 
 import typing_extensions as typing
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types import BaseCute, UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.process import check_rule
@@ -72,7 +72,7 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
         if nodes:
             result = await compose_nodes(nodes, ctx, data={Update: event, API: api})
             if not result:
-                logger.debug(f"Cannot compose nodes for handler. {result.error}")
+                logger.debug(f"Cannot compose nodes for handler. Error: {result.error!r}")
                 return False
 
             node_col = result.value
@@ -95,7 +95,7 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
         return True
 
     async def run(self, api: API, event: Event, ctx: Context) -> typing.Any:
-        logger.debug(f"Running func handler {self.func}")
+        logger.debug(f"Running func handler {self.func.__qualname__!r}")
         dataclass_type = typing.get_origin(self.dataclass) or self.dataclass
 
         if dataclass_type is Update and (event_node := ctx.pop(EVENT_NODE_KEY, None)) is not None:

telegrinder/bot/dispatch/handler/media_group_reply.py

@@ -0,0 +1,43 @@
+import typing
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.message import InputMediaType, MessageCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
+from telegrinder.bot.rules.abc import ABCRule
+
+
+class MediaGroupReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        media: InputMediaType | list[InputMediaType],
+        *rules: ABCRule,
+        caption: str | list[str] | None = None,
+        parse_mode: str | list[str] | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.media = media
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_media_group if not self.as_reply else event.reply_media_group
+        await method(
+            media=self.media,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("MediaGroupReplyHandler",)