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

telegrinder/bot/dispatch/view/callback_query.py

@@ -1,17 +1,17 @@
-from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
-from telegrinder.bot.dispatch.return_manager.callback_query import CallbackQueryReturnManager
-from telegrinder.bot.dispatch.view.base import BaseStateView
-
-
-class CallbackQueryView(BaseStateView[CallbackQueryCute]):
-    def __init__(self) -> None:
-        self.auto_rules = []
-        self.handlers = []
-        self.middlewares = []
-        self.return_manager = CallbackQueryReturnManager()
-
-    def get_state_key(self, event: CallbackQueryCute) -> int | None:
-        return event.message_id.unwrap_or_none()
-
-
-__all__ = ("CallbackQueryView",)
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.dispatch.return_manager.callback_query import CallbackQueryReturnManager
+from telegrinder.bot.dispatch.view.base import BaseStateView
+
+
+class CallbackQueryView(BaseStateView[CallbackQueryCute]):
+    def __init__(self) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = CallbackQueryReturnManager()
+
+    def get_state_key(self, event: CallbackQueryCute) -> int | None:
+        return event.message_id.unwrap_or_none()
+
+
+__all__ = ("CallbackQueryView",)

telegrinder/bot/dispatch/view/chat_join_request.py

@@ -1,16 +1,16 @@
-from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
-from telegrinder.bot.dispatch.view.base import BaseStateView
-
-
-class ChatJoinRequestView(BaseStateView[ChatJoinRequestCute]):
-    def __init__(self) -> None:
-        self.auto_rules = []
-        self.handlers = []
-        self.middlewares = []
-        self.return_manager = None
-
-    def get_state_key(self, event: ChatJoinRequestCute) -> int | None:
-        return event.chat_id
-
-
-__all__ = ("ChatJoinRequestView",)
+from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
+from telegrinder.bot.dispatch.view.base import BaseStateView
+
+
+class ChatJoinRequestView(BaseStateView[ChatJoinRequestCute]):
+    def __init__(self) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = None
+
+    def get_state_key(self, event: ChatJoinRequestCute) -> int | None:
+        return event.chat_id
+
+
+__all__ = ("ChatJoinRequestView",)

telegrinder/bot/dispatch/view/chat_member.py

@@ -1,39 +1,39 @@
-import typing
-
-from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
-from telegrinder.bot.dispatch.view.base import BaseStateView
-from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Update
-
-ChatMemberUpdateType: typing.TypeAlias = typing.Literal[
-    UpdateType.CHAT_MEMBER,
-    UpdateType.MY_CHAT_MEMBER,
-]
-
-
-class ChatMemberView(BaseStateView[ChatMemberUpdatedCute]):
-    def __init__(self, *, update_type: ChatMemberUpdateType | None = None) -> None:
-        self.auto_rules = []
-        self.handlers = []
-        self.middlewares = []
-        self.return_manager = None
-        self.update_type = update_type
-
-    def __repr__(self) -> str:
-        return "<{}: {!r}>".format(
-            self.__class__.__name__,
-            "chat_member_updated" if self.update_type is None else self.update_type.value,
-        )
-
-    def get_state_key(self, event: ChatMemberUpdatedCute) -> int | None:
-        return event.chat_id
-
-    async def check(self, event: Update) -> bool:
-        return not (
-            self.update_type is not None
-            and self.update_type != event.update_type
-            or not await super().check(event)
-        )
-
-
-__all__ = ("ChatMemberView",)
+import typing
+
+from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
+from telegrinder.bot.dispatch.view.base import BaseStateView
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
+
+ChatMemberUpdateType: typing.TypeAlias = typing.Literal[
+    UpdateType.CHAT_MEMBER,
+    UpdateType.MY_CHAT_MEMBER,
+]
+
+
+class ChatMemberView(BaseStateView[ChatMemberUpdatedCute]):
+    def __init__(self, *, update_type: ChatMemberUpdateType | None = None) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = None
+        self.update_type = update_type
+
+    def __repr__(self) -> str:
+        return "<{}: {!r}>".format(
+            self.__class__.__name__,
+            "chat_member_updated" if self.update_type is None else self.update_type.value,
+        )
+
+    def get_state_key(self, event: ChatMemberUpdatedCute) -> int | None:
+        return event.chat_id
+
+    async def check(self, event: Update) -> bool:
+        return not (
+            self.update_type is not None
+            and self.update_type != event.update_type
+            or not await super().check(event)
+        )
+
+
+__all__ = ("ChatMemberView",)

