telegrinder 0.1.dev165__py3-none-any.whl → 0.1.dev167__py3-none-any.whl

telegrinder/bot/dispatch/middleware/abc.py

@@ -8,11 +8,9 @@ T = typing.TypeVar("T", bound=BaseCute)
 
 
 class ABCMiddleware(ABC, typing.Generic[T]):
-    async def pre(self, event: T, ctx: Context) -> bool:
-        ...
+    async def pre(self, event: T, ctx: Context) -> bool: ...
 
-    async def post(self, event: T, responses: list[typing.Any], ctx: Context) -> None:
-        ...
+    async def post(self, event: T, responses: list[typing.Any], ctx: Context) -> None: ...
 
 
 __all__ = ("ABCMiddleware",)

telegrinder/bot/dispatch/process.py

@@ -25,7 +25,7 @@ async def process_inner(
     raw_event: Update,
     middlewares: list[ABCMiddleware[T]],
     handlers: list["ABCHandler[T]"],
-    return_manager: ABCReturnManager[T],
+    return_manager: ABCReturnManager[T] | None = None,
 ) -> bool:
     logger.debug("Processing {!r}...", event.__class__.__name__)
     ctx = Context(raw_update=raw_event)
@@ -43,7 +43,8 @@ async def process_inner(
             found = True
             response = await handler.run(event, ctx)
             responses.append(response)
-            await return_manager.run(response, event, ctx)
+            if return_manager is not None:
+                await return_manager.run(response, event, ctx)
             if handler.is_blocking:
                 break
             ctx = ctx_copy
@@ -56,7 +57,7 @@ async def process_inner(
 
 async def check_rule(
     api: ABCAPI,
-    rule: "ABCRule",
+    rule: "ABCRule[T]",
     update: Update,
     ctx: Context,
 ) -> bool:

telegrinder/bot/dispatch/return_manager/__init__.py

@@ -16,4 +16,4 @@ __all__ = (
     "Manager",
     "MessageReturnManager",
     "register_manager",
-) 
+)

telegrinder/bot/dispatch/return_manager/abc.py

@@ -17,10 +17,10 @@ def get_union_types(t: types.UnionType) -> tuple[type, ...] | None:
     return None
 
 
-def register_manager(return_type: type | types.UnionType):
-    def wrapper(func: typing.Callable[..., typing.Awaitable]):
+def register_manager(return_type: type[typing.Any] | types.UnionType):
+    def wrapper(func: typing.Callable[..., typing.Awaitable[typing.Any]]):
         return Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
-    
+
     return wrapper
 
 
@@ -61,34 +61,42 @@ class BaseReturnManager(ABCReturnManager[EventT]):
     @staticmethod
     async def ctx_manager(value: Context, event: EventT, ctx: Context) -> None:
         """Basic manager for returning context from handler."""
-        
+
         ctx.update(value)
-    
+
     async def run(self, response: typing.Any, event: EventT, ctx: Context) -> None:
         for manager in self.managers:
             if typing.Any in manager.types or any(type(response) is x for x in manager.types):
                 await manager(response, event, ctx)
-    
-    @typing.overload
-    def register_manager(self, return_type: type[T]) -> typing.Callable[
-        [typing.Callable[[T, EventT, Context], typing.Awaitable]], Manager
-    ]:
-        ...
-    
+
     @typing.overload
-    def register_manager(self, return_type: tuple[type[T], ...]) -> typing.Callable[
-        [typing.Callable[[tuple[T, ...], EventT, Context], typing.Awaitable]], Manager
-    ]:
-        ...
+    def register_manager(
+        self, return_type: type[T]
+    ) -> typing.Callable[
+        [typing.Callable[[T, EventT, Context], typing.Awaitable[typing.Any]]], Manager
+    ]: ...
 
-    def register_manager(self, return_type: type[T] | tuple[type[T], ...]) -> typing.Callable[
-        [typing.Callable[[T | tuple[T, ...], EventT, Context], typing.Awaitable]], Manager
+    @typing.overload
+    def register_manager(
+        self,
+        return_type: tuple[type[T], ...],
+    ) -> typing.Callable[
+        [typing.Callable[[tuple[T, ...], EventT, Context], typing.Awaitable[typing.Any]]],
+        Manager,
+    ]: ...
+
+    def register_manager(
+        self,
+        return_type: type[T] | tuple[type[T], ...],
+    ) -> typing.Callable[
+        [typing.Callable[[T | tuple[T, ...], EventT, Context], typing.Awaitable[typing.Any]]],
+        Manager,
     ]:
         def wrapper(func: typing.Callable[[T, EventT, Context], typing.Awaitable]) -> Manager:
             manager = Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
             setattr(self.__class__, func.__name__, manager)
             return manager
-        
+
         return wrapper
 
 
@@ -96,6 +104,6 @@ __all__ = (
     "ABCReturnManager",
     "BaseReturnManager",
     "Manager",
-    "register_manager",
     "get_union_types",
+    "register_manager",
 )

telegrinder/bot/dispatch/return_manager/callback_query.py

@@ -11,10 +11,12 @@ class CallbackQueryReturnManager(BaseReturnManager[CallbackQueryCute]):
     @staticmethod
     async def str_manager(value: str, event: CallbackQueryCute, ctx: Context) -> None:
         await event.answer(value)
-    
+
     @register_manager(dict)
     @staticmethod
-    async def dict_manager(value: dict[str, typing.Any], event: CallbackQueryCute, ctx: Context) -> None:
+    async def dict_manager(
+        value: dict[str, typing.Any], event: CallbackQueryCute, ctx: Context
+    ) -> None:
         await event.answer(**value)
 
 

telegrinder/bot/dispatch/return_manager/inline_query.py

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

telegrinder/bot/dispatch/return_manager/message.py

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

telegrinder/bot/dispatch/view/__init__.py

@@ -1,16 +1,22 @@
 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
 
 __all__ = (
-    "ABCView",
     "ABCStateView",
-    "BaseView",
+    "ABCView",
     "BaseStateView",
+    "BaseView",
     "CallbackQueryView",
+    "ChatJoinRequestView",
+    "ChatMemberView",
     "InlineQueryView",
     "MessageView",
+    "RawEventView",
     "ViewBox",
 )

telegrinder/bot/dispatch/view/abc.py

@@ -27,12 +27,18 @@ 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()),
+        )
+
     @abstractmethod
     async def check(self, event: Update) -> bool:
         pass
 
     @abstractmethod
