telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/bot/dispatch/view/base.py

@@ -0,0 +1,226 @@
+import typing
+from collections import deque
+
+from kungfu import Error, Ok, Pulse, Result
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.handler.func import FuncHandler, Function
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
+from telegrinder.bot.dispatch.process import check_rule, process_inner
+from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
+from telegrinder.bot.dispatch.view.abc import ABCView
+from telegrinder.bot.rules.abc import ABCRule, Always
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import (
+    BusinessConnection,
+    BusinessMessagesDeleted,
+    CallbackQuery,
+    ChatBoostRemoved,
+    ChatBoostUpdated,
+    ChatJoinRequest,
+    ChatMemberUpdated,
+    ChosenInlineResult,
+    InlineQuery,
+    Message,
+    MessageReactionCountUpdated,
+    MessageReactionUpdated,
+    PaidMediaPurchased,
+    Poll,
+    PollAnswer,
+    PreCheckoutQuery,
+    ShippingQuery,
+    Update,
+)
+
+if typing.TYPE_CHECKING:
+    from nodnod.agent.base import Agent
+
+type UpdateModel = typing.Union[
+    BusinessConnection,
+    BusinessMessagesDeleted,
+    CallbackQuery,
+    ChatBoostRemoved,
+    ChatBoostUpdated,
+    ChatJoinRequest,
+    ChatMemberUpdated,
+    ChosenInlineResult,
+    InlineQuery,
+    Message,
+    MessageReactionCountUpdated,
+    MessageReactionUpdated,
+    PaidMediaPurchased,
+    Poll,
+    PollAnswer,
+    PreCheckoutQuery,
+    ShippingQuery,
+]
+type ViewResult = Result[str, str] | Result[str, Exception]
+
+OK_CHECK: typing.Final = Ok()
+
+
+class View(ABCView):
+    filter: ABCRule
+    handlers: deque[ABCHandler]
+    middlewares: deque[ABCMiddleware]
+    return_manager: ABCReturnManager | None
+
+    def __init__(
+        self,
+        *,
+        agent_cls: type[Agent] | None = None,
+        return_manager: ABCReturnManager | None = None,
+    ) -> None:
+        self.filter = Always()
+        self.handlers = deque()
+        self.middlewares = deque()
+        self.agent_cls = agent_cls
+        self.return_manager = return_manager
+
+    def __bool__(self) -> bool:
+        return bool(self.handlers) or bool(self.middlewares)
+
+    def __repr__(self) -> str:
+        return "<{}>".format(type(self).__name__)
+
+    @property
+    def auto_rules(self) -> ABCRule:
+        return self.filter
+
+    @auto_rules.setter
+    def auto_rules(self, value: ABCRule | typing.Iterable[ABCRule], /) -> None:
+        for rule in (value,) if isinstance(value, ABCRule) else value:
+            self.filter &= rule
+
+    def __call__[T: Function](
+        self,
+        *rules: ABCRule,
+        final: bool = True,
+        agent: type[Agent] | None = None,
+    ) -> typing.Callable[[T], T]:
+        def decorator(function: T, /) -> T:
+            self.handlers.append(
+                FuncHandler(
+                    function=function,
+                    rules=rules,
+                    agent=agent or self.agent_cls,
+                    final=final,
+                ),
+            )
+            return function
+
+        return decorator
+
+    @typing.overload
+    def register_middleware[T: ABCMiddleware](self, middleware_cls: type[T], /) -> type[T]: ...
+
+    @typing.overload
+    def register_middleware(self, middleware: ABCMiddleware, /) -> None: ...
+
+    def register_middleware(
+        self,
+        middleware: type[ABCMiddleware] | ABCMiddleware,
+    ) -> typing.Callable[..., typing.Any] | None:
+        self.middlewares.append(middleware() if isinstance(middleware, type) else middleware)
+        return middleware if isinstance(middleware, type) else None
+
+    def load(self, external: typing.Self, /) -> None:
+        if not external:
+            return
+
+        self.handlers.extend(external.handlers)
+        self.middlewares.extend(external.middlewares)
+
+        if not isinstance(external.filter, Always):
+            self.filter &= external.filter
+
+        if external.return_manager is not None and self.return_manager is None:
+            self.return_manager = external.return_manager
+
+        elif self.return_manager is not None and external.return_manager is not None:
+            self.return_manager.managers.extend(external.return_manager.managers)
+
+    async def check(self, api: API, update: Update, context: Context) -> Pulse[str]:
+        if not bool(self):
+            return Error("View is empty.")
+
+        if not await check_rule(self.filter, context):
+            return Error("Filter is failed.")
+
+        return OK_CHECK
+
+    async def process(self, api: API, update: Update, context: Context) -> ViewResult:
+        return await process_inner(
+            api,
+            update,
+            context,
+            self,
+        )
+
+
+class EventView(View):
+    def __init__(
+        self,
+        update_type: UpdateType,
+        return_manager: ABCReturnManager | None = None,
+        agent_cls: type[Agent] | None = None,
+    ) -> None:
+        super().__init__(
+            agent_cls=agent_cls,
+            return_manager=return_manager,
+        )
+        self.update_type = update_type
+
+    def __repr__(self) -> str:
+        return "<{}: {!r}>".format(type(self).__name__, self.update_type)
+
+    async def check(self, api: API, update: Update, context: Context) -> Pulse[str]:
+        # If update is not of the expected, instantly skip checking the view
+        if update.update_type != self.update_type:
+            return Error(f"Incoming event `{update.update_type!r}` is not `{self.update_type!r}`.")
+        return await super().check(api, update, context)
+
+
+class EventModelView[T: (UpdateModel)](View):
+    def __init__(
+        self,
+        model: type[T],
+        return_manager: ABCReturnManager | None = None,
+        agent_cls: type[Agent] | None = None,
+    ) -> None:
+        super().__init__(
+            agent_cls=agent_cls,
+            return_manager=return_manager,
+        )
+        self.model = model
+
+    def __repr__(self) -> str:
+        return "<{}: {}>".format(type(self).__name__, self.model.__name__)
+
+    async def check(self, api: API, update: Update, context: Context) -> Pulse[str]:
+        # If update object is not of the expected type of object, instantly skip checking the view
+        if update.incoming_update.__class__ is not self.model:
+            return Error(
+                f"Incoming event model `{update.incoming_update.__class__.__name__!r}`"
+                f" is not `{self.model.__name__!r}`.",
+            )
+        return await super().check(api, update, context)
+
+
+class ErrorView(View):
+    async def process(self, api: API, update: Update, context: Context) -> ViewResult:
+        result = await super().process(api, update, context)
+
+        if not result and context.exception_update:
+            return Error(context.exception_update.unwrap())
+
+        return result
+
+
+class RawEventView(View):
+    pass
+
+
+__all__ = ("ErrorView", "EventView", "RawEventView", "View")

