telegrinder 0.3.3.post1__py3-none-any.whl → 0.3.4.post1__py3-none-any.whl

telegrinder/bot/dispatch/view/base.py

@@ -1,200 +1,200 @@
-import typing
-from abc import ABC, abstractmethod
-from functools import cached_property
-
-from fntypes.option import Nothing, Some
-
-from telegrinder.api.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 Func, FuncHandler
-from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
-from telegrinder.bot.dispatch.process import process_inner
-from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
-from telegrinder.bot.dispatch.view.abc import ABCStateView, ABCView
-from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.model import Model
-from telegrinder.msgspec_utils import Option
-from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
-from telegrinder.types.objects import Update
-
-P = typing.ParamSpec("P")
-R = typing.TypeVar("R", covariant=True)
-Event = typing.TypeVar("Event", bound=BaseCute)
-ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler)
-MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
-
-
-def get_event_model_class(view: "BaseView[Event]") -> Option[type[Event]]:
-    for base in view.__class__.__bases__ + (view.__class__,):
-        if "__orig_bases__" not in base.__dict__:
-            continue
-
-        for orig_base in base.__dict__["__orig_bases__"]:
-            origin_base = typing.get_origin(orig_base) or orig_base
-            if not isinstance(origin_base, type) and not issubclass(origin_base, object):
-                continue
-
-            for generic_type in typing.get_args(orig_base):
-                orig_generic_type = typing.get_origin(generic_type) or generic_type
-                if isinstance(orig_generic_type, type) and issubclass(orig_generic_type, BaseCute):
-                    return Some(generic_type)
-
-    return Nothing()
-
-
-class BaseView(ABCView, typing.Generic[Event]):
-    auto_rules: list[ABCRule]
-    handlers: list[ABCHandler[Event]]
-    middlewares: list[ABCMiddleware[Event]]
-    return_manager: ABCReturnManager[Event] | None = None
-
-    @staticmethod
-    def get_raw_event(update: Update) -> Option[Model]:
-        return getattr(update, update.update_type.value)
-
-    @cached_property
-    def event_model_class(self) -> Option[type[Event]]:
-        return get_event_model_class(self)
-
-    @typing.overload
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[Event, Func[P, R], ErrorHandler[Event]],
-    ]: ...
-
-    @typing.overload
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[Event, Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule,
-        error_handler: typing.Literal[None] = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[Event, Func[P, R], ErrorHandler[Event]],
-    ]: ...
-
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule,
-        error_handler: ABCErrorHandler | None = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[..., typing.Any]:
-        def wrapper(func):
-            return FuncHandler(
-                func,
-                list(rules),
-                is_blocking=is_blocking,
-                dataclass=None,
-                error_handler=error_handler or ErrorHandler(),
-            )
-
-        return wrapper
-
-    @typing.overload
-    def __call__(
-        self,
-        *rules: ABCRule,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[Event, Func[P, R], ErrorHandler[Event]],
-    ]: ...
-
-    @typing.overload
-    def __call__(  # type: ignore
-        self,
-        *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[Event, Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def __call__(
-        self,
-        *rules: ABCRule,
-        error_handler: typing.Literal[None] = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[Event, Func[P, R], ErrorHandler[Event]],
-    ]: ...
-
-    def __call__(
-        self,
-        *rules: ABCRule,
-        error_handler: ABCErrorHandler | None = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[..., typing.Any]:
-        def wrapper(func):
-            func_handler = FuncHandler(
-                func,
-                [*self.auto_rules, *rules],
-                is_blocking=is_blocking,
-                dataclass=None,
-                error_handler=error_handler or ErrorHandler(),
-            )
-            self.handlers.append(func_handler)
-            return func_handler
-
-        return wrapper
-
-    def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
-        def wrapper(cls: type[MiddlewareT]) -> type[MiddlewareT]:
-            self.middlewares.append(cls(*args, **kwargs))
-            return cls
-
-        return wrapper
-
-    async def check(self, event: Update) -> bool:
-        match self.get_raw_event(event):
-            case Some(e) if issubclass(
-                self.event_model_class.expect(
-                    "{!r} has no event model class in generic.".format(self.__class__.__qualname__),
-                ),
-                e.__class__,
-            ) and (self.handlers or self.middlewares):
-                return True
-            case _:
-                return False
-
-    async def process(self, event: Update, api: API) -> bool:
-        return await process_inner(
-            api,
-            self.event_model_class.unwrap().from_update(
-                update=self.get_raw_event(event).unwrap(),
-                bound_api=api,
-            ),
-            event,
-            self.middlewares,
-            self.handlers,
-            self.return_manager,
-        )
-
-    def load(self, external: typing.Self) -> None:
-        self.auto_rules.extend(external.auto_rules)
-        self.handlers.extend(external.handlers)
-        self.middlewares.extend(external.middlewares)
-
-
-class BaseStateView(ABCStateView[Event], BaseView[Event], ABC, typing.Generic[Event]):
-    @abstractmethod
-    def get_state_key(self, event: Event) -> int | None:
-        pass
-
-
-__all__ = ("ABCStateView", "ABCView", "BaseStateView", "BaseView")
+import typing
+from abc import ABC, abstractmethod
+from functools import cached_property
+
+from fntypes.option import Nothing, Some
+
+from telegrinder.api.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 Func, FuncHandler
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
+from telegrinder.bot.dispatch.process import process_inner
+from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
+from telegrinder.bot.dispatch.view.abc import ABCStateView, ABCView
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.model import Model
+from telegrinder.msgspec_utils import Option
+from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
+from telegrinder.types.objects import Update
+
+P = typing.ParamSpec("P")
+R = typing.TypeVar("R", covariant=True)
+Event = typing.TypeVar("Event", bound=BaseCute)
+ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler)
+MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
+
+
+def get_event_model_class(view: "BaseView[Event]") -> Option[type[Event]]:
+    for base in view.__class__.__bases__ + (view.__class__,):
+        if "__orig_bases__" not in base.__dict__:
+            continue
+
+        for orig_base in base.__dict__["__orig_bases__"]:
+            origin_base = typing.get_origin(orig_base) or orig_base
+            if not isinstance(origin_base, type) and not issubclass(origin_base, object):
+                continue
+
+            for generic_type in typing.get_args(orig_base):
+                orig_generic_type = typing.get_origin(generic_type) or generic_type
+                if isinstance(orig_generic_type, type) and issubclass(orig_generic_type, BaseCute):
+                    return Some(generic_type)
+
+    return Nothing()
+
+
+class BaseView(ABCView, typing.Generic[Event]):
+    auto_rules: list[ABCRule]
+    handlers: list[ABCHandler[Event]]
+    middlewares: list[ABCMiddleware[Event]]
+    return_manager: ABCReturnManager[Event] | None = None
+
+    @staticmethod
+    def get_raw_event(update: Update) -> Option[Model]:
+        return getattr(update, update.update_type.value)
+
+    @cached_property
+    def event_model_class(self) -> Option[type[Event]]:
+        return get_event_model_class(self)
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule,
+    ) -> typing.Callable[
+        [Func[P, R]],
+        FuncHandler[Event, Func[P, R], ErrorHandler[Event]],
+    ]: ...
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule,
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[Event, Func[P, R], ErrorHandlerT]]: ...
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule,
+        error_handler: typing.Literal[None] = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [Func[P, R]],
+        FuncHandler[Event, Func[P, R], ErrorHandler[Event]],
+    ]: ...
+
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule,
+        error_handler: ABCErrorHandler | None = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[..., typing.Any]:
+        def wrapper(func):
+            return FuncHandler(
+                func,
+                list(rules),
+                is_blocking=is_blocking,
+                dataclass=None,
+                error_handler=error_handler or ErrorHandler(),
+            )
+
+        return wrapper
+
+    @typing.overload
+    def __call__(
+        self,
+        *rules: ABCRule,
+    ) -> typing.Callable[
+        [Func[P, R]],
+        FuncHandler[Event, Func[P, R], ErrorHandler[Event]],
+    ]: ...
+
+    @typing.overload
+    def __call__(  # type: ignore
+        self,
+        *rules: ABCRule,
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[Event, Func[P, R], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        *rules: ABCRule,
+        error_handler: typing.Literal[None] = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [Func[P, R]],
+        FuncHandler[Event, Func[P, R], ErrorHandler[Event]],
+    ]: ...
+
+    def __call__(
+        self,
+        *rules: ABCRule,
+        error_handler: ABCErrorHandler | None = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[..., typing.Any]:
+        def wrapper(func):
+            func_handler = FuncHandler(
+                func,
+                [*self.auto_rules, *rules],
+                is_blocking=is_blocking,
+                dataclass=None,
+                error_handler=error_handler or ErrorHandler(),
+            )
+            self.handlers.append(func_handler)
+            return func_handler
+
+        return wrapper
+
+    def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
+        def wrapper(cls: type[MiddlewareT]) -> type[MiddlewareT]:
+            self.middlewares.append(cls(*args, **kwargs))
+            return cls
+
+        return wrapper
+
+    async def check(self, event: Update) -> bool:
+        match self.get_raw_event(event):
+            case Some(e) if issubclass(
+                self.event_model_class.expect(
+                    "{!r} has no event model class in generic.".format(self.__class__.__qualname__),
+                ),
+                e.__class__,
+            ) and (self.handlers or self.middlewares):
+                return True
+            case _:
+                return False
+
+    async def process(self, event: Update, api: API) -> bool:
+        return await process_inner(
+            api,
+            self.event_model_class.unwrap().from_update(
+                update=self.get_raw_event(event).unwrap(),
+                bound_api=api,
+            ),
+            event,
+            self.middlewares,
+            self.handlers,
+            self.return_manager,
+        )
+
+    def load(self, external: typing.Self) -> None:
+        self.auto_rules.extend(external.auto_rules)
+        self.handlers.extend(external.handlers)
+        self.middlewares.extend(external.middlewares)
+
+
+class BaseStateView(ABCStateView[Event], BaseView[Event], ABC, typing.Generic[Event]):
+    @abstractmethod
+    def get_state_key(self, event: Event) -> int | None:
+        pass
+
+
+__all__ = ("ABCStateView", "ABCView", "BaseStateView", "BaseView")

telegrinder/bot/dispatch/view/box.py

@@ -1,129 +1,129 @@
-import dataclasses
-
-import typing_extensions as typing
-
-from telegrinder.bot.dispatch.view import (
-    callback_query,
-    chat_join_request,
-    chat_member,
-    inline_query,
-    message,
-    raw,
-)
-from telegrinder.bot.dispatch.view.abc import ABCEventRawView, ABCView
-from telegrinder.types.enums import UpdateType
-
-CallbackQueryView = typing.TypeVar(
-    "CallbackQueryView", bound=ABCView, default=callback_query.CallbackQueryView
-)
-ChatJoinRequestView = typing.TypeVar(
-    "ChatJoinRequestView", bound=ABCView, default=chat_join_request.ChatJoinRequestView
-)
-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=ABCEventRawView, default=raw.RawEventView)
-
-
-@dataclasses.dataclass(kw_only=True)
-class ViewBox(
-    typing.Generic[
-        CallbackQueryView,
-        ChatJoinRequestView,
-        ChatMemberView,
-        InlineQueryView,
-        MessageView,
-        RawEventView,
-    ],
-):
-    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_view or callback_query.CallbackQueryView(),
-        )
-        self.chat_join_request = typing.cast(
-            ChatJoinRequestView,
-            chat_join_request_view or chat_join_request.ChatJoinRequestView(),
-        )
-        self.chat_member = typing.cast(
-            ChatMemberView,
-            chat_member_view or chat_member.ChatMemberView(update_type=UpdateType.CHAT_MEMBER),
-        )
-        self.my_chat_member = typing.cast(
-            ChatMemberView,
-            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_view or message.MessageView(update_type=UpdateType.MESSAGE),
-        )
-        self.business_message = typing.cast(
-            MessageView,
-            business_message_view or message.MessageView(update_type=UpdateType.BUSINESS_MESSAGE),
-        )
-        self.channel_post = typing.cast(
-            MessageView,
-            channel_post_view or message.MessageView(update_type=UpdateType.CHANNEL_POST),
-        )
-        self.edited_message = typing.cast(
-            MessageView,
-            edited_message_view or message.MessageView(update_type=UpdateType.EDITED_MESSAGE),
-        )
-        self.edited_business_message = typing.cast(
-            MessageView,
-            edited_business_message_view
-            or message.MessageView(update_type=UpdateType.EDITED_BUSINESS_MESSAGE),
-        )
-        self.edited_channel_post = typing.cast(
-            MessageView,
-            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."""
-
-        return {name: view for name, view in self.__dict__.items() if isinstance(view, ABCView)}
-
-
-__all__ = ("ViewBox",)
+import dataclasses
+
+import typing_extensions as typing
+
+from telegrinder.bot.dispatch.view import (
+    callback_query,
+    chat_join_request,
+    chat_member,
+    inline_query,
+    message,
+    raw,
+)
+from telegrinder.bot.dispatch.view.abc import ABCEventRawView, ABCView
+from telegrinder.types.enums import UpdateType
+
+CallbackQueryView = typing.TypeVar(
+    "CallbackQueryView", bound=ABCView, default=callback_query.CallbackQueryView
+)
+ChatJoinRequestView = typing.TypeVar(
+    "ChatJoinRequestView", bound=ABCView, default=chat_join_request.ChatJoinRequestView
+)
+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=ABCEventRawView, default=raw.RawEventView)
+
+
+@dataclasses.dataclass(kw_only=True)
+class ViewBox(
+    typing.Generic[
+        CallbackQueryView,
+        ChatJoinRequestView,
+        ChatMemberView,
+        InlineQueryView,
+        MessageView,
+        RawEventView,
+    ],
+):
+    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_view or callback_query.CallbackQueryView(),
+        )
+        self.chat_join_request = typing.cast(
+            ChatJoinRequestView,
+            chat_join_request_view or chat_join_request.ChatJoinRequestView(),
+        )
+        self.chat_member = typing.cast(
+            ChatMemberView,
+            chat_member_view or chat_member.ChatMemberView(update_type=UpdateType.CHAT_MEMBER),
+        )
+        self.my_chat_member = typing.cast(
+            ChatMemberView,
+            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_view or message.MessageView(update_type=UpdateType.MESSAGE),
+        )
+        self.business_message = typing.cast(
+            MessageView,
+            business_message_view or message.MessageView(update_type=UpdateType.BUSINESS_MESSAGE),
+        )
+        self.channel_post = typing.cast(
+            MessageView,
+            channel_post_view or message.MessageView(update_type=UpdateType.CHANNEL_POST),
+        )
+        self.edited_message = typing.cast(
+            MessageView,
+            edited_message_view or message.MessageView(update_type=UpdateType.EDITED_MESSAGE),
+        )
+        self.edited_business_message = typing.cast(
+            MessageView,
+            edited_business_message_view
+            or message.MessageView(update_type=UpdateType.EDITED_BUSINESS_MESSAGE),
+        )
+        self.edited_channel_post = typing.cast(
+            MessageView,
+            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."""
+
+        return {name: view for name, view in self.__dict__.items() if isinstance(view, ABCView)}
+
+
+__all__ = ("ViewBox",)