telegrinder/bot/dispatch/view/inline_query.py

@@ -1,17 +1,17 @@
-from telegrinder.bot.cute_types.inline_query import InlineQueryCute
-from telegrinder.bot.dispatch.return_manager import InlineQueryReturnManager
-from telegrinder.bot.dispatch.view.base import BaseStateView
-
-
-class InlineQueryView(BaseStateView[InlineQueryCute]):
-    def __init__(self) -> None:
-        self.auto_rules = []
-        self.handlers = []
-        self.middlewares = []
-        self.return_manager = InlineQueryReturnManager()
-
-    def get_state_key(self, event: InlineQueryCute) -> int | None:
-        return event.from_user.id
-
-
-__all__ = ("InlineQueryView",)
+from telegrinder.bot.cute_types.inline_query import InlineQueryCute
+from telegrinder.bot.dispatch.return_manager import InlineQueryReturnManager
+from telegrinder.bot.dispatch.view.base import BaseStateView
+
+
+class InlineQueryView(BaseStateView[InlineQueryCute]):
+    def __init__(self) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = InlineQueryReturnManager()
+
+    def get_state_key(self, event: InlineQueryCute) -> int | None:
+        return event.from_user.id
+
+
+__all__ = ("InlineQueryView",)

telegrinder/bot/dispatch/view/message.py

@@ -1,44 +1,44 @@
-import typing
-
-from telegrinder.bot.cute_types.message import MessageCute
-from telegrinder.bot.dispatch.return_manager.message import MessageReturnManager
-from telegrinder.bot.dispatch.view.base import BaseStateView
-from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Update
-
-MessageUpdateType: typing.TypeAlias = typing.Literal[
-    UpdateType.MESSAGE,
-    UpdateType.BUSINESS_MESSAGE,
-    UpdateType.CHANNEL_POST,
-    UpdateType.EDITED_BUSINESS_MESSAGE,
-    UpdateType.EDITED_CHANNEL_POST,
-    UpdateType.EDITED_MESSAGE,
-]
-
-
-class MessageView(BaseStateView[MessageCute]):
-    def __init__(self, *, update_type: MessageUpdateType | None = None) -> None:
-        self.auto_rules = []
-        self.handlers = []
-        self.update_type = update_type
-        self.middlewares = []
-        self.return_manager = MessageReturnManager()
-
-    def __repr__(self) -> str:
-        return "<{}: {!r}>".format(
-            self.__class__.__name__,
-            "any message update" if self.update_type is None else self.update_type.value,
-        )
-
-    def get_state_key(self, event: MessageCute) -> int | None:
-        return event.chat_id
-
-    async def check(self, event: Update) -> bool:
-        return not (
-            self.update_type is not None
-            and self.update_type != event.update_type
-            or not await super().check(event)
-        )
-
-
-__all__ = ("MessageView",)
+import typing
+
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.return_manager.message import MessageReturnManager
+from telegrinder.bot.dispatch.view.base import BaseStateView
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
+
+MessageUpdateType: typing.TypeAlias = typing.Literal[
+    UpdateType.MESSAGE,
+    UpdateType.BUSINESS_MESSAGE,
+    UpdateType.CHANNEL_POST,
+    UpdateType.EDITED_BUSINESS_MESSAGE,
+    UpdateType.EDITED_CHANNEL_POST,
+    UpdateType.EDITED_MESSAGE,
+]
+
+
+class MessageView(BaseStateView[MessageCute]):
+    def __init__(self, *, update_type: MessageUpdateType | None = None) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.update_type = update_type
+        self.middlewares = []
+        self.return_manager = MessageReturnManager()
+
+    def __repr__(self) -> str:
+        return "<{}: {!r}>".format(
+            self.__class__.__name__,
+            "any message update" if self.update_type is None else self.update_type.value,
+        )
+
+    def get_state_key(self, event: MessageCute) -> int | None:
+        return event.chat_id
+
+    async def check(self, event: Update) -> bool:
+        return not (
+            self.update_type is not None
+            and self.update_type != event.update_type
+            or not await super().check(event)
+        )
+
+
+__all__ = ("MessageView",)

telegrinder/bot/dispatch/view/raw.py

