telegrinder 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

telegrinder/bot/dispatch/view/base.py

@@ -1,219 +1,102 @@
 import typing
-from abc import ABC, abstractmethod
-from functools import cached_property
-
-from fntypes.option import Nothing, Some
+from collections import deque
 
 from telegrinder.api.api import API
-from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
-from telegrinder.bot.dispatch.handler.func import Func, FuncHandler
+from telegrinder.bot.dispatch.handler.func import FuncHandler, Function
 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.bot.dispatch.view.abc import ABCView
+from telegrinder.bot.rules.abc import ABCRule, Always
+from telegrinder.types.enums import UpdateType
 from telegrinder.types.objects import Update
 
+type Func[**P, T] = typing.Callable[P, typing.Coroutine[typing.Any, typing.Any, T]]
 
-def get_event_model_class[Event: BaseCute](
-    view: "BaseView[Event] | type[BaseView[Event]]",
-) -> Option[type[Event]]:
-    view_class = view if isinstance(view, typing.Type) else view.__class__
-    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):
+    def __init__(self, update_type: UpdateType | None = None) -> None:
+        self.handlers: deque[ABCHandler] = deque()
+        self.middlewares: deque[ABCMiddleware] = deque()
+        self.return_manager: ABCReturnManager | None = None
+        self.update_type = update_type
+        self._auto_rules: ABCRule = Always()
 
-
-class BaseView[Event: BaseCute](ABCView):
-    def __init__(self) -> None:
-        self.handlers: list[ABCHandler[Event]] = []
-        self.middlewares: list[ABCMiddleware[Event]] = []
-        self.return_manager: ABCReturnManager[Event] | None = None
-        self._auto_rules: ABCRule | None = None
+    def __repr__(self) -> str:
+        return "<{}>".format(type(self).__name__)
 
     @property
-    def auto_rules(self) -> tuple[ABCRule] | tuple[()]:
-        return (self._auto_rules,) if self._auto_rules else ()
+    def auto_rules(self) -> ABCRule:
+        return self._auto_rules
 
     @auto_rules.setter
-    def auto_rules(self, value: ABCRule | None) -> None:
+    def auto_rules(self, value: ABCRule | list[ABCRule], /) -> None:
         """Example usage:
 
         ```python
         view.auto_rules = Rule1() & Rule2() | Rule3() & Rule4()
-        view.auto_rules  # (<OrRule>,)
+        view.auto_rules # <OrRule>
 
-        view.auto_rules = None
-        view.auto_rules # ()
+        view.auto_rules = [Rule1(), Rule2()]
+        view.auto_rules # <AndRule>
         ```
         """
-        self._auto_rules = value
-
-    @staticmethod
-    def get_raw_event(update: Update) -> Option[Model]:
-        return getattr(update, update.update_type.value)
+        if isinstance(value, list):
+            for rule in value:
+                self._auto_rules = self._auto_rules & rule
+        else:
+            self._auto_rules = value
 
-    @cached_property
-    def event_model_class(self) -> Option[type[Event]]:
-        return get_event_model_class(self)
-
-    @typing.overload
-    @classmethod
-    def to_handler[**P, R](
-        cls,
-        *rules: ABCRule,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[Event, Func[P, R], ErrorHandler[Event]],
-    ]: ...
-
-    @typing.overload
     @classmethod
