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

telegrinder/bot/dispatch/view/raw.py

@@ -1,114 +1,116 @@
-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.base import BaseCute
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.context import Context
+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
+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
+
+
+class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
+    @typing.overload
+    def __call__[**P, R](
+        self,
+        *rules: ABCRule,
+        update_type: UpdateType,
+        final: bool = True,
+    ) -> typing.Callable[
+        [Func[P, R]],
+        FuncHandler[BaseCute[typing.Any], Func[P, R], ErrorHandler[BaseCute[typing.Any]]],
+    ]: ...
+
+    @typing.overload
+    def __call__[**P, Dataclass, R](
+        self,
+        *rules: ABCRule,
+        dataclass: type[Dataclass],
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[Dataclass, Func[P, R], ErrorHandler[Dataclass]]]: ...
+
+    @typing.overload
+    def __call__[**P, Dataclass, R](
+        self,
+        *rules: ABCRule,
+        update_type: UpdateType,
+        dataclass: type[Dataclass],
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[Dataclass, Func[P, R], ErrorHandler[Dataclass]]]: ...
+
+    @typing.overload
+    def __call__[**P, ErrorHandlerT: ABCErrorHandler, R](
+        self,
+        *rules: ABCRule,
+        error_handler: ErrorHandlerT,
+        final: bool = True,
+    ) -> typing.Callable[
+        [Func[P, R]],
+        FuncHandler[BaseCute[typing.Any], Func[P, R], ErrorHandlerT],
+    ]: ...
+
+    @typing.overload
+    def __call__[**P, ErrorHandlerT: ABCErrorHandler, R](
+        self,
+        *rules: ABCRule,
+        error_handler: ErrorHandlerT,
+        update_type: UpdateType,
+        final: bool = True,
+    ) -> typing.Callable[
+        [Func[P, R]],
+        FuncHandler[BaseCute[typing.Any], Func[P, R], ErrorHandlerT],
+    ]: ...
+
+    @typing.overload
+    def __call__[**P, Dataclass, ErrorHandlerT: ABCErrorHandler, R](
+        self,
+        *rules: ABCRule,
+        update_type: UpdateType,
+        dataclass: type[Dataclass],
+        error_handler: ErrorHandlerT,
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[Dataclass, Func[P, R], ErrorHandlerT]]: ...
+
+    def __call__(
+        self,
+        *rules: ABCRule,
+        update_type: UpdateType | None = None,
+        dataclass: type[typing.Any] | None = None,
+        error_handler: ABCErrorHandler | None = None,
+        final: bool = True,
+    ) -> typing.Callable[..., typing.Any]:
+        def wrapper(func: typing.Callable[..., typing.Any]):
+            func_handler = FuncHandler(
+                func,
+                rules=[*self.auto_rules, *rules],
+                final=final,
+                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, context: Context) -> bool:
+        return await process_inner(
+            api,
+            UpdateCute.from_update(event, bound_api=api),
+            event,
+            context,
+            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,14 @@
-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.cute_types import BaseCute
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+
+from .short_state import ShortState
+
+
+class WaiterActions[Event: BaseCute](typing.TypedDict):
+    on_miss: typing.NotRequired[ABCHandler[Event]]
+    on_drop: typing.NotRequired[typing.Callable[[ShortState[Event]], 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",
+)

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

@@ -1,57 +1,57 @@
-from fntypes.option import Some
-
-from telegrinder.bot.cute_types import CallbackQueryCute as CallbackQuery
-from telegrinder.bot.dispatch.view import CallbackQueryView
-from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
-
-
-def from_chat_hash(chat_id: int) -> int:
-    return chat_id
-
-
-def get_chat_from_event(event: CallbackQuery) -> int | None:
-    return event.chat.and_then(lambda chat: Some(chat.id)).unwrap_or_none()
-
-
-def for_message_hash(message_id: int) -> int:
-    return message_id
-
-
-def get_message_for_event(event: CallbackQuery) -> int | None:
-    return event.message_id.unwrap_or_none()
-
-
-def for_message_in_chat(chat_and_message: tuple[int, int]) -> str:
-    return f"{chat_and_message[0]}_{chat_and_message[1]}"
-
-
-def get_chat_and_message_for_event(event: CallbackQuery) -> tuple[int, int] | None:
-    if not event.message_id or not event.chat:
-        return None
-    return event.chat.unwrap().id, event.message_id.unwrap()
-
-
-CALLBACK_QUERY_FROM_CHAT = Hasher(
-    view_class=CallbackQueryView,
-    get_hash_from_data=from_chat_hash,
-    get_data_from_event=get_chat_from_event,
-)
-
-CALLBACK_QUERY_FOR_MESSAGE = Hasher(
-    view_class=CallbackQueryView,
-    get_hash_from_data=for_message_hash,
-    get_data_from_event=get_message_for_event,
-)
-
-CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE = Hasher(
-    view_class=CallbackQueryView,
-    get_hash_from_data=for_message_in_chat,
-    get_data_from_event=get_chat_and_message_for_event,
-)
-
-
-__all__ = (
+from fntypes.option import Some
+
+from telegrinder.bot.cute_types import CallbackQueryCute as CallbackQuery
+from telegrinder.bot.dispatch.view import CallbackQueryView
+from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
+
+
+def from_chat_hash(chat_id: int) -> int:
+    return chat_id
+
+
+def get_chat_from_event(event: CallbackQuery) -> int | None:
+    return event.chat.and_then(lambda chat: Some(chat.id)).unwrap_or_none()
+
+
+def for_message_hash(message_id: int) -> int:
+    return message_id
+
+
+def get_message_for_event(event: CallbackQuery) -> int | None:
+    return event.message_id.unwrap_or_none()
+
+
+def for_message_in_chat(chat_and_message: tuple[int, int]) -> str:
+    return f"{chat_and_message[0]}_{chat_and_message[1]}"
+
+
+def get_chat_and_message_for_event(event: CallbackQuery) -> tuple[int, int] | None:
+    if not event.message_id or not event.chat:
+        return None
+    return event.chat.unwrap().id, event.message_id.unwrap()
+
+
+CALLBACK_QUERY_FROM_CHAT = Hasher(
+    view_class=CallbackQueryView,
+    get_hash_from_data=from_chat_hash,
+    get_data_from_event=get_chat_from_event,
+)
+
+CALLBACK_QUERY_FOR_MESSAGE = Hasher(
+    view_class=CallbackQueryView,
+    get_hash_from_data=for_message_hash,
+    get_data_from_event=get_message_for_event,
+)
+
+CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE = Hasher(
+    view_class=CallbackQueryView,
+    get_hash_from_data=for_message_in_chat,
+    get_data_from_event=get_chat_and_message_for_event,
+)
+
+
+__all__ = (
     "CALLBACK_QUERY_FOR_MESSAGE",
     "CALLBACK_QUERY_FROM_CHAT",
-    "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
-)
+    "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
+)

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

@@ -1,57 +1,59 @@
-import typing
-from functools import cached_property
-
-from fntypes.option import Option
-
-from telegrinder.bot.cute_types import BaseCute
-from telegrinder.bot.dispatch.view.base import BaseView
-from telegrinder.tools.functional import from_optional
-
-T = typing.TypeVar("T")
-Event = typing.TypeVar("Event", bound=BaseCute)
-Data = typing.TypeVar("Data")
-
-
-def _echo(__x: T) -> T:
-    return __x
-
-
-ECHO = _echo
-
-
-class Hasher(typing.Generic[Event, Data]):
-    def __init__(
-        self,
-        view_class: type[BaseView[Event]],
-        get_hash_from_data: typing.Callable[[Data], typing.Hashable | None] | None = None,
-        get_data_from_event: typing.Callable[[Event], Data | None] | None = None,
-    ) -> None:
-        self.view_class = view_class
-        self._get_hash_from_data = get_hash_from_data
-        self._get_data_from_event = get_data_from_event
-
-    def __hash__(self) -> int:
-        return hash(self.name)
-
-    def __repr__(self) -> str:
-        return f"<Hasher {self.name}>"
-
-    @cached_property
-    def name(self) -> str:
-        return f"{self.view_class.__name__}_{id(self)}"
-
-    def get_hash_from_data(self, data: Data) -> Option[typing.Hashable]:
-        if self._get_hash_from_data is None:
-            raise NotImplementedError
-        return from_optional(self._get_hash_from_data(data))
-
-    def get_data_from_event(self, event: Event) -> Option[Data]:
-        if not self._get_data_from_event:
-            raise NotImplementedError
-        return from_optional(self._get_data_from_event(event))
-
-    def get_hash_from_data_from_event(self, event: Event) -> Option[typing.Hashable]:
-        return self.get_data_from_event(event).and_then(self.get_hash_from_data)  # type: ignore
-
-
-__all__ = ("Hasher",)
+import typing
+from functools import cached_property
+
+from fntypes.option import Option
+
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.dispatch.view.base import BaseView
+from telegrinder.tools.functional import from_optional
+
+Event = typing.TypeVar("Event", bound=BaseCute, covariant=True)
+Data = typing.TypeVar("Data", covariant=True)
+
+
+def _echo[T](__x: T) -> T:
+    return __x
+
+
+ECHO = _echo
+
+
+class Hasher(typing.Generic[Event, Data]):
+    def __init__(
+        self,
+        view_class: type[BaseView[Event]],
+        get_hash_from_data: typing.Callable[[Data], typing.Hashable | None] | None = None,
+        get_data_from_event: typing.Callable[[Event], Data | None] | None = None,
+    ) -> None:
+        self.view_class = view_class
+        self._get_hash_from_data = get_hash_from_data
+        self._get_data_from_event = get_data_from_event
+
+    def __hash__(self) -> int:
+        return hash(self.name)
+
+    def __repr__(self) -> str:
+        return f"<Hasher {self.name}>"
+
+    @cached_property
+    def name(self) -> str:
+        return f"{self.view_class.__name__}_{id(self)}"
+
+    def get_hash_from_data[D](self: "Hasher[Event, D]", data: D) -> Option[typing.Hashable]:
+        if self._get_hash_from_data is None:
+            raise NotImplementedError
+        return from_optional(self._get_hash_from_data(data))
+
+    def get_data_from_event[E: BaseCute](self: "Hasher[E, Data]", event: E) -> Option[Data]:
+        if not self._get_data_from_event:
+            raise NotImplementedError
+        return from_optional(self._get_data_from_event(event))
+
+    def get_hash_from_data_from_event[E: BaseCute](
+        self: "Hasher[E, Data]",
+        event: E,
+    ) -> Option[typing.Hashable]:
+        return self.get_data_from_event(event).and_then(self.get_hash_from_data)  # type: ignore
+
+
+__all__ = ("Hasher",)

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

@@ -1,53 +1,53 @@
-from telegrinder.bot.cute_types import MessageCute as Message
-from telegrinder.bot.dispatch.view import MessageView
-from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
-
-
-def from_chat_hash(chat_id: int) -> int:
-    return chat_id
-
-
-def get_chat_from_event(event: Message) -> int:
-    return event.chat.id
-
-
-def from_user_in_chat_hash(chat_and_user: tuple[int, int]) -> str:
-    return f"{chat_and_user[0]}_{chat_and_user[1]}"
-
-
-def get_user_in_chat_from_event(event: Message) -> tuple[int, int]:
-    return event.chat.id, event.from_user.id
-
-
-def from_user_hash(from_id: int) -> int:
-    return from_id
-
-
-def get_user_from_event(event: Message) -> int:
-    return event.from_user.id
-
-
-MESSAGE_IN_CHAT = Hasher(
-    view_class=MessageView,
-    get_hash_from_data=from_chat_hash,
-    get_data_from_event=get_chat_from_event,
-)
-
-MESSAGE_FROM_USER = Hasher(
-    view_class=MessageView,
-    get_hash_from_data=from_user_hash,
-    get_data_from_event=get_user_from_event,
-)
-
-MESSAGE_FROM_USER_IN_CHAT = Hasher(
-    view_class=MessageView,
-    get_hash_from_data=from_user_in_chat_hash,
-    get_data_from_event=get_user_in_chat_from_event,
-)
-
-
-__all__ = (
+from telegrinder.bot.cute_types import MessageCute as Message
+from telegrinder.bot.dispatch.view import MessageView
+from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
+
+
+def from_chat_hash(chat_id: int) -> int:
+    return chat_id
+
+
+def get_chat_from_event(event: Message) -> int:
+    return event.chat.id
+
+
+def from_user_in_chat_hash(chat_and_user: tuple[int, int]) -> str:
+    return f"{chat_and_user[0]}_{chat_and_user[1]}"
+
+
+def get_user_in_chat_from_event(event: Message) -> tuple[int, int]:
+    return event.chat.id, event.from_user.id
+
+
+def from_user_hash(from_id: int) -> int:
+    return from_id
+
+
+def get_user_from_event(event: Message) -> int:
+    return event.from_user.id
+
+
+MESSAGE_IN_CHAT = Hasher(
+    view_class=MessageView,
+    get_hash_from_data=from_chat_hash,
+    get_data_from_event=get_chat_from_event,
+)
+
+MESSAGE_FROM_USER = Hasher(
+    view_class=MessageView,
+    get_hash_from_data=from_user_hash,
+    get_data_from_event=get_user_from_event,
+)
+
+MESSAGE_FROM_USER_IN_CHAT = Hasher(
+    view_class=MessageView,
+    get_hash_from_data=from_user_in_chat_hash,
+    get_data_from_event=get_user_in_chat_from_event,
+)
+
+
+__all__ = (
     "MESSAGE_FROM_USER",
     "MESSAGE_FROM_USER_IN_CHAT",
-    "MESSAGE_IN_CHAT",
-)
+    "MESSAGE_IN_CHAT",
+)