telegrinder/bot/dispatch/view/box.py

@@ -0,0 +1,207 @@
+import dataclasses
+import typing
+from functools import cached_property
+from types import MappingProxyType
+
+from telegrinder.bot.dispatch.return_manager.callback_query import CallbackQueryReturnManager
+from telegrinder.bot.dispatch.return_manager.inline_query import InlineQueryReturnManager
+from telegrinder.bot.dispatch.return_manager.message import MessageReturnManager
+from telegrinder.bot.dispatch.return_manager.pre_checkout_query import PreCheckoutQueryReturnManager
+from telegrinder.bot.dispatch.view.base import (
+    ErrorView,
+    EventView,
+    RawEventView,
+    View,
+)
+from telegrinder.bot.dispatch.view.media_group import MediaGroupView
+from telegrinder.types.enums import UpdateType
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
+
+EXCLUDE_VIEW_META: typing.Final = dict(exclude_view=True)
+
+
+def event_view[T: EventView](
+    update_type: UpdateType,
+    return_manager: ABCReturnManager | None = None,
+    /,
+) -> typing.Callable[[], T]:
+    def factory() -> T:
+        return typing.cast("T", EventView(update_type, return_manager))
+
+    return factory
+
+
+def view[T: View](
+    view_class: type[View],
+    return_manager: ABCReturnManager | None = None,
+    /,
+) -> typing.Callable[[], T]:
+    def factory() -> T:
+        return typing.cast("T", view_class(return_manager=return_manager))
+
+    return factory
+
+
+event_model_view = view
+
+
+@dataclasses.dataclass(kw_only=True)
+class EventViewBox[
+    MessageView: EventView = EventView,
+    EditedMessageView: EventView = EventView,
+    ChannelPostView: EventView = EventView,
+    EditedChannelPostView: EventView = EventView,
+    BusinessConnectionView: EventView = EventView,
+    BusinessMessageView: EventView = EventView,
+    EditedBusinessMessageView: EventView = EventView,
+    DeletedBusinessMessagesView: EventView = EventView,
+    MessageReactionView: EventView = EventView,
+    MessageReactionCountView: EventView = EventView,
+    InlineQueryView: EventView = EventView,
+    ChosenInlineResultView: EventView = EventView,
+    CallbackQueryView: EventView = EventView,
+    ShippingQueryView: EventView = EventView,
+    PreCheckoutQueryView: EventView = EventView,
+    PurchasedPaidMediaView: EventView = EventView,
+    PollView: EventView = EventView,
+    PollAnswerView: EventView = EventView,
+    MyChatMemberView: EventView = EventView,
+    ChatMemberView: EventView = EventView,
+    ChatJoinRequestView: EventView = EventView,
+    ChatBoostView: EventView = EventView,
+    RemovedChatBoostView: EventView = EventView,
+]:
+    message: MessageView = dataclasses.field(default_factory=event_view(UpdateType.MESSAGE, MessageReturnManager()))
+    edited_message: EditedMessageView = dataclasses.field(
+        default_factory=event_view(UpdateType.EDITED_MESSAGE, MessageReturnManager()),
+    )
+    channel_post: ChannelPostView = dataclasses.field(
+        default_factory=event_view(UpdateType.CHANNEL_POST, MessageReturnManager()),
+    )
+    edited_channel_post: EditedChannelPostView = dataclasses.field(
+        default_factory=event_view(UpdateType.EDITED_CHANNEL_POST, MessageReturnManager()),
+    )
+    business_connection: BusinessConnectionView = dataclasses.field(
+        default_factory=event_view(UpdateType.BUSINESS_CONNECTION),
+    )
+    business_message: BusinessMessageView = dataclasses.field(
+        default_factory=event_view(UpdateType.BUSINESS_MESSAGE, MessageReturnManager()),
+    )
+    edited_business_message: EditedBusinessMessageView = dataclasses.field(
+        default_factory=event_view(UpdateType.EDITED_BUSINESS_MESSAGE, MessageReturnManager()),
+    )
+    deleted_business_messages: DeletedBusinessMessagesView = dataclasses.field(
+        default_factory=event_view(UpdateType.DELETED_BUSINESS_MESSAGES),
+    )
+    message_reaction: MessageReactionView = dataclasses.field(default_factory=event_view(UpdateType.MESSAGE_REACTION))
+    message_reaction_count: MessageReactionCountView = dataclasses.field(
+        default_factory=event_view(UpdateType.MESSAGE_REACTION_COUNT),
+    )
+    inline_query: InlineQueryView = dataclasses.field(
+        default_factory=event_view(UpdateType.INLINE_QUERY, InlineQueryReturnManager()),
+    )
+    chosen_inline_result: ChosenInlineResultView = dataclasses.field(
+        default_factory=event_view(UpdateType.CHOSEN_INLINE_RESULT),
+    )
+    callback_query: CallbackQueryView = dataclasses.field(
+        default_factory=event_view(UpdateType.CALLBACK_QUERY, CallbackQueryReturnManager()),
+    )
+    shipping_query: ShippingQueryView = dataclasses.field(default_factory=event_view(UpdateType.SHIPPING_QUERY))
+    pre_checkout_query: PreCheckoutQueryView = dataclasses.field(
+        default_factory=event_view(UpdateType.PRE_CHECKOUT_QUERY, PreCheckoutQueryReturnManager()),
+    )
+    purchased_paid_media: PurchasedPaidMediaView = dataclasses.field(
+        default_factory=event_view(UpdateType.PURCHASED_PAID_MEDIA),
+    )
+    poll: PollView = dataclasses.field(default_factory=event_view(UpdateType.POLL))
+    poll_answer: PollAnswerView = dataclasses.field(default_factory=event_view(UpdateType.POLL_ANSWER))
+    my_chat_member: MyChatMemberView = dataclasses.field(default_factory=event_view(UpdateType.MY_CHAT_MEMBER))
+    chat_member: ChatMemberView = dataclasses.field(default_factory=event_view(UpdateType.CHAT_MEMBER))
+    chat_join_request: ChatJoinRequestView = dataclasses.field(default_factory=event_view(UpdateType.CHAT_JOIN_REQUEST))
+    chat_boost: ChatBoostView = dataclasses.field(default_factory=event_view(UpdateType.CHAT_BOOST))
+    removed_chat_boost: RemovedChatBoostView = dataclasses.field(
+        default_factory=event_view(UpdateType.REMOVED_CHAT_BOOST),
+    )
+
+
+@dataclasses.dataclass(kw_only=True)
+class EventModelViewBox[MediaGroup: View = MediaGroupView]:
+    media_group: MediaGroup = dataclasses.field(
+        default_factory=event_model_view(MediaGroupView, MessageReturnManager())
+    )
+
+
+@dataclasses.dataclass(kw_only=True)
+class ViewBox[
+    MessageView: EventView = EventView,
+    EditedMessageView: EventView = EventView,
+    ChannelPostView: EventView = EventView,
+    EditedChannelPostView: EventView = EventView,
+    BusinessConnectionView: EventView = EventView,
+    BusinessMessageView: EventView = EventView,
+    EditedBusinessMessageView: EventView = EventView,
+    DeletedBusinessMessagesView: EventView = EventView,
+    MessageReactionView: EventView = EventView,
+    MessageReactionCountView: EventView = EventView,
+    InlineQueryView: EventView = EventView,
+    ChosenInlineResultView: EventView = EventView,
+    CallbackQueryView: EventView = EventView,
+    ShippingQueryView: EventView = EventView,
+    PreCheckoutQueryView: EventView = EventView,
+    PurchasedPaidMediaView: EventView = EventView,
+    PollView: EventView = EventView,
+    PollAnswerView: EventView = EventView,
+    MyChatMemberView: EventView = EventView,
+    ChatMemberView: EventView = EventView,
+    ChatJoinRequestView: EventView = EventView,
+    ChatBoostView: EventView = EventView,
+    RemovedChatBoostView: EventView = EventView,
+    MediaGroup: View = MediaGroupView,
+    Error: ErrorView = ErrorView,
+    RawEvent: RawEventView = RawEventView,
+](
+    EventModelViewBox[MediaGroup],
+    EventViewBox[
+        MessageView,
+        EditedMessageView,
+        ChannelPostView,
+        EditedChannelPostView,
+        BusinessConnectionView,
+        BusinessMessageView,
+        EditedBusinessMessageView,
+        DeletedBusinessMessagesView,
+        MessageReactionView,
+        MessageReactionCountView,
+        InlineQueryView,
+        ChosenInlineResultView,
+        CallbackQueryView,
+        ShippingQueryView,
+        PreCheckoutQueryView,
+        PurchasedPaidMediaView,
+        PollView,
+        PollAnswerView,
+        MyChatMemberView,
+        ChatMemberView,
+        ChatJoinRequestView,
+        ChatBoostView,
+        RemovedChatBoostView,
+    ],
+):
+    event_error: Error = dataclasses.field(default_factory=view(ErrorView), metadata=EXCLUDE_VIEW_META)
+    raw: RawEvent = dataclasses.field(default_factory=view(RawEventView), metadata=EXCLUDE_VIEW_META)
+
+    @cached_property
+    def views(self) -> MappingProxyType[str, View]:
+        return MappingProxyType(
+            mapping={
+                field.name: obj
+                for field in dataclasses.fields(self)
+                if isinstance(obj := getattr(self, field.name), View)
+                and field.metadata.get("exclude_view", False) is False
+            },
+        )
+
+
+__all__ = ("EventModelViewBox", "EventViewBox", "ViewBox")

