telegrinder 0.3.0.post1__tar.gz → 0.3.1__tar.gz

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.3.0.post1
+Version: 0.3.1
 Summary: Modern visionary telegram bot framework.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.3.0.post1"
+version = "0.3.1"
 description = "Modern visionary telegram bot framework."
 authors = ["timoniq <tesseradecades@mail.ru>"]
 maintainers = ["luwqz1 <howluwqz1@gmail.com>"]

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/cute_types/callback_query.py

@@ -9,19 +9,7 @@ from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, sho
 from telegrinder.bot.cute_types.message import MediaType, MessageCute, ReplyMarkup, execute_method_edit
 from telegrinder.model import get_params
 from telegrinder.msgspec_utils import Option, decoder
-from telegrinder.types.objects import (
-    CallbackQuery,
-    Chat,
-    InaccessibleMessage,
-    InlineKeyboardMarkup,
-    InputFile,
-    InputMedia,
-    LinkPreviewOptions,
-    MessageEntity,
-    MessageId,
-    ReplyParameters,
-    User,
-)
+from telegrinder.types.objects import *
 
 
 class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
@@ -81,7 +69,7 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
         if "cached_callback_data" in self.__dict__:
             return self.__dict__["cached_callback_data"]
         data = Nothing()
-        with suppress(msgspec.ValidationError):
+        with suppress(msgspec.ValidationError, msgspec.DecodeError):
             data = Some(decoder.decode(self.data.unwrap()))
         self.__dict__["cached_callback_data"] = data
         return data

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/cute_types/chat_join_request.py

@@ -5,7 +5,7 @@ from fntypes.result import Result
 from telegrinder.api import API, APIError
 from telegrinder.bot.cute_types.base import BaseCute, shortcut
 from telegrinder.bot.cute_types.chat_member_updated import ChatMemberShortcuts, chat_member_interaction
-from telegrinder.types.objects import ChatJoinRequest, User
+from telegrinder.types.objects import *
 
 
 class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMemberShortcuts, kw_only=True):

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/cute_types/chat_member_updated.py

@@ -6,7 +6,7 @@ from fntypes.result import Result
 from telegrinder.api import API, APIError
 from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
 from telegrinder.model import get_params
-from telegrinder.types.objects import ChatMemberUpdated, ChatPermissions, User
+from telegrinder.types.objects import *
 
 
 async def chat_member_interaction(

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/cute_types/inline_query.py

@@ -5,12 +5,7 @@ from fntypes.result import Result
 from telegrinder.api import API, APIError
 from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
 from telegrinder.model import get_params
-from telegrinder.types import (
-    InlineQuery,
-    InlineQueryResult,
-    InlineQueryResultsButton,
-    User,
-)
+from telegrinder.types.objects import *
 
 
 class InlineQueryCute(BaseCute[InlineQuery], InlineQuery, kw_only=True):

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/cute_types/message.py

@@ -15,27 +15,7 @@ from telegrinder.bot.cute_types.utils import (
 )
 from telegrinder.model import get_params
 from telegrinder.msgspec_utils import Nothing, Option
-from telegrinder.types.objects import (
-    ChatAction,
-    DiceEmoji,
-    ForceReply,
-    InaccessibleMessage,
-    InlineKeyboardMarkup,
-    InputFile,
-    InputMedia,
-    InputPollOption,
-    LabeledPrice,
-    LinkPreviewOptions,
-    Message,
-    MessageEntity,
-    MessageId,
-    ReactionEmoji,
-    ReactionType,
-    ReplyKeyboardMarkup,
-    ReplyKeyboardRemove,
-    ReplyParameters,
-    User,
-)
+from telegrinder.types import *
 
 if typing.TYPE_CHECKING:
     from datetime import datetime

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/cute_types/update.py

@@ -11,7 +11,7 @@ from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
 from telegrinder.bot.cute_types.inline_query import InlineQueryCute
 from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.msgspec_utils import Option
-from telegrinder.types.objects import Model, Update
+from telegrinder.types.objects import *
 
 EventModel = typing.TypeVar("EventModel", bound=Model)
 

telegrinder-0.3.1/telegrinder/bot/dispatch/abc.py

@@ -0,0 +1,77 @@
+import importlib.util as importlib_util
+import os
+import pathlib
+import sys
+import typing
+from abc import ABC, abstractmethod
+
+from fntypes.option import Option
+
+from telegrinder.api.api import API
+from telegrinder.tools.global_context.abc import ABCGlobalContext
+from telegrinder.types.objects import Update
+
+T = typing.TypeVar("T")
+
+
+class PathExistsError(BaseException):
+    pass
+
+
+class ABCDispatch(ABC):
+    @property
+    @abstractmethod
+    def global_context(self) -> ABCGlobalContext:
+        pass
+
+    @abstractmethod
+    async def feed(self, event: Update, api: API) -> bool:
+        pass
+
+    @abstractmethod
+    def load(self, external: typing.Self) -> None:
+        pass
+
+    @abstractmethod
+    def get_view(self, of_type: type[T]) -> Option[T]:
+        pass
+
+    def load_many(self, *externals: typing.Self) -> None:
+        for external in externals:
+            self.load(external)
+
+    def load_from_dir(self, directory: str | pathlib.Path) -> bool:
+        """Loads dispatchers from a directory containing Python modules where global variables
+        are declared with instances of dispatch.
+        Returns True if dispatchers were found, otherwise False."""
+
+        directory = pathlib.Path(directory)
+
+        if not directory.exists():
+            raise PathExistsError(f"Path {str(directory)!r} does not exists.")
+
+        dps: list[typing.Self] = []
+        for root, _, files in os.walk(directory):
+            for f in files:
+                if f.endswith(".py") and f != "__init__.py":
+                    module_path = os.path.join(root, f)
+                    module_name = os.path.splitext(os.path.relpath(module_path, directory))[0]
+                    module_name = module_name.replace(os.sep, ".")
+
+                    spec = importlib_util.spec_from_file_location(module_name, module_path)
+                    if spec is None or spec.loader is None:
+                        continue
+
+                    module = importlib_util.module_from_spec(spec)
+                    sys.modules[module_name] = module
+                    spec.loader.exec_module(module)
+
+                    for obj in module.__dict__.values():
+                        if isinstance(obj, self.__class__):
+                            dps.append(obj)
+
+        self.load_many(*dps)
+        return bool(dps)
+
+
+__all__ = ("ABCDispatch",)

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/dispatch/dispatch.py

@@ -1,6 +1,6 @@
 import dataclasses
-import typing
 
+import typing_extensions as typing
 from fntypes import Nothing, Option, Some
 from vbml.patcher import Patcher
 
@@ -27,7 +27,7 @@ from telegrinder.types.objects import Update
 if typing.TYPE_CHECKING:
     from telegrinder.bot.rules.abc import ABCRule
 
-T = typing.TypeVar("T")
+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)
 
