telegrinder 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/bot/dispatch/handler/base.py

@@ -1,57 +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",)
+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
+
+type APIMethod = typing.Callable[
+    typing.Concatenate[MessageCute, ...], typing.Awaitable[Result[typing.Any, APIError]]
+]
+
+
+class BaseReplyHandler(ABCHandler[MessageCute], abc.ABC):
+    def __init__(
+        self,
+        *rules: ABCRule,
+        final: 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.final = final
+        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

@@ -1,44 +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",)
+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,
+        final: 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,
+            final=final,
+            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

@@ -1,135 +1,129 @@
-import dataclasses
-from functools import cached_property
-
-import typing_extensions as typing
-
-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
-from telegrinder.model import Model
-from telegrinder.modules import logger
-from telegrinder.node.base import Node, get_nodes
-from telegrinder.node.composer import NodeCollection, compose_nodes
-from telegrinder.node.event import EVENT_NODE_KEY
-from telegrinder.tools.error_handler import ABCErrorHandler, ErrorHandler
-from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Update
-
-from .abc import ABCHandler
-
-if typing.TYPE_CHECKING:
-    from telegrinder.bot.rules.abc import ABCRule
-    from telegrinder.node.composer import NodeCollection
-
-Rest = typing.ParamSpec("Rest")
-Result = typing.TypeVar("Result")
-Function = typing.TypeVar("Function", bound="Func[..., typing.Any]")
-Event = typing.TypeVar("Event", bound=Model)
-ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
-
-Func: typing.TypeAlias = typing.Callable[Rest, typing.Coroutine[typing.Any, typing.Any, Result]]
-
-
-@dataclasses.dataclass(repr=False, slots=True)
-class FuncHandler(ABCHandler[Event], typing.Generic[Event, Function, ErrorHandlerT]):
-    function: Function
-    rules: list["ABCRule"]
-    is_blocking: bool = dataclasses.field(default=True, kw_only=True)
-    dataclass: type[typing.Any] | None = dataclasses.field(default=dict, kw_only=True)
-    error_handler: ErrorHandlerT = dataclasses.field(
-        default_factory=lambda: typing.cast(ErrorHandlerT, ErrorHandler()),
-        kw_only=True,
-    )
-    preset_context: Context = dataclasses.field(default_factory=lambda: Context(), kw_only=True)
-    update_type: UpdateType | None = dataclasses.field(default=None, kw_only=True)
-
-    def __post_init__(self) -> None:
-        self.dataclass = typing.get_origin(self.dataclass) or self.dataclass
-
-    @property
-    def __call__(self) -> Function:
-        return self.function
-
-    def __repr__(self) -> str:
-        return "<{}: {}={!r} with rules={!r}, dataclass={!r}, error_handler={!r}>".format(
-            self.__class__.__name__,
-            "blocking function" if self.is_blocking else "function",
-            self.function.__qualname__,
-            self.rules,
-            self.dataclass,
-            self.error_handler,
-        )
-
-    @cached_property
-    def required_nodes(self) -> dict[str, type[Node]]:
-        return get_nodes(self.function)
-
-    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
-        if self.update_type is not None and self.update_type != event.update_type:
-            return False
-
-        logger.debug("Checking handler {!r}...", self)
-        ctx = Context(raw_update=event) if ctx is None else ctx
-        temp_ctx = ctx.copy()
-        temp_ctx |= self.preset_context
-        update = event
-
-        for rule in self.rules:
-            if not await check_rule(api, rule, update, temp_ctx):
-                logger.debug("Rule {!r} failed!", rule)
-                return False
-
-        nodes = self.required_nodes
-        node_col = None
-        if nodes:
-            result = await compose_nodes(nodes, ctx, data={Update: event, API: api})
-            if not result:
-                logger.debug(f"Cannot compose nodes for handler. Error: {result.error!r}")
-                return False
-
-            node_col = result.value
-            temp_ctx |= node_col.values
-
-            if EVENT_NODE_KEY in ctx:
-                for name, node in nodes.items():
-                    if node is ctx[EVENT_NODE_KEY] and name in temp_ctx:
-                        ctx[name] = temp_ctx.pop(name)
-
-        logger.debug("All checks passed for handler.")
-
-        temp_ctx["node_col"] = node_col
-        ctx |= temp_ctx
-        return True
-
-    async def run(
-        self,
-        api: API,
-        event: Event,
-        ctx: Context,
-        node_col: "NodeCollection | None" = None,
-    ) -> typing.Any:
-        logger.debug(f"Running func handler {self.function.__qualname__!r}")
-
-        if self.dataclass is not None and EVENT_NODE_KEY not in ctx:
-            if self.update_type is not None and isinstance(event, Update):
-                update = getattr(event, event.update_type.value).unwrap()
-                event = (
-                    self.dataclass.from_update(update, bound_api=api)
-                    if issubclass(self.dataclass, BaseCute)
-                    else self.dataclass(**update.to_dict())  # type: ignore
-                )
-
-            elif issubclass(self.dataclass, UpdateCute) and isinstance(event, Update):
-                event = self.dataclass.from_update(event, bound_api=api)
-
-            else:
-                event = self.dataclass(**event.to_dict())  # type: ignore
-
-        result = (await self.error_handler.run(self.function, event, api, ctx)).unwrap()
-        if node_col := ctx.node_col:
-            await node_col.close_all()
-        return result
-
-
-__all__ = ("FuncHandler",)
+import dataclasses
+from functools import cached_property
+
+import typing_extensions as typing
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.modules import logger
+from telegrinder.node.base import NodeType, get_nodes
+from telegrinder.node.composer import NodeCollection, compose_nodes
+from telegrinder.tools.adapter.abc import ABCAdapter
+from telegrinder.tools.adapter.dataclass import DataclassAdapter
+from telegrinder.tools.error_handler import ABCErrorHandler, ErrorHandler
+from telegrinder.tools.magic import get_annotations, magic_bundle
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
+
+from .abc import ABCHandler
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.abc import ABCRule
+    from telegrinder.node.composer import NodeCollection
+
+Function = typing.TypeVar("Function", bound="Func[..., typing.Any]")
+Event = typing.TypeVar("Event")
+ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
+
+type Func[**Rest, Result] = typing.Callable[Rest, typing.Coroutine[typing.Any, typing.Any, Result]]
+
+
+@dataclasses.dataclass(repr=False, slots=True)
+class FuncHandler(ABCHandler[Event], typing.Generic[Event, Function, ErrorHandlerT]):
+    function: Function
+    rules: list["ABCRule"]
+    adapter: ABCAdapter[Update, Event] | None = dataclasses.field(default=None, kw_only=True)
+    final: bool = dataclasses.field(default=True, kw_only=True)
+    dataclass: type[typing.Any] | None = dataclasses.field(default=dict[str, typing.Any], kw_only=True)
+    error_handler: ErrorHandlerT = dataclasses.field(
+        default_factory=lambda: typing.cast(ErrorHandlerT, ErrorHandler()),
+        kw_only=True,
+    )
+    preset_context: Context = dataclasses.field(default_factory=lambda: Context(), kw_only=True)
+    update_type: UpdateType | None = dataclasses.field(default=None, kw_only=True)
+
+    def __post_init__(self) -> None:
+        self.dataclass = typing.get_origin(self.dataclass) or self.dataclass
+
+        if self.dataclass is not None and self.adapter is None:
+            self.adapter = DataclassAdapter(self.dataclass, self.update_type)
+
+    @property
+    def __call__(self) -> Function:
+        return self.function
+
+    def __repr__(self) -> str:
+        return "<{}: {}={!r} with rules={!r}, dataclass={!r}, error_handler={!r}>".format(
+            self.__class__.__name__,
+            "final function" if self.final else "function",
+            self.function.__qualname__,
+            self.rules,
+            self.dataclass,
+            self.error_handler,
+        )
+
+    @cached_property
+    def required_nodes(self) -> dict[str, type[NodeType]]:
+        return get_nodes(self.function)
+
+    def get_name_event_param(self, event: Event) -> str | None:
+        event_class = self.dataclass or event.__class__
+        for k, v in get_annotations(self.function).items():
+            if isinstance(v := typing.get_origin(v) or v, type) and v is event_class:
+                self.func_event_param = k
+                return k
+        return None
+
+    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
+        if self.update_type is not None and self.update_type != event.update_type:
+            return False
+
+        logger.debug("Checking handler {!r}...", self)
+        ctx = Context(raw_update=event) if ctx is None else ctx
+        temp_ctx = ctx.copy()
+        temp_ctx |= self.preset_context.copy()
+        update = event
+
+        for rule in self.rules:
+            if not await check_rule(api, rule, update, temp_ctx):
+                logger.debug("Rule {!r} failed!", rule)
+                return False
+
+        nodes = self.required_nodes
+        node_col = None
+        if nodes:
+            result = await compose_nodes(nodes, ctx, data={Update: update, API: api})
+            if not result:
+                logger.debug(f"Cannot compose nodes for handler, error: {str(result.error)}")
+                return False
+
+            node_col = result.value
+            temp_ctx |= node_col.values
+
+        logger.debug("All checks passed for handler.")
+        temp_ctx["node_col"] = node_col
+        ctx |= temp_ctx
+        return True
+
+    async def run(
+        self,
+        api: API,
+        event: Event,
+        ctx: Context,
+        node_col: "NodeCollection | None" = None,
+    ) -> typing.Any:
+        logger.debug(f"Running handler {self!r}...")
+
+        try:
+            if event_param := self.get_name_event_param(event):
+                ctx = Context(**{event_param: event, **ctx})
+            return await self(**magic_bundle(self.function, ctx, start_idx=0))
+        except BaseException as exception:
+            return await self.error_handler.run(exception, event, api, ctx)
+        finally:
+            if node_col := ctx.node_col:
+                await node_col.close_all()
+
+
+__all__ = ("FuncHandler",)

telegrinder/bot/dispatch/handler/media_group_reply.py

@@ -1,43 +1,44 @@
-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",)
+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 InputMedia
+
+
+class MediaGroupReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        media: InputMedia | list[InputMedia],
+        *rules: ABCRule,
+        caption: str | list[str] | None = None,
+        parse_mode: str | list[str] | None = None,
+        final: 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,
+            final=final,
+            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",)

telegrinder/bot/dispatch/handler/message_reply.py

@@ -1,36 +1,36 @@
-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
-
-
-class MessageReplyHandler(BaseReplyHandler):
-    def __init__(
-        self,
-        text: str,
-        *rules: ABCRule,
-        parse_mode: str | None = None,
-        is_blocking: bool = True,
-        as_reply: bool = False,
-        preset_context: Context | None = None,
-        **default_params: typing.Any,
-    ) -> None:
-        self.text = text
-        self.parse_mode = parse_mode
-        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 if not self.as_reply else event.reply
-        await method(text=self.text, parse_mode=self.parse_mode, **self.default_params)
-
-
-__all__ = ("MessageReplyHandler",)
+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
+
+
+class MessageReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        text: str,
+        *rules: ABCRule,
+        parse_mode: str | None = None,
+        final: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.text = text
+        self.parse_mode = parse_mode
+        super().__init__(
+            *rules,
+            final=final,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer if not self.as_reply else event.reply
+        await method(text=self.text, parse_mode=self.parse_mode, **self.default_params)
+
+
+__all__ = ("MessageReplyHandler",)