telegrinder/bot/dispatch/view/media_group.py

@@ -0,0 +1,25 @@
+import typing
+
+from telegrinder.bot.dispatch.view.base import EventModelView
+from telegrinder.bot.rules.media import IsMediaGroup
+from telegrinder.types.objects import Message
+
+if typing.TYPE_CHECKING:
+    from nodnod.agent.base import Agent
+
+    from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
+
+
+class MediaGroupView(EventModelView[Message]):
+    def __init__(
+        self,
+        *,
+        return_manager: ABCReturnManager | None = None,
+        agent_cls: type[Agent] | None = None,
+    ) -> None:
+        super().__init__(model=Message, return_manager=return_manager, agent_cls=agent_cls)
+
+        self.filter = IsMediaGroup()
+
+
+__all__ = ("MediaGroupView",)

telegrinder/bot/dispatch/waiter_machine/__init__.py

@@ -0,0 +1,25 @@
+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,
+)
+from telegrinder.bot.dispatch.waiter_machine.machine import WaiterMachine
+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",
+    "MESSAGE_FROM_USER",
+    "MESSAGE_FROM_USER_IN_CHAT",
+    "MESSAGE_IN_CHAT",
+    "Hasher",
+    "ShortState",
+    "WaiterMachine",
+    "WaiterMiddleware",
+)