@@ -52,7 +52,7 @@ class Dispatch(
     )
 
     def __repr__(self) -> str:
-        return "Dispatch(%s)" % ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items())
+        return "Dispatch(%s)" % ", ".join(f"{k}={v!r}" for k, v in self.get_views().items())
 
     @property
     def global_context(self) -> TelegrinderContext:
@@ -97,7 +97,7 @@ class Dispatch(
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
-    def handle(  # type: ignore
+    def handle(
         self,
         *rules: "ABCRule",
         error_handler: ErrorHandlerT,
@@ -105,7 +105,7 @@ class Dispatch(
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
 
     @typing.overload
-    def handle(  # type: ignore
+    def handle(
         self,
         *rules: "ABCRule",
         update_type: UpdateType,
@@ -142,15 +142,15 @@ class Dispatch(
         is_blocking: bool = True,
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
-    def handle(  # type: ignore
+    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,
-    ):
-        def wrapper(func: typing.Callable):
+    ) -> typing.Callable[..., typing.Any]:
+        def wrapper(func):
             handler = FuncHandler(
                 func,
                 list(rules),

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/dispatch/handler/func.py

@@ -21,10 +21,7 @@ from .abc import ABCHandler
 if typing.TYPE_CHECKING:
     from telegrinder.bot.rules import ABCRule
 
-F = typing.TypeVar(
-    "F",
-    bound=typing.Callable[typing.Concatenate[typing.Any, ...], typing.Awaitable[typing.Any]],
-)
+F = typing.TypeVar("F", bound=typing.Callable[..., typing.Awaitable[typing.Any]])
 Event = typing.TypeVar("Event", bound=Model)
 ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
 
@@ -65,9 +62,15 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
         temp_ctx = ctx.copy()
         temp_ctx |= self.preset_context
 
+        update = event
+
+        for rule in self.rules:
+            if not await check_rule(api, rule, update, temp_ctx):
+                logger.debug("Rule {!r} failed!", rule)
+                return False
+
         nodes = self.required_nodes
         node_col = None
-        update = event
 
         if nodes:
             result = await compose_nodes(nodes, ctx, data={Update: event, API: api})
@@ -83,11 +86,6 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
                     if node is ctx[EVENT_NODE_KEY] and name in temp_ctx:
                         ctx[EVENT_NODE_KEY] = temp_ctx.pop(name)
 
-        for rule in self.rules:
-            if not await check_rule(api, rule, update, temp_ctx):
-                logger.debug("Rule {!r} failed!", rule)
-                return False
-
         logger.debug("All checks passed for handler.")
 
         temp_ctx["node_col"] = node_col

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/dispatch/process.py

@@ -10,7 +10,7 @@ from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
 from telegrinder.model import Model
 from telegrinder.modules import logger
 from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, NodeScope, compose_nodes
-from telegrinder.tools.i18n.base import I18nEnum
+from telegrinder.tools.i18n.abc import I18nEnum
 from telegrinder.types.objects import Update
 
 if typing.TYPE_CHECKING:

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/dispatch/view/base.py

@@ -18,14 +18,22 @@ from telegrinder.msgspec_utils import Option
 from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
 from telegrinder.types.objects import Update
 
+if typing.TYPE_CHECKING:
+    from telegrinder.node.base import Node
+
+T = typing.TypeVar("T", contravariant=True, bound="BaseCute | Node")
 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 Func(typing.Protocol[T]):
+    __name__: str
+
+    async def __call__(self, event_or_node: T, /, *args: typing.Any, **kwargs: typing.Any) -> typing.Any: ...
+
+
+FuncType: typing.TypeAlias = Func[Event] | Func[T]
 
 
 def get_event_model_class(view: "BaseView[Event]") -> Option[type[Event]]:
@@ -66,8 +74,8 @@ class BaseView(ABCView, typing.Generic[Event]):
         cls,
         *rules: ABCRule,
     ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+        [FuncType[Event, T]],
+        FuncHandler[Event, FuncType[Event, T], ErrorHandler[Event]],
     ]: ...
 
     @typing.overload
@@ -77,7 +85,7 @@ class BaseView(ABCView, typing.Generic[Event]):
         *rules: ABCRule,
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
+    ) -> typing.Callable[[FuncType[Event, T]], FuncHandler[Event, FuncType[Event, T], ErrorHandlerT]]: ...
 
     @typing.overload
     @classmethod
@@ -87,18 +95,18 @@ class BaseView(ABCView, typing.Generic[Event]):
         error_handler: typing.Literal[None] = None,
         is_blocking: bool = True,
     ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+        [FuncType[Event, T]],
+        FuncHandler[Event, FuncType[Event, T], ErrorHandler[Event]],
     ]: ...
 
     @classmethod
-    def to_handler(  # type: ignore
+    def to_handler(
         cls,
         *rules: ABCRule,
         error_handler: ABCErrorHandler | None = None,
         is_blocking: bool = True,
-    ):
-        def wrapper(func: FuncType[Event]):
+    ) -> typing.Callable[..., typing.Any]:
+        def wrapper(func):
             return FuncHandler(
                 func,
                 list(rules),
@@ -114,8 +122,8 @@ class BaseView(ABCView, typing.Generic[Event]):
         self,
         *rules: ABCRule,
     ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+        [FuncType[Event, T]],
+        FuncHandler[Event, FuncType[Event, T], ErrorHandler[Event]],
     ]: ...
 
     @typing.overload
@@ -124,7 +132,7 @@ class BaseView(ABCView, typing.Generic[Event]):
         *rules: ABCRule,
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
+    ) -> typing.Callable[[FuncType[Event, T]], FuncHandler[Event, FuncType[Event, T], ErrorHandlerT]]: ...
 
     @typing.overload
     def __call__(
@@ -133,17 +141,17 @@ class BaseView(ABCView, typing.Generic[Event]):
         error_handler: typing.Literal[None] = None,
         is_blocking: bool = True,
     ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+        [FuncType[Event, T]],
+        FuncHandler[Event, FuncType[Event, T], ErrorHandler[Event]],
     ]: ...
 
-    def __call__(  # type: ignore
+    def __call__(
         self,
         *rules: ABCRule,
         error_handler: ABCErrorHandler | None = None,
         is_blocking: bool = True,
-    ):
-        def wrapper(func: FuncType[Event]):
+    ) -> typing.Callable[..., typing.Any]:
+        def wrapper(func):
             func_handler = FuncHandler(
                 func,
                 [*self.auto_rules, *rules],
@@ -198,3 +206,6 @@ class BaseStateView(ABCStateView[Event], BaseView[Event], ABC, typing.Generic[Ev
     @abstractmethod
     def get_state_key(self, event: Event) -> int | None:
         pass
+
+
+__all__ = ("ABCStateView", "ABCView", "BaseStateView", "BaseView")

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/dispatch/view/raw.py

@@ -11,12 +11,13 @@ from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, Error
 from telegrinder.types.enums import UpdateType
 from telegrinder.types.objects import Update
 
-T = typing.TypeVar("T")
+T = typing.TypeVar("T", contravariant=True)
 
-FuncType: typing.TypeAlias = typing.Callable[
-    typing.Concatenate[T, ...],
-    typing.Coroutine[typing.Any, typing.Any, typing.Any],
-]
+
+class Func(typing.Protocol[T]):
+    __name__: str
+
+    async def __call__(self, event_or_node: T, /, *args: typing.Any, **kwargs: typing.Any) -> typing.Any: ...
 
 
 class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
@@ -32,8 +33,8 @@ class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
         update_type: UpdateType,
         *rules: ABCRule,
     ) -> typing.Callable[
-        [FuncType[UpdateCute]],
-        FuncHandler[UpdateCute, FuncType[UpdateCute], ErrorHandler[UpdateCute]],
+        [Func[UpdateCute]],
+        FuncHandler[UpdateCute, Func[UpdateCute], ErrorHandler[UpdateCute]],
     ]: ...
 
     @typing.overload
@@ -42,7 +43,7 @@ class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
         update_type: UpdateType,
         *rules: ABCRule,
         dataclass: type[T],
-    ) -> typing.Callable[[FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandler[T]]]: ...
+    ) -> typing.Callable[[Func[T]], FuncHandler[UpdateCute, Func[T], ErrorHandler[T]]]: ...
 
     @typing.overload
     def __call__(
@@ -51,8 +52,8 @@ class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
         *rules: ABCRule,
         error_handler: ErrorHandlerT,
     ) -> typing.Callable[
-        [FuncType[UpdateCute]],
-        FuncHandler[UpdateCute, FuncType[UpdateCute], ErrorHandlerT],
+        [Func[UpdateCute]],
+        FuncHandler[UpdateCute, Func[UpdateCute], ErrorHandlerT],
     ]: ...
 
     @typing.overload
@@ -63,19 +64,19 @@ class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
         dataclass: type[T],
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[[FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandlerT]]: ...
+    ) -> typing.Callable[[Func[T]], FuncHandler[UpdateCute, Func[T], ErrorHandlerT]]: ...
 
     @typing.overload
     def __call__(
         self,
         update_type: UpdateType,
         *rules: ABCRule,
-        dataclass: typing.Literal[None] = None,
-        error_handler: typing.Literal[None] = None,
+        dataclass: None = None,
+        error_handler: None = None,
         is_blocking: bool = True,
     ) -> typing.Callable[
-        [FuncType[UpdateCute]],
-        FuncHandler[UpdateCute, FuncType[UpdateCute], ErrorHandler[UpdateCute]],
+        [Func[UpdateCute]],
+        FuncHandler[UpdateCute, Func[UpdateCute], ErrorHandler[UpdateCute]],
     ]: ...
 
     def __call__(  # type: ignore
@@ -86,7 +87,7 @@ class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
         error_handler: ABCErrorHandler | None = None,
         is_blocking: bool = True,
     ):
-        def wrapper(func: FuncType[typing.Any]):
+        def wrapper(func):
             func_handler = FuncHandler(
                 func,
                 rules=[*self.auto_rules, *rules],
@@ -112,3 +113,6 @@ class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
             self.handlers,
             self.return_manager,
         )
+
+
+__all__ = ("RawEventView",)

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/dispatch/waiter_machine/actions.py

@@ -8,3 +8,6 @@ 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-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/dispatch/waiter_machine/hasher/callback.py

@@ -1,9 +1,8 @@
-from fntypes import Some
+from fntypes.option import Some
 
 from telegrinder.bot.cute_types import CallbackQueryCute as CallbackQuery
 from telegrinder.bot.dispatch.view import CallbackQueryView
-
-from .hasher import Hasher
+from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
 
 
 def from_chat_hash(chat_id: int) -> int:
@@ -14,13 +13,6 @@ 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
 
@@ -29,13 +21,6 @@ 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]}"
 