-    def to_handler[**P, Dataclass, R](
-        cls,
-        *rules: ABCRule,
-        dataclass: type[Dataclass],
-        final: bool = True,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[Dataclass, Func[P, R], ErrorHandler[Dataclass]],
-    ]: ...
-
-    @typing.overload
-    @classmethod
-    def to_handler[**P, ErrorHandlerT: ABCErrorHandler, R](
-        cls,
-        *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[Event, Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    @classmethod
-    def to_handler[**P, Dataclass, ErrorHandlerT: ABCErrorHandler, R](
-        cls,
-        *rules: ABCRule,
-        dataclass: type[Dataclass],
-        error_handler: ErrorHandlerT,
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[Dataclass, Func[P, R], ErrorHandlerT]]: ...
-
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule,
-        dataclass: type[typing.Any] | None = None,
-        error_handler: ABCErrorHandler | None = None,
-        final: bool = True,
-    ) -> typing.Callable[..., typing.Any]:
-        def wrapper(func):
+    def to_handler[T: Function](cls, *rules: ABCRule, final: bool = True) -> typing.Callable[[T], FuncHandler[T]]:
+        def wrapper(func: T, /) -> FuncHandler[T]:
             return FuncHandler(
-                func,
-                list(rules),
+                function=func,
+                rules=list(rules),
                 final=final,
-                dataclass=dataclass,
-                error_handler=error_handler or ErrorHandler(),
             )
 
         return wrapper
 
-    @typing.overload
-    def __call__[**P, R](
-        self,
-        *rules: ABCRule,
-        final: bool = True,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[Event, Func[P, R], ErrorHandler[Event]],
-    ]: ...
+    def __call__[T: Function](self, *rules: ABCRule, final: bool = True) -> typing.Callable[[T], T]:
+        def wrapper(func: T, /) -> T:
+            self.handlers.append(
+                FuncHandler(
+                    function=func,
+                    rules=[self.auto_rules, *rules],
+                    final=final,
+                ),
+            )
+            return func
+
+        return wrapper
 
     @typing.overload
-    def __call__[**P, Dataclass, R](
-        self,
-        *rules: ABCRule,
-        dataclass: type[Dataclass],
-        final: bool = True,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[Dataclass, Func[P, R], ErrorHandler[Dataclass]],
-    ]: ...
+    def register_middleware[T: ABCMiddleware](self, middleware_cls: type[T], /) -> type[T]: ...
 
     @typing.overload
-    def __call__[**P, ErrorHandlerT: ABCErrorHandler, R](
-        self,
-        *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[Event, Func[P, R], ErrorHandlerT]]: ...
+    def register_middleware(self, middleware: ABCMiddleware, /) -> None: ...
 
-    def __call__[**P, R](
+    def register_middleware(
         self,
-        *rules: ABCRule,
-        dataclass: type[typing.Any] | None = None,
-        error_handler: ABCErrorHandler | None = None,
-        final: bool = True,
-    ) -> typing.Callable[..., typing.Any]:
-        def wrapper(func: typing.Callable[..., typing.Any]):
-            func_handler = FuncHandler(
-                func,
-                [*self.auto_rules, *rules],
-                final=final,
-                dataclass=dataclass,
-                error_handler=error_handler or ErrorHandler(),
-            )
-            self.handlers.append(func_handler)
-            return func_handler
-
-        return wrapper
-
-    def register_middleware[Middleware: ABCMiddleware](self, *args: typing.Any, **kwargs: typing.Any):
-        def wrapper(cls: type[Middleware]) -> type[Middleware]:
-            self.middlewares.append(cls(*args, **kwargs))
-            return cls
-
-        return wrapper
+        middleware: type[ABCMiddleware] | ABCMiddleware,
+    ) -> typing.Callable[..., typing.Any] | None:
+        self.middlewares.append(middleware() if isinstance(middleware, type) else middleware)
+        return middleware if isinstance(middleware, type) else None
 
     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
+        if self.update_type is not None and event.update_type != self.update_type:
+            return False
+        return bool(self.handlers or self.middlewares)
 
     async def process(self, event: Update, api: API, context: Context) -> bool:
         return await process_inner(
             api,
-            self.event_model_class.unwrap().from_update(
-                update=self.get_raw_event(event).unwrap(),
-                bound_api=api,
-            ),
             event,
             context,
-            self.middlewares,
-            self.handlers,
-            self.return_manager,
+            self,
         )
 
     def load(self, external: typing.Self, /) -> None:
@@ -221,11 +104,4 @@ class BaseView[Event: BaseCute](ABCView):
         self.middlewares.extend(external.middlewares)
 
 
-class BaseStateView[Event: BaseCute](ABCStateView[Event], BaseView[Event], ABC):
-    @classmethod
-    @abstractmethod
-    def get_state_key(cls, event: Event) -> int | None:
-        pass
-
-
-__all__ = ("ABCStateView", "ABCView", "BaseStateView", "BaseView")
+__all__ = ("BaseView",)

telegrinder/bot/dispatch/view/box.py

@@ -6,6 +6,7 @@ from telegrinder.bot.dispatch.view import (
     callback_query,
     chat_join_request,
     chat_member,
+    error,
     inline_query,
     message,
     pre_checkout_query,
@@ -33,6 +34,7 @@ ChatMemberView = typing.TypeVar("ChatMemberView", bound=ABCView, default=chat_me
 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)
+ErrorView = typing.TypeVar("ErrorView", bound=ABCView, default=error.ErrorView)
 
 
 @dataclasses.dataclass(kw_only=True)
@@ -45,6 +47,7 @@ class ViewBox(
         MessageView,
         PreCheckoutQueryView,
         RawEventView,
+        ErrorView,
     ],
 ):
     callback_query_view: dataclasses.InitVar[CallbackQueryView | None] = None
@@ -62,6 +65,7 @@ class ViewBox(
     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
+    error_view: dataclasses.InitVar[ErrorView | None] = None
 
     def __post_init__(
         self,
@@ -80,61 +84,58 @@ class ViewBox(
         chat_member_updated_view: ChatMemberView | None = None,
         pre_checkout_query_view: PreCheckoutQueryView | None = None,
         raw_event_view: RawEventView | None = None,
+        error_view: ErrorView | None = None,
     ) -> None:
         self.callback_query = typing.cast(
-            CallbackQueryView,
+            "CallbackQueryView",
             callback_query_view or callback_query.CallbackQueryView(),
         )
         self.chat_join_request = typing.cast(
-            ChatJoinRequestView,
+            "ChatJoinRequestView",
             chat_join_request_view or chat_join_request.ChatJoinRequestView(),
         )
         self.chat_member = typing.cast(
-            ChatMemberView,
+            "ChatMemberView",
             chat_member_view or chat_member.ChatMemberView(update_type=UpdateType.CHAT_MEMBER),
         )
         self.my_chat_member = typing.cast(
-            ChatMemberView,
+            "ChatMemberView",
             my_chat_member_view or chat_member.ChatMemberView(update_type=UpdateType.MY_CHAT_MEMBER),
         )
         self.inline_query = typing.cast(
-            InlineQueryView,
+            "InlineQueryView",
             inline_query_view or inline_query.InlineQueryView(),
         )
         self.message = typing.cast(
-            MessageView,
+            "MessageView",
             message_view or message.MessageView(update_type=UpdateType.MESSAGE),
         )
         self.business_message = typing.cast(
-            MessageView,
+            "MessageView",
             business_message_view or message.MessageView(update_type=UpdateType.BUSINESS_MESSAGE),
         )
         self.channel_post = typing.cast(
-            MessageView,
+            "MessageView",
             channel_post_view or message.MessageView(update_type=UpdateType.CHANNEL_POST),
         )
         self.edited_message = typing.cast(
-            MessageView,
+            "MessageView",
             edited_message_view or message.MessageView(update_type=UpdateType.EDITED_MESSAGE),
         )
         self.edited_business_message = typing.cast(
-            MessageView,
+            "MessageView",
             edited_business_message_view or message.MessageView(update_type=UpdateType.EDITED_BUSINESS_MESSAGE),
         )
         self.edited_channel_post = typing.cast(
-            MessageView,
+            "MessageView",
             edited_channel_post_view or message.MessageView(update_type=UpdateType.EDITED_CHANNEL_POST),
         )
         self.pre_checkout_query = typing.cast(
-            PreCheckoutQueryView,
+            "PreCheckoutQueryView",
             pre_checkout_query_view or pre_checkout_query.PreCheckoutQueryView(),
         )
-        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())
+        self.raw_event = typing.cast("RawEventView", raw_event_view or raw.RawEventView())
+        self.error = typing.cast("ErrorView", error_view or error.ErrorView())
 
 
 __all__ = ("ViewBox",)

telegrinder/bot/dispatch/view/callback_query.py

@@ -1,16 +1,12 @@
-from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
 from telegrinder.bot.dispatch.return_manager.callback_query import CallbackQueryReturnManager
-from telegrinder.bot.dispatch.view.base import BaseStateView
+from telegrinder.bot.dispatch.view.base import BaseView
+from telegrinder.types.enums import UpdateType
 
 
-class CallbackQueryView(BaseStateView[CallbackQueryCute]):
+class CallbackQueryView(BaseView):
     def __init__(self) -> None:
-        super().__init__()
+        super().__init__(UpdateType.CALLBACK_QUERY)
         self.return_manager = CallbackQueryReturnManager()
 
-    @classmethod
-    def get_state_key(cls, event: CallbackQueryCute) -> int | None:
-        return event.message_id.unwrap_or_none()
-
 
 __all__ = ("CallbackQueryView",)

telegrinder/bot/dispatch/view/chat_join_request.py

@@ -1,11 +1,10 @@
-from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
-from telegrinder.bot.dispatch.view.base import BaseStateView
+from telegrinder.bot.dispatch.view.base import BaseView
+from telegrinder.types.enums import UpdateType
 
 
-class ChatJoinRequestView(BaseStateView[ChatJoinRequestCute]):
-    @classmethod
-    def get_state_key(cls, event: ChatJoinRequestCute) -> int | None:
-        return event.chat_id
+class ChatJoinRequestView(BaseView):
+    def __init__(self) -> None:
+        super().__init__(UpdateType.CHAT_JOIN_REQUEST)
 
 
 __all__ = ("ChatJoinRequestView",)

telegrinder/bot/dispatch/view/chat_member.py

@@ -1,37 +1,17 @@
 import typing
 
-from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
-from telegrinder.bot.dispatch.view.base import BaseStateView
+from telegrinder.bot.dispatch.view.base import BaseView
 from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Update
 
-ChatMemberUpdateType: typing.TypeAlias = typing.Literal[
+type ChatMemberUpdateType = typing.Literal[
     UpdateType.CHAT_MEMBER,
     UpdateType.MY_CHAT_MEMBER,
 ]
 
 
-class ChatMemberView(BaseStateView[ChatMemberUpdatedCute]):
-    def __init__(self, *, update_type: ChatMemberUpdateType | None = None) -> None:
-        super().__init__()
-        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,
-        )
-
-    @classmethod
-    def get_state_key(cls, 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)
-        )
+class ChatMemberView(BaseView):
+    def __init__(self, update_type: ChatMemberUpdateType) -> None:
+        super().__init__(update_type)
 
 
 __all__ = ("ChatMemberView",)

telegrinder/bot/dispatch/view/error.py

@@ -0,0 +1,9 @@
+from telegrinder.bot.dispatch.view.base import BaseView
+
+
+class ErrorView(BaseView):
+    def __init__(self) -> None:
+        super().__init__()
+
+
+__all__ = ("ErrorView",)

telegrinder/bot/dispatch/view/inline_query.py

@@ -1,16 +1,12 @@
-from telegrinder.bot.cute_types.inline_query import InlineQueryCute
 from telegrinder.bot.dispatch.return_manager import InlineQueryReturnManager
-from telegrinder.bot.dispatch.view.base import BaseStateView
+from telegrinder.bot.dispatch.view.base import BaseView
+from telegrinder.types.enums import UpdateType
 
 
-class InlineQueryView(BaseStateView[InlineQueryCute]):
+class InlineQueryView(BaseView):
     def __init__(self) -> None:
-        super().__init__()
+        super().__init__(UpdateType.INLINE_QUERY)
         self.return_manager = InlineQueryReturnManager()
 
-    @classmethod
-    def get_state_key(cls, event: InlineQueryCute) -> int | None:
-        return event.from_user.id
-
 
 __all__ = ("InlineQueryView",)

telegrinder/bot/dispatch/view/message.py

@@ -1,12 +1,10 @@
 import typing
 
-from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.dispatch.return_manager.message import MessageReturnManager
-from telegrinder.bot.dispatch.view.base import BaseStateView
+from telegrinder.bot.dispatch.view.base import BaseView
 from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Update
 
-MessageUpdateType: typing.TypeAlias = typing.Literal[
+type MessageUpdateType = typing.Literal[
     UpdateType.MESSAGE,
     UpdateType.BUSINESS_MESSAGE,
     UpdateType.CHANNEL_POST,
@@ -16,28 +14,10 @@ MessageUpdateType: typing.TypeAlias = typing.Literal[
 ]
 
 
-class MessageView(BaseStateView[MessageCute]):
-    def __init__(self, *, update_type: MessageUpdateType | None = None) -> None:
-        super().__init__()
-        self.update_type = update_type
+class MessageView(BaseView):
+    def __init__(self, update_type: MessageUpdateType) -> None:
+        super().__init__(update_type)
         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,
-        )
-
-    @classmethod
-    def get_state_key(cls, event: MessageCute) -> 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__ = ("MessageView",)

telegrinder/bot/dispatch/view/pre_checkout_query.py

@@ -1,16 +1,12 @@
-from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
 from telegrinder.bot.dispatch.return_manager.pre_checkout_query import PreCheckoutQueryManager
-from telegrinder.bot.dispatch.view.base import BaseStateView
+from telegrinder.bot.dispatch.view.base import BaseView
+from telegrinder.types.enums import UpdateType
 
 
-class PreCheckoutQueryView(BaseStateView[PreCheckoutQueryCute]):
+class PreCheckoutQueryView(BaseView):
     def __init__(self) -> None:
-        super().__init__()
+        super().__init__(UpdateType.PRE_CHECKOUT_QUERY)
         self.return_manager = PreCheckoutQueryManager()
 
-    @classmethod
-    def get_state_key(cls, event: PreCheckoutQueryCute) -> int | None:
-        return event.from_user.id
-
 
 __all__ = ("PreCheckoutQueryView",)