telegrinder 0.3.4.post1__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/bot/dispatch/return_manager/abc.py

@@ -7,11 +7,8 @@ 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=Model, contravariant=True)
 
-
-def get_union_types(t: types.UnionType) -> tuple[type, ...] | None:
+def get_union_types(t: types.UnionType | typing.Any) -> tuple[type[typing.Any], ...] | None:
     if type(t) in (types.UnionType, typing._UnionGenericAlias):  # type: ignore
         return tuple(typing.get_origin(x) or x for x in typing.get_args(t))
     return None
@@ -33,13 +30,13 @@ class Manager:
         await self.callback(*args, **kwargs)
 
 
-class ABCReturnManager(ABC, typing.Generic[Event]):
+class ABCReturnManager[Event: Model](ABC):
     @abstractmethod
     async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
         pass
 
 
-class BaseReturnManager(ABCReturnManager[Event]):
+class BaseReturnManager[Event: Model](ABCReturnManager[Event]):
     def __repr__(self) -> str:
         return "<{}: {}>".format(
             self.__class__.__name__,
@@ -63,7 +60,6 @@ class BaseReturnManager(ABCReturnManager[Event]):
     @staticmethod
     async def ctx_manager(value: Context, event: Event, ctx: Context) -> None:
         """Basic manager for returning context from handler."""
-
         ctx.update(value)
 
     async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
@@ -74,13 +70,13 @@ class BaseReturnManager(ABCReturnManager[Event]):
                 await manager(response, event, ctx)
 
     @typing.overload
-    def register_manager(
+    def register_manager[T](
         self,
         return_type: type[T],
     ) -> typing.Callable[[typing.Callable[[T, Event, Context], typing.Awaitable[typing.Any]]], Manager]: ...
 
     @typing.overload
-    def register_manager(
+    def register_manager[T](
         self,
         return_type: tuple[type[T], ...],
     ) -> typing.Callable[
@@ -88,7 +84,7 @@ class BaseReturnManager(ABCReturnManager[Event]):
         Manager,
     ]: ...
 
-    def register_manager(
+    def register_manager[T](
         self,
         return_type: type[T] | tuple[type[T], ...],
     ) -> typing.Callable[

telegrinder/bot/dispatch/return_manager/pre_checkout_query.py

@@ -0,0 +1,20 @@
+import typing
+
+from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
+
+
+class PreCheckoutQueryManager(BaseReturnManager[PreCheckoutQueryCute]):
+    @register_manager(bool)
+    @staticmethod
+    async def bool_manager(value: bool, event: PreCheckoutQueryCute, ctx: Context) -> None:
+        await event.answer(value)
+
+    @register_manager(dict[str, typing.Any])
+    @staticmethod
+    async def dict_manager(value: dict[str, typing.Any], event: PreCheckoutQueryCute, ctx: Context) -> None:
+        await event.answer(**value)
+
+
+__all__ = ("PreCheckoutQueryManager",)

telegrinder/bot/dispatch/view/__init__.py

@@ -6,6 +6,7 @@ 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.pre_checkout_query import PreCheckoutQueryView
 from telegrinder.bot.dispatch.view.raw import RawEventView
 
 __all__ = (
@@ -18,6 +19,7 @@ __all__ = (
     "ChatMemberView",
     "InlineQueryView",
     "MessageView",
+    "PreCheckoutQueryView",
     "RawEventView",
     "ViewBox",
 )

telegrinder/bot/dispatch/view/abc.py

@@ -3,11 +3,10 @@ from abc import ABC, abstractmethod
 
 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.types.objects import Update
 
-Event = typing.TypeVar("Event", bound=BaseCute)
-
 
 class ABCView(ABC):
     def __repr__(self) -> str:
@@ -18,19 +17,24 @@ class ABCView(ABC):
         pass
 
     @abstractmethod
-    async def process(self, event: Update, api: API) -> bool:
+    async def process(
+        self,
+        event: Update,
+        api: API[typing.Any],
+        context: Context,
+    ) -> bool:
         pass
 
     @abstractmethod
-    def load(self, external: typing.Self) -> None:
+    def load(self, external: typing.Self, /) -> None:
         pass
 
 
-class ABCEventRawView(ABCView, ABC, typing.Generic[Event]):
+class ABCEventRawView[Event: BaseCute](ABCView, ABC):
     handlers: list[ABCHandler[Event]]
 
 
-class ABCStateView(ABCView, typing.Generic[Event]):
+class ABCStateView[Event: BaseCute](ABCView):
     @abstractmethod
     def get_state_key(self, event: Event) -> int | None:
         pass

telegrinder/bot/dispatch/view/base.py

@@ -6,6 +6,7 @@ from fntypes.option import Nothing, Some
 
 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.middleware.abc import ABCMiddleware
@@ -18,15 +19,12 @@ 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__,):
+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
 
@@ -43,11 +41,30 @@ def get_event_model_class(view: "BaseView[Event]") -> Option[type[Event]]:
     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
+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
+
+    @property
+    def auto_rules(self) -> tuple[ABCRule] | tuple[()]:
+        return (self._auto_rules,) if self._auto_rules else ()
+
+    @auto_rules.setter
+    def auto_rules(self, value: ABCRule | None) -> None:
+        """Example usage:
+
+        ```python
+        view.auto_rules = Rule1() & Rule2() | Rule3() & Rule4()
+        view.auto_rules  # (<OrRule>,)
+
+        view.auto_rules = None
+        view.auto_rules # ()
+        ```
+        """
+        self._auto_rules = value
 
     @staticmethod
     def get_raw_event(update: Update) -> Option[Model]:
@@ -59,7 +76,7 @@ class BaseView(ABCView, typing.Generic[Event]):
 
     @typing.overload
     @classmethod
-    def to_handler(
+    def to_handler[**P, R](
         cls,
         *rules: ABCRule,
     ) -> typing.Callable[
@@ -69,83 +86,96 @@ class BaseView(ABCView, typing.Generic[Event]):
 
     @typing.overload
     @classmethod
-    def to_handler(
+    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,
-        is_blocking: bool = True,
+        final: bool = True,
     ) -> typing.Callable[[Func[P, R]], FuncHandler[Event, Func[P, R], ErrorHandlerT]]: ...
 
     @typing.overload
     @classmethod
-    def to_handler(
+    def to_handler[**P, Dataclass, ErrorHandlerT: ABCErrorHandler, R](
         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]],
-    ]: ...
+        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,
-        is_blocking: bool = True,
+        final: bool = True,
     ) -> typing.Callable[..., typing.Any]:
         def wrapper(func):
             return FuncHandler(
                 func,
                 list(rules),
-                is_blocking=is_blocking,
-                dataclass=None,
+                final=final,
+                dataclass=dataclass,
                 error_handler=error_handler or ErrorHandler(),
             )
 
         return wrapper
 
     @typing.overload
-    def __call__(
+    def __call__[**P, R](
         self,
         *rules: ABCRule,
+        final: bool = True,
     ) -> typing.Callable[
         [Func[P, R]],
         FuncHandler[Event, Func[P, R], ErrorHandler[Event]],
     ]: ...
 
     @typing.overload
-    def __call__(  # type: ignore
+    def __call__[**P, Dataclass, R](
         self,
         *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[Event, Func[P, R], ErrorHandlerT]]: ...
+        dataclass: type[Dataclass],
+        final: bool = True,
+    ) -> typing.Callable[
+        [Func[P, R]],
+        FuncHandler[Dataclass, Func[P, R], ErrorHandler[Dataclass]],
+    ]: ...
 
     @typing.overload
-    def __call__(
+    def __call__[**P, ErrorHandlerT: ABCErrorHandler, R](
         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]],
-    ]: ...
+        error_handler: ErrorHandlerT,
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[Event, Func[P, R], ErrorHandlerT]]: ...
 
-    def __call__(
+    def __call__[**P, R](
         self,
         *rules: ABCRule,
+        dataclass: type[typing.Any] | None = None,
         error_handler: ABCErrorHandler | None = None,
-        is_blocking: bool = True,
+        final: bool = True,
     ) -> typing.Callable[..., typing.Any]:
-        def wrapper(func):
+        def wrapper(func: typing.Callable[..., typing.Any]):
             func_handler = FuncHandler(
                 func,
                 [*self.auto_rules, *rules],
-                is_blocking=is_blocking,
-                dataclass=None,
+                final=final,
+                dataclass=dataclass,
                 error_handler=error_handler or ErrorHandler(),
             )
             self.handlers.append(func_handler)
@@ -153,8 +183,8 @@ class BaseView(ABCView, typing.Generic[Event]):
 
         return wrapper
 
-    def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
-        def wrapper(cls: type[MiddlewareT]) -> type[MiddlewareT]:
+    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
 
@@ -172,7 +202,7 @@ class BaseView(ABCView, typing.Generic[Event]):
             case _:
                 return False
 
-    async def process(self, event: Update, api: API) -> bool:
+    async def process(self, event: Update, api: API, context: Context) -> bool:
         return await process_inner(
             api,
             self.event_model_class.unwrap().from_update(
@@ -180,20 +210,21 @@ class BaseView(ABCView, typing.Generic[Event]):
                 bound_api=api,
             ),
             event,
+            context,
             self.middlewares,
             self.handlers,
             self.return_manager,
         )
 
-    def load(self, external: typing.Self) -> None:
-        self.auto_rules.extend(external.auto_rules)
+    def load(self, external: typing.Self, /) -> None:
         self.handlers.extend(external.handlers)
         self.middlewares.extend(external.middlewares)
 
 
-class BaseStateView(ABCStateView[Event], BaseView[Event], ABC, typing.Generic[Event]):
+class BaseStateView[Event: BaseCute](ABCStateView[Event], BaseView[Event], ABC):
+    @classmethod
     @abstractmethod
-    def get_state_key(self, event: Event) -> int | None:
+    def get_state_key(cls, event: Event) -> int | None:
         pass
 
 

telegrinder/bot/dispatch/view/box.py

@@ -8,16 +8,26 @@ from telegrinder.bot.dispatch.view import (
     chat_member,
     inline_query,
     message,
+    pre_checkout_query,
     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
+    "CallbackQueryView",
+    bound=ABCView,
+    default=callback_query.CallbackQueryView,
+)
+PreCheckoutQueryView = typing.TypeVar(
+    "PreCheckoutQueryView",
+    bound=ABCView,
+    default=pre_checkout_query.PreCheckoutQueryView,
 )
 ChatJoinRequestView = typing.TypeVar(
-    "ChatJoinRequestView", bound=ABCView, default=chat_join_request.ChatJoinRequestView
+    "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)
@@ -33,6 +43,7 @@ class ViewBox(
         ChatMemberView,
         InlineQueryView,
         MessageView,
+        PreCheckoutQueryView,
         RawEventView,
     ],
 ):
@@ -44,6 +55,7 @@ class ViewBox(
     message_view: dataclasses.InitVar[MessageView | None] = None
     business_message_view: dataclasses.InitVar[MessageView | None] = None
     channel_post_view: dataclasses.InitVar[MessageView | None] = None
+    pre_checkout_query_view: dataclasses.InitVar[PreCheckoutQueryView | 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
@@ -66,6 +78,7 @@ class ViewBox(
         edited_channel_post_view: MessageView | None = None,
         any_message_view: MessageView | None = None,
         chat_member_updated_view: ChatMemberView | None = None,
+        pre_checkout_query_view: PreCheckoutQueryView | None = None,
         raw_event_view: RawEventView | None = None,
     ) -> None:
         self.callback_query = typing.cast(
@@ -106,13 +119,16 @@ class ViewBox(
         )
         self.edited_business_message = typing.cast(
             MessageView,
-            edited_business_message_view
-            or message.MessageView(update_type=UpdateType.EDITED_BUSINESS_MESSAGE),
+            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.pre_checkout_query = typing.cast(
+            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,
@@ -120,10 +136,5 @@ class ViewBox(
         )
         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",)

telegrinder/bot/dispatch/view/callback_query.py

@@ -5,12 +5,11 @@ from telegrinder.bot.dispatch.view.base import BaseStateView
 
 class CallbackQueryView(BaseStateView[CallbackQueryCute]):
     def __init__(self) -> None:
-        self.auto_rules = []
-        self.handlers = []
-        self.middlewares = []
+        super().__init__()
         self.return_manager = CallbackQueryReturnManager()
 
-    def get_state_key(self, event: CallbackQueryCute) -> int | None:
+    @classmethod
+    def get_state_key(cls, event: CallbackQueryCute) -> int | None:
         return event.message_id.unwrap_or_none()
 
 

telegrinder/bot/dispatch/view/chat_join_request.py

@@ -3,13 +3,8 @@ from telegrinder.bot.dispatch.view.base 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:
+    @classmethod
+    def get_state_key(cls, event: ChatJoinRequestCute) -> int | None:
         return event.chat_id
 
 

telegrinder/bot/dispatch/view/chat_member.py

@@ -13,10 +13,7 @@ ChatMemberUpdateType: typing.TypeAlias = typing.Literal[
 
 class ChatMemberView(BaseStateView[ChatMemberUpdatedCute]):
     def __init__(self, *, update_type: ChatMemberUpdateType | None = None) -> None:
-        self.auto_rules = []
-        self.handlers = []
-        self.middlewares = []
-        self.return_manager = None
+        super().__init__()
         self.update_type = update_type
 
     def __repr__(self) -> str:
@@ -25,7 +22,8 @@ class ChatMemberView(BaseStateView[ChatMemberUpdatedCute]):
             "chat_member_updated" if self.update_type is None else self.update_type.value,
         )
 
-    def get_state_key(self, event: ChatMemberUpdatedCute) -> int | None:
+    @classmethod
+    def get_state_key(cls, event: ChatMemberUpdatedCute) -> int | None:
         return event.chat_id
 
     async def check(self, event: Update) -> bool:

telegrinder/bot/dispatch/view/inline_query.py

@@ -5,12 +5,11 @@ from telegrinder.bot.dispatch.view.base import BaseStateView
 
 class InlineQueryView(BaseStateView[InlineQueryCute]):
     def __init__(self) -> None:
-        self.auto_rules = []
-        self.handlers = []
-        self.middlewares = []
+        super().__init__()
         self.return_manager = InlineQueryReturnManager()
 
-    def get_state_key(self, event: InlineQueryCute) -> int | None:
+    @classmethod
+    def get_state_key(cls, event: InlineQueryCute) -> int | None:
         return event.from_user.id
 
 

telegrinder/bot/dispatch/view/message.py

@@ -18,10 +18,8 @@ MessageUpdateType: typing.TypeAlias = typing.Literal[
 
 class MessageView(BaseStateView[MessageCute]):
     def __init__(self, *, update_type: MessageUpdateType | None = None) -> None:
-        self.auto_rules = []
-        self.handlers = []
+        super().__init__()
         self.update_type = update_type
-        self.middlewares = []
         self.return_manager = MessageReturnManager()
 
     def __repr__(self) -> str:
@@ -30,7 +28,8 @@ class MessageView(BaseStateView[MessageCute]):
             "any message update" if self.update_type is None else self.update_type.value,
         )
 
-    def get_state_key(self, event: MessageCute) -> int | None:
+    @classmethod
+    def get_state_key(cls, event: MessageCute) -> int | None:
         return event.chat_id
 
     async def check(self, event: Update) -> bool:

telegrinder/bot/dispatch/view/pre_checkout_query.py

@@ -0,0 +1,16 @@
+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
+
+
+class PreCheckoutQueryView(BaseStateView[PreCheckoutQueryCute]):
+    def __init__(self) -> None:
+        super().__init__()
+        self.return_manager = PreCheckoutQueryManager()
+
+    @classmethod
+    def get_state_key(cls, event: PreCheckoutQueryCute) -> int | None:
+        return event.from_user.id
+
+
+__all__ = ("PreCheckoutQueryView",)