@@ -1,114 +1,114 @@
-import typing
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.bot.dispatch.handler.func import Func, FuncHandler
-from telegrinder.bot.dispatch.process import process_inner
-from telegrinder.bot.dispatch.view.abc import ABCEventRawView
-from telegrinder.bot.dispatch.view.base import BaseView, ErrorHandlerT
-from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
-from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Update
-
-T = typing.TypeVar("T", contravariant=True)
-R = typing.TypeVar("R", covariant=True)
-P = typing.ParamSpec("P")
-
-
-class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
-    def __init__(self) -> None:
-        self.auto_rules = []
-        self.handlers = []
-        self.middlewares = []
-        self.return_manager = None
-
-    @typing.overload
-    def __call__(
-        self,
-        update_type: UpdateType,
-        *rules: ABCRule,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]],
-    ]: ...
-
-    @typing.overload
-    def __call__(
-        self,
-        update_type: UpdateType,
-        *rules: ABCRule,
-        dataclass: type[T],
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
-
-    @typing.overload
-    def __call__(
-        self,
-        update_type: UpdateType,
-        *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT],
-    ]: ...
-
-    @typing.overload
-    def __call__(
-        self,
-        update_type: UpdateType,
-        *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 __call__(
-        self,
-        update_type: UpdateType,
-        *rules: ABCRule,
-        dataclass: None = None,
-        error_handler: None = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]],
-    ]: ...
-
-    def __call__(  # type: ignore
-        self,
-        update_type: UpdateType,
-        *rules: ABCRule,
-        dataclass: type[typing.Any] | None = None,
-        error_handler: ABCErrorHandler | None = None,
-        is_blocking: bool = True,
-    ):
-        def wrapper(func):
-            func_handler = FuncHandler(
-                func,
-                rules=[*self.auto_rules, *rules],
-                is_blocking=is_blocking,
-                dataclass=dataclass,
-                error_handler=error_handler or ErrorHandler(),
-                update_type=update_type,
-            )
-            self.handlers.append(func_handler)
-            return func_handler
-
-        return wrapper
-
-    async def check(self, event: Update) -> bool:
-        return bool(self.handlers) or bool(self.middlewares)
-
-    async def process(self, event: Update, api: API) -> bool:
-        return await process_inner(
-            api,
-            UpdateCute.from_update(event, bound_api=api),
-            event,
-            self.middlewares,
-            self.handlers,
-            self.return_manager,
-        )
-
-
-__all__ = ("RawEventView",)
+import typing
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.handler.func import Func, FuncHandler
+from telegrinder.bot.dispatch.process import process_inner
+from telegrinder.bot.dispatch.view.abc import ABCEventRawView
+from telegrinder.bot.dispatch.view.base import BaseView, ErrorHandlerT
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
+
+T = typing.TypeVar("T", contravariant=True)
+R = typing.TypeVar("R", covariant=True)
+P = typing.ParamSpec("P")
+
+
+class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
+    def __init__(self) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = None
+
+    @typing.overload
+    def __call__(
+        self,
+        update_type: UpdateType,
+        *rules: ABCRule,
+    ) -> typing.Callable[
+        [Func[P, R]],
+        FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]],
+    ]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        update_type: UpdateType,
+        *rules: ABCRule,
+        dataclass: type[T],
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        update_type: UpdateType,
+        *rules: ABCRule,
+        error_handler: ErrorHandlerT,
+    ) -> typing.Callable[
+        [Func[P, R]],
+        FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT],
+    ]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        update_type: UpdateType,
+        *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 __call__(
+        self,
+        update_type: UpdateType,
+        *rules: ABCRule,
+        dataclass: None = None,
+        error_handler: None = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [Func[P, R]],
+        FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]],
+    ]: ...
+
+    def __call__(  # type: ignore
+        self,
+        update_type: UpdateType,
+        *rules: ABCRule,
+        dataclass: type[typing.Any] | None = None,
+        error_handler: ABCErrorHandler | None = None,
+        is_blocking: bool = True,
+    ):
+        def wrapper(func):
+            func_handler = FuncHandler(
+                func,
+                rules=[*self.auto_rules, *rules],
+                is_blocking=is_blocking,
+                dataclass=dataclass,
+                error_handler=error_handler or ErrorHandler(),
+                update_type=update_type,
+            )
+            self.handlers.append(func_handler)
+            return func_handler
+
+        return wrapper
+
+    async def check(self, event: Update) -> bool:
+        return bool(self.handlers) or bool(self.middlewares)
+
+    async def process(self, event: Update, api: API) -> bool:
+        return await process_inner(
+            api,
+            UpdateCute.from_update(event, bound_api=api),
+            event,
+            self.middlewares,
+            self.handlers,
+            self.return_manager,
+        )
+
+
+__all__ = ("RawEventView",)