@@ -46,8 +31,20 @@ def get_chat_and_message_for_event(event: CallbackQuery) -> tuple[int, int] | No
     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=CallbackQueryView,
+    view_class=CallbackQueryView,
     get_hash_from_data=for_message_in_chat,
     get_data_from_event=get_chat_and_message_for_event,
 )

{telegrinder-0.3.0.post1 → telegrinder-0.3.1}/telegrinder/bot/dispatch/waiter_machine/hasher/hasher.py

@@ -1,30 +1,44 @@
 import typing
+from functools import cached_property
 
-from fntypes import Option
+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")
 
-ECHO = lambda x: x
+
+def _echo(__x: T) -> T:
+    return __x
+
+
+ECHO = _echo
 
 
 class Hasher(typing.Generic[Event, Data]):
     def __init__(
         self,
-        view: type[BaseView[Event]],
+        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,
-    ):
-        self.view = view
+    ) -> 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 get_name(self) -> str:
-        return f"{self.view.__class__.__name__}_{id(self)}"
+    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:
@@ -39,11 +53,5 @@ class Hasher(typing.Generic[Event, Data]):
     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
 
-    def __hash__(self) -> int:
-        return hash(self.get_name())
-
-    def __repr__(self) -> str:
-        return f"<Hasher {self.get_name()}>"
-
 
 __all__ = ("Hasher",)