telegrinder 0.1.dev170__py3-none-any.whl → 0.1.dev171__py3-none-any.whl

telegrinder/bot/dispatch/dispatch.py

@@ -8,15 +8,15 @@ from telegrinder.api.abc import ABCAPI
 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.rules import ABCRule
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.handler.func import ErrorHandlerT, FuncHandler
 from telegrinder.modules import logger
 from telegrinder.tools.error_handler.error_handler import ErrorHandler
-from telegrinder.tools.global_context import TelegrinderCtx
-from telegrinder.types import Update
+from telegrinder.tools.global_context import TelegrinderContext
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
 
 from .abc import ABCDispatch
-from .handler import ABCHandler, FuncHandler
-from .handler.func import ErrorHandlerT
 from .view.box import (
     CallbackQueryView,
     ChatJoinRequestView,
@@ -27,9 +27,10 @@ from .view.box import (
     ViewBox,
 )
 
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.abc import ABCRule
+
 T = typing.TypeVar("T")
-R = typing.TypeVar("R")
-P = typing.ParamSpec("P")
 Handler = typing.Callable[typing.Concatenate[T, ...], typing.Coroutine[typing.Any, typing.Any, typing.Any]]
 Event = typing.TypeVar("Event", bound=BaseCute)
 
@@ -48,18 +49,22 @@ class Dispatch(
         RawEventView,
     ],
 ):
-    global_context: TelegrinderCtx = dataclasses.field(
-        init=False,
-        default_factory=lambda: TelegrinderCtx(),
-    )
     default_handlers: list[ABCHandler] = dataclasses.field(
         init=False,
         default_factory=lambda: [],
     )
+    _global_context: TelegrinderContext = dataclasses.field(
+        init=False,
+        default_factory=lambda: TelegrinderContext(),
+    )
 
     def __repr__(self) -> str:
         return "Dispatch(%s)" % ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items())
 
+    @property
+    def global_context(self) -> TelegrinderContext:
+        return self._global_context
+
     @property
     def patcher(self) -> Patcher:
         """Alias `patcher` to get `vbml.Patcher` from the global context."""
