telegrinder 0.3.3.post1__py3-none-any.whl → 0.3.4.post1__py3-none-any.whl

telegrinder/bot/dispatch/dispatch.py

@@ -1,202 +1,202 @@
-import dataclasses
-
-import typing_extensions as typing
-from fntypes import Nothing, Option, Some
-from vbml.patcher import Patcher
-
-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
-from telegrinder.bot.dispatch.handler.func import ErrorHandlerT, Func, FuncHandler
-from telegrinder.bot.dispatch.view.box import (
-    CallbackQueryView,
-    ChatJoinRequestView,
-    ChatMemberView,
-    InlineQueryView,
-    MessageView,
-    RawEventView,
-    ViewBox,
-)
-from telegrinder.modules import logger
-from telegrinder.tools.error_handler.error_handler import ErrorHandler
-from telegrinder.tools.global_context import TelegrinderContext
-from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Update
-
-if typing.TYPE_CHECKING:
-    from telegrinder.bot.rules.abc import ABCRule
-
-T = typing.TypeVar("T", default=typing.Any)
-R = typing.TypeVar("R", covariant=True, default=typing.Any)
-Event = typing.TypeVar("Event", bound=BaseCute)
-P = typing.ParamSpec("P", default=...)
-
-DEFAULT_DATACLASS: typing.Final[type[Update]] = Update
-
-
-@dataclasses.dataclass(repr=False, kw_only=True)
-class Dispatch(
-    ABCDispatch,
-    ViewBox[
-        CallbackQueryView,
-        ChatJoinRequestView,
-        ChatMemberView,
-        InlineQueryView,
-        MessageView,
-        RawEventView,
-    ],
-):
-    _global_context: TelegrinderContext = dataclasses.field(
-        init=False,
-        default_factory=lambda: TelegrinderContext(),
-    )
-
-    def __repr__(self) -> str:
-        return "Dispatch(%s)" % ", ".join(f"{k}={v!r}" for k, v in self.get_views().items())
-
-    @property
-    def global_context(self) -> TelegrinderContext:
-        return self._global_context
-
-    @property
-    def patcher(self) -> Patcher:
-        """Alias `patcher` to get `vbml.Patcher` from the global context."""
-
-        return self.global_context.vbml_patcher
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[T],
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        update_type: UpdateType,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[T],
-        update_type: UpdateType,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        update_type: UpdateType,
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[typing.Any],
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[typing.Any],
-        update_type: UpdateType,
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        update_type: UpdateType | None = None,
-        dataclass: type[T] = DEFAULT_DATACLASS,
-        error_handler: typing.Literal[None] = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
-
-    def handle(
-        self,
-        *rules: "ABCRule",
-        update_type: UpdateType | None = None,
-        dataclass: type[typing.Any] = DEFAULT_DATACLASS,
-        error_handler: ErrorHandlerT | None = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[..., typing.Any]:
-        def wrapper(func):
-            handler = FuncHandler(
-                func,
-                list(rules),
-                is_blocking=is_blocking,
-                dataclass=dataclass,
-                error_handler=error_handler or ErrorHandler(),
-                update_type=update_type,
-            )
-            self.raw_event.handlers.append(handler)
-            return handler
-
-        return wrapper
-
-    async def feed(self, event: Update, api: API) -> bool:
-        logger.debug(
-            "Processing update (update_id={}, update_type={!r})",
-            event.update_id,
-            event.update_type.name,
-        )
-        for view in self.get_views().values():
-            if await view.check(event):
-                logger.debug(
-                    "Update (update_id={}, update_type={!r}) matched view {!r}.",
-                    event.update_id,
-                    event.update_type.name,
-                    view,
-                )
-                if await view.process(event, api):
-                    return True
-        return False
-
-    def load(self, external: typing.Self) -> None:
-        view_external = external.get_views()
-        for name, view in self.get_views().items():
-            assert name in view_external, f"View {name!r} is undefined in external dispatch."
-            view.load(view_external[name])
-            setattr(external, name, view)
-
-    def get_view(self, of_type: type[T]) -> Option[T]:
-        for view in self.get_views().values():
-            if isinstance(view, of_type):
-                return Some(view)
-        return Nothing()
-
-    __call__ = handle
-
-
-__all__ = ("Dispatch",)
+import dataclasses
+
+import typing_extensions as typing
+from fntypes import Nothing, Option, Some
+from vbml.patcher import Patcher
+
+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
+from telegrinder.bot.dispatch.handler.func import ErrorHandlerT, Func, FuncHandler
+from telegrinder.bot.dispatch.view.box import (
+    CallbackQueryView,
+    ChatJoinRequestView,
+    ChatMemberView,
+    InlineQueryView,
+    MessageView,
+    RawEventView,
+    ViewBox,
+)
+from telegrinder.modules import logger
+from telegrinder.tools.error_handler.error_handler import ErrorHandler
+from telegrinder.tools.global_context import TelegrinderContext
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.abc import ABCRule
+
+T = typing.TypeVar("T", default=typing.Any)
+R = typing.TypeVar("R", covariant=True, default=typing.Any)
+Event = typing.TypeVar("Event", bound=BaseCute)
+P = typing.ParamSpec("P", default=...)
+
+DEFAULT_DATACLASS: typing.Final[type[Update]] = Update
+
+
+@dataclasses.dataclass(repr=False, kw_only=True)
+class Dispatch(
+    ABCDispatch,
+    ViewBox[
+        CallbackQueryView,
+        ChatJoinRequestView,
+        ChatMemberView,
+        InlineQueryView,
+        MessageView,
+        RawEventView,
+    ],
+):
+    _global_context: TelegrinderContext = dataclasses.field(
+        init=False,
+        default_factory=lambda: TelegrinderContext(),
+    )
+
+    def __repr__(self) -> str:
+        return "Dispatch(%s)" % ", ".join(f"{k}={v!r}" for k, v in self.get_views().items())
+
+    @property
+    def global_context(self) -> TelegrinderContext:
+        return self._global_context
+
+    @property
+    def patcher(self) -> Patcher:
+        """Alias `patcher` to get `vbml.Patcher` from the global context."""
+
+        return self.global_context.vbml_patcher
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        dataclass: type[T],
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        update_type: UpdateType,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        dataclass: type[T],
+        update_type: UpdateType,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        update_type: UpdateType,
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        dataclass: type[typing.Any],
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        dataclass: type[typing.Any],
+        update_type: UpdateType,
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        update_type: UpdateType | None = None,
+        dataclass: type[T] = DEFAULT_DATACLASS,
+        error_handler: typing.Literal[None] = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
+
+    def handle(
+        self,
+        *rules: "ABCRule",
+        update_type: UpdateType | None = None,
+        dataclass: type[typing.Any] = DEFAULT_DATACLASS,
+        error_handler: ErrorHandlerT | None = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[..., typing.Any]:
+        def wrapper(func):
+            handler = FuncHandler(
+                func,
+                list(rules),
+                is_blocking=is_blocking,
+                dataclass=dataclass,
+                error_handler=error_handler or ErrorHandler(),
+                update_type=update_type,
+            )
+            self.raw_event.handlers.append(handler)
+            return handler
+
+        return wrapper
+
+    async def feed(self, event: Update, api: API) -> bool:
+        logger.debug(
+            "Processing update (update_id={}, update_type={!r})",
+            event.update_id,
+            event.update_type.name,
+        )
+        for view in self.get_views().values():
+            if await view.check(event):
+                logger.debug(
+                    "Update (update_id={}, update_type={!r}) matched view {!r}.",
+                    event.update_id,
+                    event.update_type.name,
+                    view,
+                )
+                if await view.process(event, api):
+                    return True
+        return False
+
+    def load(self, external: typing.Self) -> None:
+        view_external = external.get_views()
+        for name, view in self.get_views().items():
+            assert name in view_external, f"View {name!r} is undefined in external dispatch."
+            view.load(view_external[name])
+            setattr(external, name, view)
+
+    def get_view(self, of_type: type[T]) -> Option[T]:
+        for view in self.get_views().values():
+            if isinstance(view, of_type):
+                return Some(view)
+        return Nothing()
+
+    __call__ = handle
+
+
+__all__ = ("Dispatch",)

telegrinder/bot/dispatch/handler/__init__.py

@@ -1,14 +1,14 @@
-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__ = (
+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",
     "AudioReplyHandler",
     "DocumentReplyHandler",
@@ -17,5 +17,5 @@ __all__ = (
     "MessageReplyHandler",
     "PhotoReplyHandler",
     "StickerReplyHandler",
-    "VideoReplyHandler",
-)
+    "VideoReplyHandler",
+)

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",)