telegrinder 0.1.dev170__py3-none-any.whl → 0.2.0__py3-none-any.whl

telegrinder/bot/dispatch/process.py

@@ -2,27 +2,26 @@ import typing
 
 from fntypes.result import Error, Ok
 
-from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.cute_types import BaseCute
+from telegrinder.api.api import API
 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)
-_: typing.TypeAlias = typing.Any
+Event = typing.TypeVar("Event", bound=Model)
 
 
 async def process_inner(
+    api: API,
     event: Event,
     raw_event: Update,
     middlewares: list[ABCMiddleware[Event]],
@@ -31,10 +30,13 @@ async def process_inner(
 ) -> bool:
     logger.debug("Processing {!r}...", event.__class__.__name__)
     ctx = Context(raw_update=raw_event)
-    ctx[CONTEXT_STORE_NODES_KEY] = {}  # for per-event shared nodes
+    ctx[CONTEXT_STORE_NODES_KEY] = {}  # For per-event shared nodes
 
+    logger.debug("Run pre middlewares...")
     for middleware in middlewares:
-        if await middleware.pre(event, ctx) is False:
+        middleware_result = await middleware.pre(event, ctx)
+        logger.debug("Middleware {!r} returned {!r}", middleware.__class__.__name__, middleware_result)
+        if middleware_result is False:
             return False
 
     found = False
@@ -42,9 +44,10 @@ 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):
+            logger.debug("Handler {!r} matched, run...", handler)
             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:
