telegrinder 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

telegrinder/bot/dispatch/return_manager/inline_query.py

@@ -1,12 +1,12 @@
 import typing
 
-from telegrinder.bot.cute_types import InlineQueryCute
+from telegrinder.bot.cute_types.inline_query import InlineQueryCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
 
 
 class InlineQueryReturnManager(BaseReturnManager[InlineQueryCute]):
-    @register_manager(dict)
+    @register_manager(dict[str, typing.Any])
     @staticmethod
     async def dict_manager(value: dict[str, typing.Any], event: InlineQueryCute, ctx: Context) -> None:
         await event.answer(**value)

telegrinder/bot/dispatch/return_manager/message.py

@@ -1,6 +1,6 @@
 import typing
 
-from telegrinder.bot.cute_types import MessageCute
+from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
 from telegrinder.tools.formatting import HTMLFormatter
@@ -12,7 +12,7 @@ class MessageReturnManager(BaseReturnManager[MessageCute]):
     async def str_manager(value: str, event: MessageCute, ctx: Context) -> None:
         await event.answer(value)
 
-    @register_manager(list | tuple)
+    @register_manager(list[str] | tuple[str, ...])
     @staticmethod
     async def seq_manager(
         value: list[str] | tuple[str, ...],
@@ -22,7 +22,7 @@ class MessageReturnManager(BaseReturnManager[MessageCute]):
         for message in value:
             await event.answer(message)
 
-    @register_manager(dict)
+    @register_manager(dict[str, typing.Any])
     @staticmethod
     async def dict_manager(value: dict[str, typing.Any], event: MessageCute, ctx: Context) -> None:
         await event.answer(**value)

telegrinder/bot/dispatch/view/__init__.py

@@ -1,4 +1,5 @@
-from telegrinder.bot.dispatch.view.abc import ABCStateView, ABCView, BaseStateView, BaseView
+from telegrinder.bot.dispatch.view.abc import ABCStateView, ABCView
+from telegrinder.bot.dispatch.view.base import BaseStateView, BaseView
 from telegrinder.bot.dispatch.view.box import ViewBox
 from telegrinder.bot.dispatch.view.callback_query import CallbackQueryView
 from telegrinder.bot.dispatch.view.chat_join_request import ChatJoinRequestView

telegrinder/bot/dispatch/view/abc.py

@@ -1,30 +1,12 @@
 import typing
 from abc import ABC, abstractmethod
-from functools import cached_property
 
-from fntypes.co import Nothing, Some
-
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
-from telegrinder.bot.dispatch.handler.func import FuncHandler
-from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
-from telegrinder.bot.dispatch.process import process_inner
-from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
-from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.model import Model
-from telegrinder.msgspec_utils import Option
-from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
 from telegrinder.types.objects import Update
 
 Event = typing.TypeVar("Event", bound=BaseCute)
-ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler)
-MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
-
-FuncType: typing.TypeAlias = typing.Callable[
-    typing.Concatenate[Event, ...],
-    typing.Coroutine[typing.Any, typing.Any, typing.Any],
-]
 
 
 class ABCView(ABC):
@@ -54,169 +36,8 @@ class ABCStateView(ABCView, typing.Generic[Event]):
         pass
 
 