-    async def process(self, event: Update, api: ABCAPI):
+    async def process(self, event: Update, api: ABCAPI) -> None:
         pass
 
     @abstractmethod
@@ -45,27 +51,19 @@ class ABCStateView(ABCView, typing.Generic[EventType]):
     def get_state_key(self, event: EventType) -> int | None:
         pass
 
-    def __repr__(self) -> str:
-        return "<{!r}: {}>".format(
-            self.__class__.__name__,
-            ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items()),
-        )
-
 
 class BaseView(ABCView, typing.Generic[EventType]):
     auto_rules: list[ABCRule[EventType]]
     handlers: list[ABCHandler[EventType]]
     middlewares: list[ABCMiddleware[EventType]]
-    return_manager: ABCReturnManager[EventType]
+    return_manager: ABCReturnManager[EventType] | None
 
     @classmethod
     def get_event_type(cls) -> Option[type[EventType]]:
         for base in cls.__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
-                    ):
+                    if issubclass(typing.get_origin(generic_type) or generic_type, BaseCute):
                         return Some(generic_type)
         return Nothing()
 
@@ -76,22 +74,25 @@ class BaseView(ABCView, typing.Generic[EventType]):
                 return getattr(update, update_type.value)
             case _:
                 return Nothing()
-    
+
     @typing.overload
     def __call__(
         self,
         *rules: ABCRule[EventType],
-    ) -> typing.Callable[[FuncType[EventType]], FuncHandler[EventType, FuncType[EventType], ErrorHandler]]:
-        ...
-    
+    ) -> typing.Callable[
+        [FuncType[EventType]],
+        FuncHandler[EventType, FuncType[EventType], ErrorHandler[EventType]],
+    ]: ...
+
     @typing.overload
     def __call__(
         self,
         *rules: ABCRule[EventType],
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[[FuncType[EventType]], FuncHandler[EventType, FuncType[EventType], ErrorHandlerT]]:
-        ...
+    ) -> typing.Callable[
+        [FuncType[EventType]], FuncHandler[EventType, FuncType[EventType], ErrorHandlerT]
+    ]: ...
 
     @typing.overload
     def __call__(
@@ -99,8 +100,10 @@ class BaseView(ABCView, typing.Generic[EventType]):
         *rules: ABCRule[EventType],
         error_handler: typing.Literal[None] = None,
         is_blocking: bool = True,
-    ) -> typing.Callable[[FuncType[EventType]], FuncHandler[EventType, FuncType[EventType], ErrorHandler]]:
-        ...
+    ) -> typing.Callable[
+        [FuncType[EventType]],
+        FuncHandler[EventType, FuncType[EventType], ErrorHandler[EventType]],
+    ]: ...
 
     def __call__(  # type: ignore
         self,
@@ -114,6 +117,7 @@ class BaseView(ABCView, typing.Generic[EventType]):
                 [*self.auto_rules, *rules],
                 is_blocking=is_blocking,
                 dataclass=None,
+                error_handler=error_handler or ErrorHandler(),
             )
             self.handlers.append(func_handler)
             return func_handler