telegrinder/bot/dispatch/waiter_machine/__init__.py

@@ -1,18 +1,18 @@
-from telegrinder.bot.dispatch.waiter_machine.hasher import (
-    CALLBACK_QUERY_FOR_MESSAGE,
-    CALLBACK_QUERY_FROM_CHAT,
-    CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE,
-    MESSAGE_FROM_USER,
-    MESSAGE_FROM_USER_IN_CHAT,
-    MESSAGE_IN_CHAT,
-    Hasher,
-    StateViewHasher,
-)
-from telegrinder.bot.dispatch.waiter_machine.machine import WaiterMachine, clear_wm_storage_worker
-from telegrinder.bot.dispatch.waiter_machine.middleware import WaiterMiddleware
-from telegrinder.bot.dispatch.waiter_machine.short_state import ShortState
-
-__all__ = (
+from telegrinder.bot.dispatch.waiter_machine.hasher import (
+    CALLBACK_QUERY_FOR_MESSAGE,
+    CALLBACK_QUERY_FROM_CHAT,
+    CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE,
+    MESSAGE_FROM_USER,
+    MESSAGE_FROM_USER_IN_CHAT,
+    MESSAGE_IN_CHAT,
+    Hasher,
+    StateViewHasher,
+)
+from telegrinder.bot.dispatch.waiter_machine.machine import WaiterMachine, clear_wm_storage_worker
+from telegrinder.bot.dispatch.waiter_machine.middleware import WaiterMiddleware
+from telegrinder.bot.dispatch.waiter_machine.short_state import ShortState
+
+__all__ = (
     "CALLBACK_QUERY_FOR_MESSAGE",
     "CALLBACK_QUERY_FROM_CHAT",
     "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
@@ -24,5 +24,5 @@ __all__ = (
     "StateViewHasher",
     "WaiterMachine",
     "WaiterMiddleware",
-    "clear_wm_storage_worker",
-)
+    "clear_wm_storage_worker",
+)

telegrinder/bot/dispatch/waiter_machine/actions.py

@@ -1,13 +1,13 @@
-import typing
-
-from telegrinder.bot.dispatch.handler.abc import ABCHandler
-
-from .short_state import EventModel, ShortState
-
-
-class WaiterActions(typing.TypedDict, typing.Generic[EventModel]):
-    on_miss: typing.NotRequired[ABCHandler[EventModel]]
-    on_drop: typing.NotRequired[typing.Callable[[ShortState[EventModel]], None]]
-
-
-__all__ = ("WaiterActions",)
+import typing
+
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+
+from .short_state import EventModel, ShortState
+
+
+class WaiterActions(typing.TypedDict, typing.Generic[EventModel]):
+    on_miss: typing.NotRequired[ABCHandler[EventModel]]
+    on_drop: typing.NotRequired[typing.Callable[[ShortState[EventModel]], None]]
+
+
+__all__ = ("WaiterActions",)

telegrinder/bot/dispatch/waiter_machine/hasher/__init__.py

@@ -1,9 +1,9 @@
-from .callback import CALLBACK_QUERY_FOR_MESSAGE, CALLBACK_QUERY_FROM_CHAT, CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE
-from .hasher import Hasher
-from .message import MESSAGE_FROM_USER, MESSAGE_FROM_USER_IN_CHAT, MESSAGE_IN_CHAT
-from .state import StateViewHasher
-
-__all__ = (
+from .callback import CALLBACK_QUERY_FOR_MESSAGE, CALLBACK_QUERY_FROM_CHAT, CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE
+from .hasher import Hasher
+from .message import MESSAGE_FROM_USER, MESSAGE_FROM_USER_IN_CHAT, MESSAGE_IN_CHAT
+from .state import StateViewHasher
+
+__all__ = (
     "CALLBACK_QUERY_FOR_MESSAGE",
     "CALLBACK_QUERY_FROM_CHAT",
     "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
@@ -11,5 +11,5 @@ __all__ = (
     "MESSAGE_FROM_USER",
     "MESSAGE_FROM_USER_IN_CHAT",
     "MESSAGE_IN_CHAT",
-    "StateViewHasher",
-)
+    "StateViewHasher",
+)