@@ -54,17 +57,24 @@ async def process_inner(
 
         ctx = ctx_copy
 
+    logger.debug("Run post middlewares...")
     for middleware in middlewares:
+        logger.debug("Run post middleware {!r}", middleware.__class__.__name__)
         await middleware.post(event, responses, ctx)
 
     for session in ctx.get(CONTEXT_STORE_NODES_KEY, {}).values():
         await session.close(scopes=(NodeScope.PER_EVENT,))
 
+    logger.debug(
+        "{} handlers, returns {!r}",
+        "No found" if not found else "Found",
+        found,
+    )
     return found
 
 
 async def check_rule(
-    api: ABCAPI,
+    api: API,
     rule: "ABCRule",
     update: Update,
     ctx: Context,
@@ -73,13 +83,21 @@ async def check_rule(
     Returns check result."""
 
     # Running adapter
-    match await rule.adapter.adapt(api, update):
+    match await rule.adapter.adapt(api, update, ctx):
         case Ok(value):
             adapted_value = value
         case Error(err):
             logger.debug("Adapter failed with error message: {!r}", str(err))
             return False
 
+    # Preparing update
+    if isinstance(adapted_val := ctx.get(rule.adapter.ADAPTED_VALUE_KEY or ""), UpdateCute):
+        update = adapted_val
+    elif isinstance(adapted_value, UpdateCute):
+        update = adapted_value
+    else:
+        update = UpdateCute.from_update(update, bound_api=api)
+
     # Running subrules to fetch requirements
     ctx_copy = ctx.copy()
     for requirement in rule.requires:
@@ -88,20 +106,21 @@ async def check_rule(
 
     # Translating translatable rules
     if I18nEnum.I18N in ctx:
-        rule = await rule.translate(ctx.get(I18nEnum.I18N))
+        rule = await rule.translate(ctx[I18nEnum.I18N])
 
     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)
-        if node_col is None:
+        result = await compose_nodes(nodes, ctx, data={Update: update, API: api})
+        if not result:
             return False
+        node_col = result.value
 
     # Running check
-    result = await rule.bounding_check(adapted_value, ctx, node_col)
+    result = await rule.bounding_check(adapted_value, ctx, node_col=node_col)
 
     # Closing node sessions if there are any
     if node_col is not None:

telegrinder/bot/dispatch/return_manager/__init__.py

@@ -1,12 +1,12 @@
-from .abc import (
+from telegrinder.bot.dispatch.return_manager.abc import (
     ABCReturnManager,
     BaseReturnManager,
     Manager,
     register_manager,
 )
-from .callback_query import CallbackQueryReturnManager
-from .inline_query import InlineQueryReturnManager
-from .message import MessageReturnManager
+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
 
 __all__ = (
     "ABCReturnManager",

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/return_manager/callback_query.py

@@ -2,8 +2,7 @@ import typing
 
 from telegrinder.bot.cute_types import CallbackQueryCute
 from telegrinder.bot.dispatch.context import Context
-
-from .abc import BaseReturnManager, register_manager
+from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
 
 
 class CallbackQueryReturnManager(BaseReturnManager[CallbackQueryCute]):

telegrinder/bot/dispatch/return_manager/inline_query.py

@@ -2,8 +2,7 @@ import typing
 
 from telegrinder.bot.cute_types import InlineQueryCute
 from telegrinder.bot.dispatch.context import Context
-
-from .abc import BaseReturnManager, register_manager
+from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
 
 
 class InlineQueryReturnManager(BaseReturnManager[InlineQueryCute]):

telegrinder/bot/dispatch/return_manager/message.py

@@ -2,10 +2,9 @@ import typing
 
 from telegrinder.bot.cute_types 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
 
-from .abc import BaseReturnManager, register_manager
-
 
 class MessageReturnManager(BaseReturnManager[MessageCute]):
     @register_manager(str)

telegrinder/bot/dispatch/view/__init__.py

@@ -1,11 +1,11 @@
-from .abc import ABCStateView, ABCView, BaseStateView, BaseView
-from .box import ViewBox
-from .callback_query import CallbackQueryView
-from .chat_join_request import ChatJoinRequestView
-from .chat_member import ChatMemberView
-from .inline_query import InlineQueryView
-from .message import MessageView
-from .raw import RawEventView
+from telegrinder.bot.dispatch.view.abc import ABCStateView, ABCView, 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
+from telegrinder.bot.dispatch.view.chat_member import ChatMemberView
+from telegrinder.bot.dispatch.view.inline_query import InlineQueryView
+from telegrinder.bot.dispatch.view.message import MessageView
+from telegrinder.bot.dispatch.view.raw import RawEventView
 
 __all__ = (
     "ABCStateView",

telegrinder/bot/dispatch/view/abc.py

@@ -1,9 +1,10 @@
 import typing
 from abc import ABC, abstractmethod
+from functools import cached_property
 
 from fntypes.co import Nothing, Some
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.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
@@ -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 "<{}>".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: API) -> bool:
         pass
 
     @abstractmethod
@@ -46,6 +44,10 @@ class ABCView(ABC):
         pass
 
 
+class ABCEventRawView(ABCView, ABC, typing.Generic[Event]):
+    handlers: list[ABCHandler[Event]]
+
+
 class ABCStateView(ABCView, typing.Generic[Event]):
     @abstractmethod
     def get_state_key(self, event: Event) -> int | None:
@@ -62,9 +64,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 +179,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: API) -> bool:
+        return await process_inner(
+            api,
+            self.get_event_type.unwrap().from_update(
                 update=self.get_raw_event(event).unwrap(),
                 bound_api=api,
             ),
@@ -214,6 +215,7 @@ class BaseStateView(ABCStateView[Event], BaseView[Event], ABC, typing.Generic[Ev
 
 __all__ = (
     "ABCStateView",
+    "ABCEventRawView",
     "ABCView",
     "BaseStateView",
     "BaseView",

telegrinder/bot/dispatch/view/box.py

@@ -10,7 +10,7 @@ from telegrinder.bot.dispatch.view import (
     message,
     raw,
 )
-from telegrinder.bot.dispatch.view.abc import ABCView
+from telegrinder.bot.dispatch.view.abc import ABCEventRawView, ABCView
 from telegrinder.types.enums import UpdateType
 
 CallbackQueryView = typing.TypeVar(
@@ -22,7 +22,7 @@ ChatJoinRequestView = typing.TypeVar(
 ChatMemberView = typing.TypeVar("ChatMemberView", bound=ABCView, default=chat_member.ChatMemberView)
 InlineQueryView = typing.TypeVar("InlineQueryView", bound=ABCView, default=inline_query.InlineQueryView)
 MessageView = typing.TypeVar("MessageView", bound=ABCView, default=message.MessageView)
-RawEventView = typing.TypeVar("RawEventView", bound=ABCView, default=raw.RawEventView)
+RawEventView = typing.TypeVar("RawEventView", bound=ABCEventRawView, default=raw.RawEventView)
 
 
 @dataclasses.dataclass(kw_only=True)
@@ -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/callback_query.py

@@ -1,7 +1,6 @@
 from telegrinder.bot.cute_types import CallbackQueryCute
 from telegrinder.bot.dispatch.return_manager import CallbackQueryReturnManager
-
-from .abc import BaseStateView
+from telegrinder.bot.dispatch.view.abc import BaseStateView
 
 
 class CallbackQueryView(BaseStateView[CallbackQueryCute]):

telegrinder/bot/dispatch/view/chat_join_request.py

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

telegrinder/bot/dispatch/view/chat_member.py

@@ -1,9 +1,9 @@
 import typing
 
 from telegrinder.bot.cute_types import ChatMemberUpdatedCute
+from telegrinder.bot.dispatch.view.abc import BaseStateView
 from telegrinder.types.enums import UpdateType
-
-from .abc import BaseStateView
+from telegrinder.types.objects import Update
 
 ChatMemberUpdateType: typing.TypeAlias = typing.Literal[
     UpdateType.CHAT_MEMBER,
@@ -19,8 +19,22 @@ class ChatMemberView(BaseStateView[ChatMemberUpdatedCute]):
         self.return_manager = None
         self.update_type = update_type
 
+    def __repr__(self) -> str:
+        return "<{}: {!r}>".format(
+            self.__class__.__name__,
+            "chat_member_updated" if self.update_type is None else self.update_type.value,
+        )
+
     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
+            and self.update_type != event.update_type
+            or not await super().check(event)
+        )
+
+
 __all__ = ("ChatMemberView",)

telegrinder/bot/dispatch/view/inline_query.py

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

telegrinder/bot/dispatch/view/message.py

@@ -2,10 +2,9 @@ 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 .abc import BaseStateView
-
 MessageUpdateType: typing.TypeAlias = typing.Literal[
     UpdateType.MESSAGE,
     UpdateType.BUSINESS_MESSAGE,
@@ -24,13 +23,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",)

telegrinder/bot/dispatch/view/raw.py

@@ -1,14 +1,14 @@
 import typing
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.cute_types 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.rules.abc import ABCRule
 from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
-from telegrinder.types import Update, UpdateType
-
-from .abc import BaseView, ErrorHandlerT
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
 
 T = typing.TypeVar("T")
 
@@ -18,7 +18,7 @@ FuncType: typing.TypeAlias = typing.Callable[
 ]
 
 
-class RawEventView(BaseView[UpdateCute]):
+class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
     def __init__(self) -> None:
         self.auto_rules = []
         self.handlers = []
@@ -88,7 +88,7 @@ class RawEventView(BaseView[UpdateCute]):
         def wrapper(func: FuncType[typing.Any]):
             func_handler = FuncHandler(
                 func,
-                [*self.auto_rules, *rules],
+                rules=[*self.auto_rules, *rules],
                 is_blocking=is_blocking,
                 dataclass=dataclass,
                 error_handler=error_handler or ErrorHandler(),
@@ -100,10 +100,11 @@ class RawEventView(BaseView[UpdateCute]):
         return wrapper
 
     async def check(self, event: Update) -> bool:
-        return False
+        return bool(self.handlers) or bool(self.middlewares)
 
-    async def process(self, event: Update, api: ABCAPI) -> bool:
+    async def process(self, event: Update, api: API) -> bool:
         return await process_inner(
+            api,
             UpdateCute.from_update(event, bound_api=api),
             event,
             self.middlewares,

telegrinder/bot/dispatch/waiter_machine/__init__.py

@@ -1,6 +1,6 @@
-from .machine import WaiterMachine, clear_wm_storage_worker
-from .middleware import WaiterMiddleware
-from .short_state import ShortState
+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__ = (
     "ShortState",