-class BaseView(ABCView, typing.Generic[Event]):
-    auto_rules: list[ABCRule]
-    handlers: list[ABCHandler[Event]]
-    middlewares: list[ABCMiddleware[Event]]
-    return_manager: ABCReturnManager[Event] | None = None
-
-    @staticmethod
-    def get_raw_event(update: Update) -> Option[Model]:
-        return getattr(update, update.update_type.value)
-
-    @cached_property
-    def get_event_type(self) -> Option[type[Event]]:
-        for base in self.__class__.__dict__.get("__orig_bases__", ()):
-            if issubclass(typing.get_origin(base) or base, ABCView):
-                for generic_type in typing.get_args(base):
-                    if issubclass(typing.get_origin(generic_type) or generic_type, BaseCute):
-                        return Some(generic_type)
-        return Nothing()
-
-    @typing.overload
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule,
-    ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
-    ]: ...
-
-    @typing.overload
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
-
-    @typing.overload
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule,
-        error_handler: typing.Literal[None] = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
-    ]: ...
-
-    @classmethod
-    def to_handler(  # type: ignore
-        cls,
-        *rules: ABCRule,
-        error_handler: ABCErrorHandler | None = None,
-        is_blocking: bool = True,
-    ):
-        def wrapper(func: FuncType[Event]):
-            return FuncHandler(
-                func,
-                list(rules),
-                is_blocking=is_blocking,
-                dataclass=None,
-                error_handler=error_handler or ErrorHandler(),
-            )
-
-        return wrapper
-
-    @typing.overload
-    def __call__(
-        self,
-        *rules: ABCRule,
-    ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
-    ]: ...
-
-    @typing.overload
-    def __call__(  # type: ignore
-        self,
-        *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def __call__(
-        self,
-        *rules: ABCRule,
-        error_handler: typing.Literal[None] = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
-    ]: ...
-
-    def __call__(  # type: ignore
-        self,
-        *rules: ABCRule,
-        error_handler: ABCErrorHandler | None = None,
-        is_blocking: bool = True,
-    ):
-        def wrapper(func: FuncType[Event]):
-            func_handler = FuncHandler(
-                func,
-                [*self.auto_rules, *rules],
-                is_blocking=is_blocking,
-                dataclass=None,
-                error_handler=error_handler or ErrorHandler(),
-            )
-            self.handlers.append(func_handler)
-            return func_handler
-
-        return wrapper
-
-    def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
-        def wrapper(cls: type[MiddlewareT]) -> type[MiddlewareT]:
-            self.middlewares.append(cls(*args, **kwargs))
-            return cls
-
-        return wrapper
-
-    async def check(self, event: Update) -> bool:
-        match self.get_raw_event(event):
-            case Some(e) if issubclass(
-                self.get_event_type.expect(
-                    "{!r} has no event type in generic.".format(self.__class__.__name__),
-                ),
-                e.__class__,
-            ) and (self.handlers or self.middlewares):
-                return True
-            case _:
-                return False
-
-    async def process(self, event: Update, api: API) -> bool:
-        return await process_inner(
-            api,
-            self.get_event_type.unwrap().from_update(
-                update=self.get_raw_event(event).unwrap(),
-                bound_api=api,
-            ),
-            event,
-            self.middlewares,
-            self.handlers,
-            self.return_manager,
-        )
-
-    def load(self, external: typing.Self) -> None:
-        self.auto_rules.extend(external.auto_rules)
-        self.handlers.extend(external.handlers)
-        self.middlewares.extend(external.middlewares)
-
-
-class BaseStateView(ABCStateView[Event], BaseView[Event], ABC, typing.Generic[Event]):
-    @abstractmethod
-    def get_state_key(self, event: Event) -> int | None:
-        pass
-
-
 __all__ = (
-    "ABCStateView",
     "ABCEventRawView",
+    "ABCStateView",
     "ABCView",
-    "BaseStateView",
-    "BaseView",
 )

telegrinder/bot/dispatch/view/base.py

@@ -0,0 +1,200 @@
+import typing
+from abc import ABC, abstractmethod
+from functools import cached_property
+
+from fntypes.option import Nothing, Some
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.handler.func import FuncHandler
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
+from telegrinder.bot.dispatch.process import process_inner
+from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
+from telegrinder.bot.dispatch.view.abc import ABCStateView, ABCView
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.model import Model
+from telegrinder.msgspec_utils import Option
+from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
+from telegrinder.types.objects import Update
+
+Event = typing.TypeVar("Event", bound=BaseCute)
+ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler)
+MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
+
+FuncType: typing.TypeAlias = typing.Callable[
+    typing.Concatenate[Event, ...],
+    typing.Coroutine[typing.Any, typing.Any, typing.Any],
+]
+
+
+def get_event_model_class(view: "BaseView[Event]") -> Option[type[Event]]:
+    for base in view.__class__.__bases__ + (view.__class__,):
+        if "__orig_bases__" not in base.__dict__:
+            continue
+
+        for orig_base in base.__dict__["__orig_bases__"]:
+            origin_base = typing.get_origin(orig_base) or orig_base
+            if not isinstance(origin_base, type) and not issubclass(origin_base, object):
+                continue
+
+            for generic_type in typing.get_args(orig_base):
+                orig_generic_type = typing.get_origin(generic_type) or generic_type
+                if isinstance(orig_generic_type, type) and issubclass(orig_generic_type, BaseCute):
+                    return Some(generic_type)
+
+    return Nothing()
+
+
+class BaseView(ABCView, typing.Generic[Event]):
+    auto_rules: list[ABCRule]
+    handlers: list[ABCHandler[Event]]
+    middlewares: list[ABCMiddleware[Event]]
+    return_manager: ABCReturnManager[Event] | None = None
+
+    @staticmethod
+    def get_raw_event(update: Update) -> Option[Model]:
+        return getattr(update, update.update_type.value)
+
+    @cached_property
+    def event_model_class(self) -> Option[type[Event]]:
+        return get_event_model_class(self)
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule,
+    ) -> typing.Callable[
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+    ]: ...
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule,
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule,
+        error_handler: typing.Literal[None] = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+    ]: ...
+
+    @classmethod
+    def to_handler(  # type: ignore
+        cls,
+        *rules: ABCRule,
+        error_handler: ABCErrorHandler | None = None,
+        is_blocking: bool = True,
+    ):
+        def wrapper(func: FuncType[Event]):
+            return FuncHandler(
+                func,
+                list(rules),
+                is_blocking=is_blocking,
+                dataclass=None,
+                error_handler=error_handler or ErrorHandler(),
+            )
+
+        return wrapper
+
+    @typing.overload
+    def __call__(
+        self,
+        *rules: ABCRule,
+    ) -> typing.Callable[
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+    ]: ...
+
+    @typing.overload
+    def __call__(  # type: ignore
+        self,
+        *rules: ABCRule,
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        *rules: ABCRule,
+        error_handler: typing.Literal[None] = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+    ]: ...
+
+    def __call__(  # type: ignore
+        self,
+        *rules: ABCRule,
+        error_handler: ABCErrorHandler | None = None,
+        is_blocking: bool = True,
+    ):
+        def wrapper(func: FuncType[Event]):
+            func_handler = FuncHandler(
+                func,
+                [*self.auto_rules, *rules],
+                is_blocking=is_blocking,
+                dataclass=None,
+                error_handler=error_handler or ErrorHandler(),
+            )
+            self.handlers.append(func_handler)
+            return func_handler
+
+        return wrapper
+
+    def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
+        def wrapper(cls: type[MiddlewareT]) -> type[MiddlewareT]:
+            self.middlewares.append(cls(*args, **kwargs))
+            return cls
+
+        return wrapper
+
+    async def check(self, event: Update) -> bool:
+        match self.get_raw_event(event):
+            case Some(e) if issubclass(
+                self.event_model_class.expect(
+                    "{!r} has no event model class in generic.".format(self.__class__.__qualname__),
+                ),
+                e.__class__,
+            ) and (self.handlers or self.middlewares):
+                return True
+            case _:
+                return False
+
+    async def process(self, event: Update, api: API) -> bool:
+        return await process_inner(
+            api,
+            self.event_model_class.unwrap().from_update(
+                update=self.get_raw_event(event).unwrap(),
+                bound_api=api,
+            ),
+            event,
+            self.middlewares,
+            self.handlers,
+            self.return_manager,
+        )
+
+    def load(self, external: typing.Self) -> None:
+        self.auto_rules.extend(external.auto_rules)
+        self.handlers.extend(external.handlers)
+        self.middlewares.extend(external.middlewares)
+
+
+class BaseStateView(ABCStateView[Event], BaseView[Event], ABC, typing.Generic[Event]):
+    @abstractmethod
+    def get_state_key(self, event: Event) -> int | None:
+        pass