@@ -69,28 +74,57 @@ class Dispatch(
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        dataclass: type[T],
+        is_blocking: bool = True,
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
+        update_type: UpdateType,
         is_blocking: bool = True,
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
         dataclass: type[T],
+        update_type: UpdateType,
         is_blocking: bool = True,
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(  # type: ignore
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def handle(  # type: ignore
+        self,
+        *rules: "ABCRule",
+        update_type: UpdateType,
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        dataclass: type[T],
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
@@ -98,8 +132,9 @@ class Dispatch(
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
         dataclass: type[T],
+        update_type: UpdateType,
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
@@ -107,7 +142,8 @@ class Dispatch(
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
+        update_type: UpdateType | None = None,
         dataclass: type[T] = DEFAULT_DATACLASS,
         error_handler: typing.Literal[None] = None,
         is_blocking: bool = True,
@@ -115,7 +151,8 @@ class Dispatch(
 
     def handle(  # type: ignore
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
+        update_type: UpdateType | None = None,
         dataclass: type[typing.Any] = DEFAULT_DATACLASS,
         error_handler: ErrorHandlerT | None = None,
         is_blocking: bool = True,
@@ -127,6 +164,7 @@ class Dispatch(
                 is_blocking=is_blocking,
                 dataclass=dataclass,
                 error_handler=error_handler or ErrorHandler(),
+                update_type=update_type,
             )
             self.default_handlers.append(handler)
             return handler
@@ -142,18 +180,18 @@ class Dispatch(
                 logger.debug(
                     "Update (update_id={}) matched view {!r}.",
                     event.update_id,
-                    view.__class__.__name__,
+                    view,
                 )
-                await view.process(event, api)
-                return True
+                if await view.process(event, api):
+                    return True
 
-        ctx = Context()
+        ctx = Context(raw_update=event)
         loop = asyncio.get_running_loop()
         found = False
         for handler in self.default_handlers:
             if await handler.check(api, event, ctx):
                 found = True
-                loop.create_task(handler.run(event, ctx))
+                loop.create_task(handler.run(api, event, ctx))
                 if handler.is_blocking:
                     break
         return found

telegrinder/bot/dispatch/handler/abc.py

@@ -4,7 +4,7 @@ from abc import ABC, abstractmethod
 from telegrinder.api.abc import ABCAPI
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.model import Model
-from telegrinder.types import Update
+from telegrinder.types.objects import Update
 
 T = typing.TypeVar("T", bound=Model)
 
@@ -17,7 +17,7 @@ class ABCHandler(ABC, typing.Generic[T]):
         pass
 
     @abstractmethod
-    async def run(self, event: T, ctx: Context) -> typing.Any:
+    async def run(self, api: ABCAPI, event: T, ctx: Context) -> typing.Any:
         pass
 
 

telegrinder/bot/dispatch/handler/func.py

@@ -1,4 +1,5 @@
 import dataclasses
+from functools import cached_property
 
 import typing_extensions as typing
 
@@ -6,12 +7,14 @@ from telegrinder.api.abc import ABCAPI
 from telegrinder.bot.cute_types import BaseCute, UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.model import Model
 from telegrinder.modules import logger
-from telegrinder.node import Node, compose_nodes, is_node
+from telegrinder.node.base import Node, get_nodes
+from telegrinder.node.composer import compose_nodes
+from telegrinder.node.event import EVENT_NODE_KEY
 from telegrinder.tools.error_handler import ABCErrorHandler, ErrorHandler
-from telegrinder.tools.magic import get_annotations
-from telegrinder.types import Update
 from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
 
 from .abc import ABCHandler
 
@@ -22,11 +25,11 @@ F = typing.TypeVar(
     "F",
     bound=typing.Callable[typing.Concatenate[typing.Any, ...], typing.Awaitable[typing.Any]],
 )
-Event = typing.TypeVar("Event", bound=BaseCute)
+Event = typing.TypeVar("Event", bound=Model)
 ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
     func: F
     rules: list["ABCRule"]
@@ -49,26 +52,37 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
             self.error_handler,
         )
 
-    def get_required_nodes(self) -> dict[str, type[Node]]:
-        return {k: v for k, v in get_annotations(self.func).items() if is_node(v)}
+    @cached_property
+    def required_nodes(self) -> dict[str, type[Node]]:
+        return get_nodes(self.func)
 
     async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
         if self.update_type is not None and self.update_type != event.update_type:
             return False
 
-        ctx = ctx or Context()
+        ctx = Context(raw_update=event) if ctx is None else ctx
         temp_ctx = ctx.copy()
         temp_ctx |= self.preset_context
 
-        nodes = self.get_required_nodes()
+        nodes = self.required_nodes
         node_col = None
 
         if nodes:
-            node_col = await compose_nodes(nodes, UpdateCute.from_update(event, api), ctx)
+            node_col = await compose_nodes(
+                UpdateCute.from_update(event, api),
+                ctx,
+                nodes,
+            )
+
             if node_col is None:
                 return False
             temp_ctx |= node_col.values()
 
+            if EVENT_NODE_KEY in ctx:
+                for name, node in nodes.items():
+                    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, event, temp_ctx):
                 logger.debug("Rule {!r} failed!", rule)
@@ -78,19 +92,24 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
         ctx |= temp_ctx
         return True
 
-    async def run(self, event: Event, ctx: Context) -> typing.Any:
-        api = event.api
+    async def run(self, api: ABCAPI, event: Event, ctx: Context) -> typing.Any:
+        dataclass_type = typing.get_origin(self.dataclass) or self.dataclass
+
+        if dataclass_type is Update and (event_node := ctx.pop(EVENT_NODE_KEY, None)) is not None:
+            event = event_node
 
-        if self.dataclass is not None:
-            if self.update_type is not None:
+        elif dataclass_type is not None:
+            if self.update_type is not None and isinstance(event, Update):
                 update = event.to_dict()[self.update_type.value].unwrap()
                 event = (
                     self.dataclass.from_update(update, bound_api=api)  # type: ignore
-                    if issubclass(self.dataclass, BaseCute)
-                    else self.dataclass(**update.to_dict())
+                    if issubclass(dataclass_type, BaseCute)
+                    else self.dataclass(**update.to_dict())  # type: ignore
                 )
+            elif issubclass(dataclass_type, UpdateCute) and isinstance(event, Update):
+                event = self.dataclass.from_update(event, bound_api=api)  # type: ignore
             else:
-                event = self.dataclass(**event.to_dict())
+                event = self.dataclass(**event.to_dict())  # type: ignore
 
         result = (await self.error_handler.run(self.func, event, api, ctx)).unwrap()
         if node_col := ctx.node_col:

telegrinder/bot/dispatch/handler/message_reply.py

@@ -37,7 +37,7 @@ class MessageReplyHandler(ABCHandler[MessageCute]):
         )
 
     async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
-        ctx = ctx or Context()
+        ctx = Context() if ctx is None else ctx
         temp_ctx = ctx.copy()
         temp_ctx |= self.preset_context
 
@@ -49,7 +49,7 @@ class MessageReplyHandler(ABCHandler[MessageCute]):
         ctx |= temp_ctx
         return True
 
-    async def run(self, event: MessageCute, _: Context) -> typing.Any:
+    async def run(self, _: ABCAPI, event: MessageCute, __: Context) -> typing.Any:
         await event.answer(
             text=self.text,
             reply_parameters=ReplyParameters(event.message_id) if self.as_reply else None,

telegrinder/bot/dispatch/middleware/abc.py

@@ -1,10 +1,10 @@
 import typing
 from abc import ABC
 
-from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.model import Model
 
-Event = typing.TypeVar("Event", bound=BaseCute)
+Event = typing.TypeVar("Event", bound=Model)
 
 
 class ABCMiddleware(ABC, typing.Generic[Event]):

telegrinder/bot/dispatch/process.py

@@ -3,26 +3,26 @@ import typing
 from fntypes.result import Error, Ok
 
 from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
+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.types import Update
-
-from .middleware.abc import ABCMiddleware
-from .return_manager.abc import ABCReturnManager
+from telegrinder.types.objects import Update
 
 if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch.handler.abc import ABCHandler
     from telegrinder.bot.rules.abc import ABCRule
 
-Event = typing.TypeVar("Event", bound=BaseCute)
+Event = typing.TypeVar("Event", bound=Model)
 _: typing.TypeAlias = typing.Any
 
 
 async def process_inner(
+    api: ABCAPI,
     event: Event,
     raw_event: Update,
     middlewares: list[ABCMiddleware[Event]],
@@ -42,9 +42,9 @@ async def process_inner(
     ctx_copy = ctx.copy()
 
     for handler in handlers:
-        if await handler.check(event.api, raw_event, ctx):
+        if await handler.check(api, raw_event, ctx):
             found = True
-            response = await handler.run(event, ctx)
+            response = await handler.run(api, event, ctx)
             logger.debug("Handler {!r} returned: {!r}", handler, response)
             responses.append(response)
             if return_manager is not None:
@@ -93,10 +93,10 @@ async def check_rule(
     ctx |= ctx_copy
 
     # Composing required nodes
-    nodes = rule.get_required_nodes()
+    nodes = rule.required_nodes
     node_col = None
     if nodes:
-        node_col = await compose_nodes(nodes, UpdateCute.from_update(update, api), ctx)
+        node_col = await compose_nodes(UpdateCute.from_update(update, api), ctx, nodes)
         if node_col is None:
             return False
 

telegrinder/bot/dispatch/return_manager/abc.py

@@ -3,12 +3,12 @@ import types
 import typing
 from abc import ABC, abstractmethod
 
-from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.model import Model
 from telegrinder.modules import logger
 
 T = typing.TypeVar("T")
-Event = typing.TypeVar("Event", bound=BaseCute, contravariant=True)
+Event = typing.TypeVar("Event", bound=Model, contravariant=True)
 
 
 def get_union_types(t: types.UnionType) -> tuple[type, ...] | None:
@@ -24,7 +24,7 @@ def register_manager(return_type: type[typing.Any] | types.UnionType):
     return wrapper
 
 
-@dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True, slots=True)
 class Manager:
     types: tuple[type, ...]
     callback: typing.Callable[..., typing.Awaitable]

telegrinder/bot/dispatch/view/abc.py

@@ -1,5 +1,6 @@
 import typing
 from abc import ABC, abstractmethod
+from functools import cached_property
 
 from fntypes.co import Nothing, Some
 
@@ -28,17 +29,14 @@ FuncType: typing.TypeAlias = typing.Callable[
 
 class ABCView(ABC):
     def __repr__(self) -> str:
-        return "<{!r}: {}>".format(
-            self.__class__.__name__,
-            ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items()),
-        )
+        return "<{!r}>".format(self.__class__.__name__)
 
     @abstractmethod
     async def check(self, event: Update) -> bool:
         pass
 
     @abstractmethod
-    async def process(self, event: Update, api: ABCAPI) -> None:
+    async def process(self, event: Update, api: ABCAPI) -> bool:
         pass
 
     @abstractmethod
@@ -62,9 +60,9 @@ class BaseView(ABCView, typing.Generic[Event]):
     def get_raw_event(update: Update) -> Option[Model]:
         return getattr(update, update.update_type.value)
 
-    @classmethod
-    def get_event_type(cls) -> Option[type[Event]]:
-        for base in cls.__dict__.get("__orig_bases__", ()):
+    @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):
@@ -177,20 +175,19 @@ class BaseView(ABCView, typing.Generic[Event]):
     async def check(self, event: Update) -> bool:
         match self.get_raw_event(event):
             case Some(e) if issubclass(
-                self.get_event_type().expect(
+                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: ABCAPI) -> None:
-        await process_inner(
-            self.get_event_type()
-            .unwrap()
-            .from_update(
+    async def process(self, event: Update, api: ABCAPI) -> bool:
+        return await process_inner(
+            api,
+            self.get_event_type.unwrap().from_update(
                 update=self.get_raw_event(event).unwrap(),
                 bound_api=api,
             ),

telegrinder/bot/dispatch/view/box.py

@@ -36,78 +36,89 @@ class ViewBox(
         RawEventView,
     ],
 ):
-    callback_query: CallbackQueryView = dataclasses.field(
-        default_factory=lambda: typing.cast(
+    callback_query_view: dataclasses.InitVar[CallbackQueryView | None] = None
+    chat_join_request_view: dataclasses.InitVar[ChatJoinRequestView | None] = None
+    chat_member_view: dataclasses.InitVar[ChatMemberView | None] = None
+    my_chat_member_view: dataclasses.InitVar[ChatMemberView | None] = None
+    inline_query_view: dataclasses.InitVar[InlineQueryView | None] = None
+    message_view: dataclasses.InitVar[MessageView | None] = None
+    business_message_view: dataclasses.InitVar[MessageView | None] = None
+    channel_post_view: dataclasses.InitVar[MessageView | None] = None
+    edited_message_view: dataclasses.InitVar[MessageView | None] = None
+    edited_business_message_view: dataclasses.InitVar[MessageView | None] = None
+    edited_channel_post_view: dataclasses.InitVar[MessageView | None] = None
+    any_message_view: dataclasses.InitVar[MessageView | None] = None
+    chat_member_updated_view: dataclasses.InitVar[ChatMemberView | None] = None
+    raw_event_view: dataclasses.InitVar[RawEventView | None] = None
+
+    def __post_init__(
+        self,
+        callback_query_view: CallbackQueryView | None = None,
+        chat_join_request_view: ChatJoinRequestView | None = None,
+        chat_member_view: ChatMemberView | None = None,
+        my_chat_member_view: ChatMemberView | None = None,
+        inline_query_view: InlineQueryView | None = None,
+        message_view: MessageView | None = None,
+        business_message_view: MessageView | None = None,
+        channel_post_view: MessageView | None = None,
+        edited_message_view: MessageView | None = None,
+        edited_business_message_view: MessageView | None = None,
+        edited_channel_post_view: MessageView | None = None,
+        any_message_view: MessageView | None = None,
+        chat_member_updated_view: ChatMemberView | None = None,
+        raw_event_view: RawEventView | None = None,
+    ) -> None:
+        self.callback_query = typing.cast(
             CallbackQueryView,
-            callback_query.CallbackQueryView(),
-        ),
-    )
-    chat_join_request: ChatJoinRequestView = dataclasses.field(
-        default_factory=lambda: typing.cast(
+            callback_query_view or callback_query.CallbackQueryView(),
+        )
+        self.chat_join_request = typing.cast(
             ChatJoinRequestView,
-            chat_join_request.ChatJoinRequestView(),
-        ),
-    )
-    chat_member: ChatMemberView = dataclasses.field(
-        default_factory=lambda: typing.cast(
+            chat_join_request_view or chat_join_request.ChatJoinRequestView(),
+        )
+        self.chat_member = typing.cast(
             ChatMemberView,
-            chat_member.ChatMemberView(update_type=UpdateType.CHAT_MEMBER),
-        ),
-    )
-    my_chat_member: ChatMemberView = dataclasses.field(
-        default_factory=lambda: typing.cast(
+            chat_member_view or chat_member.ChatMemberView(update_type=UpdateType.CHAT_MEMBER),
+        )
+        self.my_chat_member = typing.cast(
             ChatMemberView,
-            chat_member.ChatMemberView(update_type=UpdateType.MY_CHAT_MEMBER),
-        ),
-    )
-    inline_query: InlineQueryView = dataclasses.field(
-        default_factory=lambda: typing.cast(InlineQueryView, inline_query.InlineQueryView()),
-    )
-    message: MessageView = dataclasses.field(
-        default_factory=lambda: typing.cast(
+            my_chat_member_view or chat_member.ChatMemberView(update_type=UpdateType.MY_CHAT_MEMBER),
+        )
+        self.inline_query = typing.cast(
+            InlineQueryView,
+            inline_query_view or inline_query.InlineQueryView(),
+        )
+        self.message = typing.cast(
             MessageView,
-            message.MessageView(update_type=UpdateType.MESSAGE),
-        ),
-    )
-    business_message: MessageView = dataclasses.field(
-        default_factory=lambda: typing.cast(
+            message_view or message.MessageView(update_type=UpdateType.MESSAGE),
+        )
+        self.business_message = typing.cast(
             MessageView,
-            message.MessageView(update_type=UpdateType.BUSINESS_MESSAGE),
-        ),
-    )
-    channel_post: MessageView = dataclasses.field(
-        default_factory=lambda: typing.cast(
+            business_message_view or message.MessageView(update_type=UpdateType.BUSINESS_MESSAGE),
+        )
+        self.channel_post = typing.cast(
             MessageView,
-            message.MessageView(update_type=UpdateType.CHANNEL_POST),
-        ),
-    )
-    edited_message: MessageView = dataclasses.field(
-        default_factory=lambda: typing.cast(
+            channel_post_view or message.MessageView(update_type=UpdateType.CHANNEL_POST),
+        )
+        self.edited_message = typing.cast(
             MessageView,
-            message.MessageView(update_type=UpdateType.EDITED_MESSAGE),
-        ),
-    )
-    edited_business_message: MessageView = dataclasses.field(
-        default_factory=lambda: typing.cast(
+            edited_message_view or message.MessageView(update_type=UpdateType.EDITED_MESSAGE),
+        )
+        self.edited_business_message = typing.cast(
             MessageView,
-            message.MessageView(update_type=UpdateType.EDITED_BUSINESS_MESSAGE),
-        ),
-    )
-    edited_channel_post: MessageView = dataclasses.field(
-        default_factory=lambda: typing.cast(
+            edited_business_message_view
+            or message.MessageView(update_type=UpdateType.EDITED_BUSINESS_MESSAGE),
+        )
+        self.edited_channel_post = typing.cast(
             MessageView,
-            message.MessageView(update_type=UpdateType.EDITED_CHANNEL_POST),
-        ),
-    )
-    any_message: MessageView = dataclasses.field(
-        default_factory=lambda: typing.cast(MessageView, message.MessageView()),
-    )
-    chat_member_updated: ChatMemberView = dataclasses.field(
-        default_factory=lambda: typing.cast(ChatMemberView, chat_member.ChatMemberView()),
-    )
-    raw_event: RawEventView = dataclasses.field(
-        default_factory=lambda: typing.cast(RawEventView, raw.RawEventView()),
-    )
+            edited_channel_post_view or message.MessageView(update_type=UpdateType.EDITED_CHANNEL_POST),
+        )
+        self.any_message = typing.cast(MessageView, any_message_view or message.MessageView())
+        self.chat_member_updated = typing.cast(
+            ChatMemberView,
+            chat_member_updated_view or chat_member.ChatMemberView(),
+        )
+        self.raw_event = typing.cast(RawEventView, raw_event_view or raw.RawEventView())
 
     def get_views(self) -> dict[str, ABCView]:
         """Get all views."""

telegrinder/bot/dispatch/view/message.py

@@ -24,13 +24,21 @@ class MessageView(BaseStateView[MessageCute]):
         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:
-        if not await super().check(event):
-            return False
-        return True if self.update_type is None else self.update_type == event.update_type
+        return not (
+            self.update_type is not None
+            and self.update_type != event.update_type
+            or not await super().check(event)
+        )
 
 
 __all__ = ("MessageView",)