@@ -139,8 +143,8 @@ class BaseView(ABCView, typing.Generic[EventType]):
             case _:
                 return False
 
-    async def process(self, event: Update, api: ABCAPI) -> bool:
-        return await process_inner(
+    async def process(self, event: Update, api: ABCAPI) -> None:
+        await process_inner(
             self.get_event_type()
             .unwrap()
             .from_update(
@@ -166,8 +170,8 @@ class BaseStateView(ABCStateView[EventType], BaseView[EventType], ABC, typing.Ge
 
 
 __all__ = (
-    "ABCView",
     "ABCStateView",
-    "BaseView",
+    "ABCView",
     "BaseStateView",
+    "BaseView",
 )

telegrinder/bot/dispatch/view/box.py

@@ -2,38 +2,101 @@ import dataclasses
 
 import typing_extensions as typing
 
+from telegrinder.types.enums import UpdateType
+
 from .abc import ABCView
 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
 
-CallbackQueryViewT = typing.TypeVar(
-    "CallbackQueryViewT", bound=ABCView, default=CallbackQueryView
-)
-InlineQueryViewT = typing.TypeVar(
-    "InlineQueryViewT", bound=ABCView, default=InlineQueryView
+CallbackQueryViewT = typing.TypeVar("CallbackQueryViewT", bound=ABCView, default=CallbackQueryView)
+ChatJoinRequestViewT = typing.TypeVar(
+    "ChatJoinRequestViewT", bound=ABCView, default=ChatJoinRequestView
 )
+ChatMemberViewT = typing.TypeVar("ChatMemberViewT", bound=ABCView, default=ChatMemberView)
+InlineQueryViewT = typing.TypeVar("InlineQueryViewT", bound=ABCView, default=InlineQueryView)
 MessageViewT = typing.TypeVar("MessageViewT", bound=ABCView, default=MessageView)
+RawEventViewT = typing.TypeVar("RawEventViewT", bound=ABCView, default=RawEventView)
 
 
 @dataclasses.dataclass(kw_only=True)
-class ViewBox(typing.Generic[CallbackQueryViewT, InlineQueryViewT, MessageViewT]):
+class ViewBox(
+    typing.Generic[
+        CallbackQueryViewT,
+        ChatJoinRequestViewT,
+        ChatMemberViewT,
+        InlineQueryViewT,
+        MessageViewT,
+        RawEventViewT,
+    ],
+):
     callback_query: CallbackQueryViewT = dataclasses.field(
         default_factory=lambda: typing.cast(CallbackQueryViewT, CallbackQueryView()),
     )
+    chat_join_request: ChatJoinRequestViewT = dataclasses.field(
+        default_factory=lambda: typing.cast(ChatJoinRequestViewT, ChatJoinRequestView()),
+    )
+    chat_member: ChatMemberViewT = dataclasses.field(
+        default_factory=lambda: typing.cast(
+            ChatMemberViewT, ChatMemberView(update_type=UpdateType.CHAT_MEMBER)
+        ),
+    )
+    my_chat_member: ChatMemberViewT = dataclasses.field(
+        default_factory=lambda: typing.cast(
+            ChatMemberViewT, ChatMemberView(update_type=UpdateType.MY_CHAT_MEMBER)
+        ),
+    )
     inline_query: InlineQueryViewT = dataclasses.field(
         default_factory=lambda: typing.cast(InlineQueryViewT, InlineQueryView()),
     )
     message: MessageViewT = dataclasses.field(
+        default_factory=lambda: typing.cast(
+            MessageViewT, MessageView(update_type=UpdateType.MESSAGE)
+        ),
+    )
+    business_message: MessageViewT = dataclasses.field(
+        default_factory=lambda: typing.cast(
+            MessageViewT, MessageView(update_type=UpdateType.BUSINESS_MESSAGE)
+        ),
+    )
+    channel_post: MessageViewT = dataclasses.field(
+        default_factory=lambda: typing.cast(
+            MessageViewT, MessageView(update_type=UpdateType.CHANNEL_POST)
+        ),
+    )
+    edited_message: MessageViewT = dataclasses.field(
+        default_factory=lambda: typing.cast(
+            MessageViewT, MessageView(update_type=UpdateType.EDITED_MESSAGE)
+        ),
+    )
+    edited_business_message: MessageViewT = dataclasses.field(
+        default_factory=lambda: typing.cast(
+            MessageViewT,
+            MessageView(update_type=UpdateType.EDITED_BUSINESS_MESSAGE),
+        ),
+    )
+    edited_channel_post: MessageViewT = dataclasses.field(
+        default_factory=lambda: typing.cast(
+            MessageViewT, MessageView(update_type=UpdateType.EDITED_CHANNEL_POST)
+        ),
+    )
+    any_message: MessageViewT = dataclasses.field(
         default_factory=lambda: typing.cast(MessageViewT, MessageView()),
     )
+    chat_member_updated: ChatMemberViewT = dataclasses.field(
+        default_factory=lambda: typing.cast(ChatMemberViewT, ChatMemberView()),
+    )
+    raw_event: RawEventViewT = dataclasses.field(
+        default_factory=lambda: typing.cast(RawEventViewT, RawEventView()),
+    )
 
     def get_views(self) -> dict[str, ABCView]:
-        return {
-            name: view
-            for name, view in self.__dict__.items()
-            if isinstance(view, ABCView)
-        }
+        """Get all views."""
+
+        return {name: view for name, view in self.__dict__.items() if isinstance(view, ABCView)}
 
 
 __all__ = ("ViewBox",)

telegrinder/bot/dispatch/view/callback_query.py

@@ -1,5 +1,3 @@
-from fntypes.option import Some
-
 from telegrinder.bot.cute_types import CallbackQueryCute
 from telegrinder.bot.dispatch.return_manager import CallbackQueryReturnManager
 
@@ -14,7 +12,7 @@ class CallbackQueryView(BaseStateView[CallbackQueryCute]):
         self.return_manager = CallbackQueryReturnManager()
 
     def get_state_key(self, event: CallbackQueryCute) -> int | None:
-        return event.message.map(lambda variative: variative.v.message_id).unwrap_or_none()
+        return event.message_id.unwrap_or_none()
 
 
 __all__ = ("CallbackQueryView",)

telegrinder/bot/dispatch/view/chat_join_request.py

@@ -0,0 +1,17 @@
+from telegrinder.bot.cute_types import ChatJoinRequestCute
+
+from .abc import BaseStateView
+
+
+class ChatJoinRequestView(BaseStateView[ChatJoinRequestCute]):
+    def __init__(self) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = None
+
+    def get_state_key(self, event: ChatJoinRequestCute) -> int | None:
+        return event.chat_id
+
+
+__all__ = ("ChatJoinRequestView",)

telegrinder/bot/dispatch/view/chat_member.py

@@ -0,0 +1,26 @@
+import typing
+
+from telegrinder.bot.cute_types import ChatMemberUpdatedCute
+from telegrinder.types.enums import UpdateType
+
+from .abc import BaseStateView
+
+ChatMemberUpdateType: typing.TypeAlias = typing.Literal[
+    UpdateType.CHAT_MEMBER,
+    UpdateType.MY_CHAT_MEMBER,
+]
+
+
+class ChatMemberView(BaseStateView[ChatMemberUpdatedCute]):
+    def __init__(self, *, update_type: ChatMemberUpdateType | None = None) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = None
+        self.update_type = update_type
+
+    def get_state_key(self, event: ChatMemberUpdatedCute) -> int | None:
+        return event.chat_id
+
+
+__all__ = ("ChatMemberView",)

telegrinder/bot/dispatch/view/message.py

@@ -1,18 +1,40 @@
+import typing
+
 from telegrinder.bot.cute_types import MessageCute
 from telegrinder.bot.dispatch.return_manager import MessageReturnManager
+from telegrinder.types import Update, UpdateType
 
 from .abc import BaseStateView
 
+MessageUpdateType: typing.TypeAlias = typing.Literal[
+    UpdateType.MESSAGE,
+    UpdateType.BUSINESS_MESSAGE,
+    UpdateType.CHANNEL_POST,
+    UpdateType.EDITED_BUSINESS_MESSAGE,
+    UpdateType.EDITED_CHANNEL_POST,
+    UpdateType.EDITED_MESSAGE,
+]
+
 
 class MessageView(BaseStateView[MessageCute]):
-    def __init__(self) -> None:
+    def __init__(self, *, update_type: MessageUpdateType | None = None) -> None:
         self.auto_rules = []
         self.handlers = []
+        self.update_type = update_type
         self.middlewares = []
         self.return_manager = MessageReturnManager()
 
     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.unwrap_or_none()
+        )
+
 
 __all__ = ("MessageView",)

telegrinder/bot/dispatch/view/raw.py

@@ -0,0 +1,112 @@
+import typing
+
+from telegrinder.api.abc import ABCAPI
+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.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
+
+T = typing.TypeVar("T")
+
+FuncType: typing.TypeAlias = typing.Callable[
+    typing.Concatenate[T, ...],
+    typing.Coroutine[typing.Any, typing.Any, typing.Any],
+]
+
+
+class RawEventView(BaseView[UpdateCute]):
+    def __init__(self) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = None
+
+    @typing.overload
+    def __call__(
+        self,
+        update_type: UpdateType,
+        *rules: ABCRule[UpdateCute],
+    ) -> typing.Callable[
+        [FuncType[UpdateCute]],
+        FuncHandler[UpdateCute, FuncType[UpdateCute], ErrorHandler[UpdateCute]],
+    ]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        update_type: UpdateType,
+        *rules: ABCRule[UpdateCute],
+        dataclass: type[T],
+    ) -> typing.Callable[[FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandler[T]]]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        update_type: UpdateType,
+        *rules: ABCRule[UpdateCute],
+        error_handler: ErrorHandlerT,
+    ) -> typing.Callable[
+        [FuncType[UpdateCute]],
+        FuncHandler[UpdateCute, FuncType[UpdateCute], ErrorHandlerT],
+    ]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        update_type: UpdateType,
+        *rules: ABCRule[UpdateCute],
+        dataclass: type[T],
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        update_type: UpdateType,
+        *rules: ABCRule[UpdateCute],
+        dataclass: typing.Literal[None] = None,
+        error_handler: typing.Literal[None] = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [FuncType[UpdateCute]],
+        FuncHandler[UpdateCute, FuncType[UpdateCute], ErrorHandler[UpdateCute]],
+    ]: ...
+
+    def __call__(  # type: ignore
+        self,
+        update_type: UpdateType,
+        *rules: ABCRule[typing.Any],
+        dataclass: type[typing.Any] | None = None,
+        error_handler: ABCErrorHandler | None = None,
+        is_blocking: bool = True,
+    ):
+        def wrapper(func: FuncType[typing.Any]):
+            func_handler = FuncHandler(
+                func,
+                [*self.auto_rules, *rules],
+                is_blocking=is_blocking,
+                dataclass=dataclass,
+                error_handler=error_handler or ErrorHandler(),
+                update_type=update_type,
+            )
+            self.handlers.append(func_handler)
+            return func_handler
+
+        return wrapper
+
+    async def check(self, event: Update) -> bool:
+        return False
+
+    async def process(self, event: Update, api: ABCAPI) -> bool:
+        return await process_inner(
+            UpdateCute.from_update(event, bound_api=api),
+            event,
+            self.middlewares,
+            self.handlers,
+            self.return_manager,
+        )