telegrinder/bot/dispatch/waiter_machine/actions.py

@@ -0,0 +1,16 @@
+import typing
+
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.cute_types.base import BaseCute
+
+type OnDrop[Event: BaseCute[typing.Any] = typing.Any] = typing.Callable[..., typing.Awaitable[typing.Any] | typing.Any]
+
+
+class WaiterActions[Event: BaseCute[typing.Any] = typing.Any](typing.TypedDict):
+    on_miss: typing.NotRequired[ABCHandler]
+    on_drop: typing.NotRequired[OnDrop[Event]]
+
+
+__all__ = ("WaiterActions",)

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

@@ -0,0 +1,13 @@
+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
+
+__all__ = (
+    "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",
+)

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

@@ -0,0 +1,53 @@
+from kungfu.library.monad.option import Some
+
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute as CallbackQuery
+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.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(
+    get_hash_from_data=from_chat_hash,
+    get_data_from_event=get_chat_from_event,
+)
+
+CALLBACK_QUERY_FOR_MESSAGE = Hasher(
+    get_hash_from_data=for_message_hash,
+    get_data_from_event=get_message_for_event,
+)
+
+CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE = Hasher(
+    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",
+)

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

@@ -0,0 +1,61 @@
+import secrets
+import typing
+
+from kungfu.library.misc import from_optional
+from kungfu.library.monad.option import Option
+
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.dispatch.view.base import View
+
+type HasherWithData[Event: BaseCute, Data] = tuple[Hasher[Event, Data], View, Data]
+
+Event = typing.TypeVar("Event", bound=BaseCute, covariant=True)
+Data = typing.TypeVar("Data", covariant=True)
+
+
+def ECHO[T](__x: T) -> T:  # noqa
+    return __x
+
+
+class Hasher(typing.Generic[Event, Data]):
+    def __init__(
+        self,
+        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.code = secrets.token_hex(8)
+        self._get_hash_from_data = get_hash_from_data
+        self._get_data_from_event = get_data_from_event
+
+    def __call__[D](
+        self: Hasher[Event, D],
+        view: View,
+        data: D,
+        /,
+    ) -> HasherWithData[Event, D]:
+        return (self, view, data)
+
+    def __hash__(self) -> int:
+        return hash(self.code)
+
+    def __repr__(self) -> str:
+        return f"<Hasher {self.code}>"
+
+    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).then(self.get_hash_from_data)
+
+
+__all__ = ("Hasher",)

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

@@ -0,0 +1,49 @@
+from telegrinder.bot.cute_types.message import MessageCute as Message
+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(
+    get_hash_from_data=from_chat_hash,
+    get_data_from_event=get_chat_from_event,
+)
+
+MESSAGE_FROM_USER = Hasher(
+    get_hash_from_data=from_user_hash,
+    get_data_from_event=get_user_from_event,
+)
+
+MESSAGE_FROM_USER_IN_CHAT = Hasher(
+    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",
+)