telegrinder 0.3.0.post2__py3-none-any.whl → 0.3.2__py3-none-any.whl

telegrinder/bot/dispatch/context.py

@@ -1,92 +1,92 @@
-import enum
-import typing
-from reprlib import recursive_repr
-
-from telegrinder.types.objects import Update
-
-T = typing.TypeVar("T")
-
-Key: typing.TypeAlias = str | enum.Enum
-AnyValue: typing.TypeAlias = typing.Any
-
-
-class Context(dict[str, AnyValue]):
-    """Context class like dict & dotdict.
-
-    For example:
-    ```python
-    class MyRule(ABCRule[T]):
-        async def check(self, event: T, ctx: Context) -> bool:
-            ctx.me = (await event.ctx_api.get_me()).unwrap()
-            ctx["items"] = [1, 2, 3]
-            return True
-    ```
-    """
-
-    raw_update: Update
-
-    def __init__(self, **kwargs: AnyValue) -> None:
-        cls_vars = vars(self.__class__)
-        defaults = {}
-
-        for k in self.__class__.__annotations__:
-            if k in cls_vars:
-                defaults[k] = cls_vars[k]
-                delattr(self.__class__, k)
-
-        dict.__init__(self, **defaults | kwargs)
-
-    @recursive_repr()
-    def __repr__(self) -> str:
-        return "{}({})".format(self.__class__.__name__, ", ".join(f"{k}={v!r}" for k, v in self.items()))
-
-    def __setitem__(self, __key: Key, __value: AnyValue) -> None:
-        dict.__setitem__(self, self.key_to_str(__key), __value)
-
-    def __getitem__(self, __key: Key) -> AnyValue:
-        return dict.__getitem__(self, self.key_to_str(__key))
-
-    def __delitem__(self, __key: Key) -> None:
-        dict.__delitem__(self, self.key_to_str(__key))
-
-    def __setattr__(self, __name: str, __value: AnyValue) -> None:
-        self.__setitem__(__name, __value)
-
-    def __getattr__(self, __name: str) -> AnyValue:
-        return self.__getitem__(__name)
-
-    def __delattr__(self, __name: str) -> None:
-        self.__delitem__(__name)
-
-    @staticmethod
-    def key_to_str(key: Key) -> str:
-        return key if isinstance(key, str) else str(key.value)
-
-    def copy(self) -> typing.Self:
-        return self.__class__(**dict.copy(self))
-
-    def set(self, key: Key, value: AnyValue) -> None:
-        self[key] = value
-
-    @typing.overload
-    def get(self, key: Key) -> AnyValue | None: ...
-
-    @typing.overload
-    def get(self, key: Key, default: T) -> T | AnyValue: ...
-
-    @typing.overload
-    def get(self, key: Key, default: None = None) -> AnyValue | None: ...
-
-    def get(self, key: Key, default: T | None = None) -> T | AnyValue | None:
-        return dict.get(self, key, default)
-
-    def get_or_set(self, key: Key, default: T) -> T:
-        if key not in self:
-            self.set(key, default)
-        return self.get(key, default)
-
-    def delete(self, key: Key) -> None:
-        del self[key]
-
-
-__all__ = ("Context",)
+import enum
+import typing
+from reprlib import recursive_repr
+
+from telegrinder.types.objects import Update
+
+T = typing.TypeVar("T")
+
+Key: typing.TypeAlias = str | enum.Enum
+AnyValue: typing.TypeAlias = typing.Any
+
+
+class Context(dict[str, AnyValue]):
+    """Context class like dict & dotdict.
+
+    For example:
+    ```python
+    class MyRule(ABCRule[T]):
+        async def check(self, event: T, ctx: Context) -> bool:
+            ctx.me = (await event.ctx_api.get_me()).unwrap()
+            ctx["items"] = [1, 2, 3]
+            return True
+    ```
+    """
+
+    raw_update: Update
+
+    def __init__(self, **kwargs: AnyValue) -> None:
+        cls_vars = vars(self.__class__)
+        defaults = {}
+
+        for k in self.__class__.__annotations__:
+            if k in cls_vars:
+                defaults[k] = cls_vars[k]
+                delattr(self.__class__, k)
+
+        dict.__init__(self, **defaults | kwargs)
+
+    @recursive_repr()
+    def __repr__(self) -> str:
+        return "{}({})".format(self.__class__.__name__, ", ".join(f"{k}={v!r}" for k, v in self.items()))
+
+    def __setitem__(self, __key: Key, __value: AnyValue) -> None:
+        dict.__setitem__(self, self.key_to_str(__key), __value)
+
+    def __getitem__(self, __key: Key) -> AnyValue:
+        return dict.__getitem__(self, self.key_to_str(__key))
+
+    def __delitem__(self, __key: Key) -> None:
+        dict.__delitem__(self, self.key_to_str(__key))
+
+    def __setattr__(self, __name: str, __value: AnyValue) -> None:
+        self.__setitem__(__name, __value)
+
+    def __getattr__(self, __name: str) -> AnyValue:
+        return self.__getitem__(__name)
+
+    def __delattr__(self, __name: str) -> None:
+        self.__delitem__(__name)
+
+    @staticmethod
+    def key_to_str(key: Key) -> str:
+        return key if isinstance(key, str) else str(key.value)
+
+    def copy(self) -> typing.Self:
+        return self.__class__(**dict.copy(self))
+
+    def set(self, key: Key, value: AnyValue) -> None:
+        self[key] = value
+
+    @typing.overload
+    def get(self, key: Key) -> AnyValue | None: ...
+
+    @typing.overload
+    def get(self, key: Key, default: T) -> T | AnyValue: ...
+
+    @typing.overload
+    def get(self, key: Key, default: None = None) -> AnyValue | None: ...
+
+    def get(self, key: Key, default: T | None = None) -> T | AnyValue | None:
+        return dict.get(self, key, default)
+
+    def get_or_set(self, key: Key, default: T) -> T:
+        if key not in self:
+            self.set(key, default)
+        return self.get(key, default)
+
+    def delete(self, key: Key) -> None:
+        del self[key]
+
+
+__all__ = ("Context",)

telegrinder/bot/dispatch/dispatch.py

@@ -1,201 +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, 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)
-Handler = typing.Callable[typing.Concatenate[T, ...], typing.Coroutine[typing.Any, typing.Any, typing.Any]]
-Event = typing.TypeVar("Event", bound=BaseCute)
-
-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[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[T],
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        update_type: UpdateType,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[T],
-        update_type: UpdateType,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        update_type: UpdateType,
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[T],
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[T],
-        update_type: UpdateType,
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], 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[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
-
-    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",
+)