telegrinder/bot/dispatch/view/callback_query.py

@@ -1,6 +1,6 @@
-from telegrinder.bot.cute_types import CallbackQueryCute
-from telegrinder.bot.dispatch.return_manager import CallbackQueryReturnManager
-from telegrinder.bot.dispatch.view.abc import BaseStateView
+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]):

telegrinder/bot/dispatch/view/chat_join_request.py

@@ -1,5 +1,5 @@
-from telegrinder.bot.cute_types import ChatJoinRequestCute
-from telegrinder.bot.dispatch.view.abc import BaseStateView
+from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
+from telegrinder.bot.dispatch.view.base import BaseStateView
 
 
 class ChatJoinRequestView(BaseStateView[ChatJoinRequestCute]):

telegrinder/bot/dispatch/view/chat_member.py

@@ -1,7 +1,7 @@
 import typing
 
-from telegrinder.bot.cute_types import ChatMemberUpdatedCute
-from telegrinder.bot.dispatch.view.abc import BaseStateView
+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
 
@@ -28,7 +28,6 @@ class ChatMemberView(BaseStateView[ChatMemberUpdatedCute]):
     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

telegrinder/bot/dispatch/view/inline_query.py

@@ -1,6 +1,6 @@
-from telegrinder.bot.cute_types import InlineQueryCute
+from telegrinder.bot.cute_types.inline_query import InlineQueryCute
 from telegrinder.bot.dispatch.return_manager import InlineQueryReturnManager
