telegrinder 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

telegrinder/bot/dispatch/handler/abc.py

@@ -1,24 +1,24 @@
-import typing
-from abc import ABC, abstractmethod
-
-from telegrinder.api import API
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.model import Model
-from telegrinder.types.objects import Update
-
-T = typing.TypeVar("T", bound=Model)
-
-
-class ABCHandler(ABC, typing.Generic[T]):
-    is_blocking: bool
-
-    @abstractmethod
-    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
-        pass
-
-    @abstractmethod
-    async def run(self, api: API, event: T, ctx: Context) -> typing.Any:
-        pass
-
-
-__all__ = ("ABCHandler",)
+import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.model import Model
+from telegrinder.types.objects import Update
+
+T = typing.TypeVar("T", bound=Model)
+
+
+class ABCHandler(ABC, typing.Generic[T]):
+    is_blocking: bool
+
+    @abstractmethod
+    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
+        pass
+
+    @abstractmethod
+    async def run(self, api: API, event: T, ctx: Context) -> typing.Any:
+        pass
+
+
+__all__ = ("ABCHandler",)

telegrinder/bot/dispatch/handler/audio_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 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",)
+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

@@ -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
+
+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

@@ -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,
+        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

@@ -1,123 +1,135 @@
-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 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 import ABCRule
-
-F = typing.TypeVar("F", bound=typing.Callable[..., typing.Awaitable[typing.Any]])
-Event = typing.TypeVar("Event", bound=Model)
-ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
-
-
-@dataclasses.dataclass(repr=False, slots=True)
-class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
-    func: F
-    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 __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.func.__name__,
-            self.rules,
-            self.dataclass,
-            self.error_handler,
-        )
-
-    @cached_property
-    def required_nodes(self) -> dict[str, type[Node]]:
-        return get_nodes(self.func)
-
-    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[EVENT_NODE_KEY] = 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) -> typing.Any:
-        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:
-            event = event_node
-
-        elif dataclass_type is not None:
-            if self.update_type is not None and isinstance(event, Update):
-                update = event.to_dict()[self.update_type.value].unwrap()
-                event = (
-                    self.dataclass.from_update(update, bound_api=api)  # type: ignore
-                    if issubclass(dataclass_type, BaseCute)
-                    else self.dataclass(**update.to_dict())  # type: ignore
-                )
-
-            elif issubclass(dataclass_type, UpdateCute) and isinstance(event, Update):
-                event = self.dataclass.from_update(event, bound_api=api)  # type: ignore
-
-            else:
-                event = self.dataclass(**event.to_dict())  # type: ignore
-
-        result = (await self.error_handler.run(self.func, 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.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",)