-from telegrinder.bot.dispatch.view.abc import BaseStateView
+from telegrinder.bot.dispatch.view.base import BaseStateView
 
 
 class InlineQueryView(BaseStateView[InlineQueryCute]):

telegrinder/bot/dispatch/view/message.py

@@ -1,9 +1,10 @@
 import typing
 
-from telegrinder.bot.cute_types import MessageCute
-from telegrinder.bot.dispatch.return_manager import MessageReturnManager
-from telegrinder.bot.dispatch.view.abc import BaseStateView
-from telegrinder.types import Update, UpdateType
+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,

telegrinder/bot/dispatch/view/raw.py

@@ -1,10 +1,11 @@
 import typing
 
-from telegrinder.api import API
-from telegrinder.bot.cute_types import UpdateCute
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.handler.func import FuncHandler
 from telegrinder.bot.dispatch.process import process_inner
-from telegrinder.bot.dispatch.view.abc import ABCEventRawView, BaseView, ErrorHandlerT
+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

telegrinder/bot/dispatch/waiter_machine/__init__.py

@@ -1,9 +1,27 @@
+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",
+    "Hasher",
+    "MESSAGE_FROM_USER",
+    "MESSAGE_FROM_USER_IN_CHAT",
+    "MESSAGE_IN_CHAT",
     "ShortState",
+    "StateViewHasher",
     "WaiterMachine",
     "WaiterMiddleware",
     "clear_wm_storage_worker",

telegrinder/bot/dispatch/waiter_machine/actions.py

@@ -0,0 +1,10 @@
+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]]

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

@@ -0,0 +1,15 @@
+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",
+    "Hasher",
+    "MESSAGE_FROM_USER",
+    "MESSAGE_FROM_USER_IN_CHAT",
+    "MESSAGE_IN_CHAT",
+    "StateViewHasher",
+)

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

@@ -0,0 +1,60 @@
+from fntypes import Some
+
+from telegrinder.bot.cute_types import CallbackQueryCute as CallbackQuery
+from telegrinder.bot.dispatch.view import CallbackQueryView
+
+from .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()
+
+
+CALLBACK_QUERY_FROM_CHAT = Hasher(
+    view=CallbackQueryView,
+    get_hash_from_data=from_chat_hash,
+    get_data_from_event=get_chat_from_event,
+)
+
+
+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()
+
+
+CALLBACK_QUERY_FOR_MESSAGE = Hasher(
+    view=CallbackQueryView,
+    get_hash_from_data=for_message_hash,
+    get_data_from_event=get_message_for_event,
+)
+
+
+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_IN_CHAT_FOR_MESSAGE = Hasher(
+    view=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",
+)