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

telegrinder/bot/dispatch/handler/func.py

@@ -4,15 +4,15 @@ from functools import cached_property
 import typing_extensions as typing
 
 from telegrinder.api.api import API
-from telegrinder.bot.cute_types import BaseCute, UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.process import check_rule
-from telegrinder.model import Model
 from telegrinder.modules import logger
-from telegrinder.node.base import Node, get_nodes
+from telegrinder.node.base import NodeType, get_nodes
 from telegrinder.node.composer import NodeCollection, compose_nodes
-from telegrinder.node.event import EVENT_NODE_KEY
+from telegrinder.tools.adapter.abc import ABCAdapter
+from telegrinder.tools.adapter.dataclass import DataclassAdapter
 from telegrinder.tools.error_handler import ABCErrorHandler, ErrorHandler
+from telegrinder.tools.magic import get_annotations, magic_bundle
 from telegrinder.types.enums import UpdateType
 from telegrinder.types.objects import Update
 
@@ -22,21 +22,20 @@ if typing.TYPE_CHECKING:
     from telegrinder.bot.rules.abc import ABCRule
     from telegrinder.node.composer import NodeCollection
 
-Rest = typing.ParamSpec("Rest")
-Result = typing.TypeVar("Result")
 Function = typing.TypeVar("Function", bound="Func[..., typing.Any]")
-Event = typing.TypeVar("Event", bound=Model)
+Event = typing.TypeVar("Event")
 ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
 
-Func: typing.TypeAlias = typing.Callable[Rest, typing.Coroutine[typing.Any, typing.Any, Result]]
+type Func[**Rest, Result] = typing.Callable[Rest, typing.Coroutine[typing.Any, typing.Any, Result]]
 
 
 @dataclasses.dataclass(repr=False, slots=True)
 class FuncHandler(ABCHandler[Event], typing.Generic[Event, Function, ErrorHandlerT]):
     function: Function
     rules: list["ABCRule"]
-    is_blocking: bool = dataclasses.field(default=True, kw_only=True)
-    dataclass: type[typing.Any] | None = dataclasses.field(default=dict, kw_only=True)
+    adapter: ABCAdapter[Update, Event] | None = dataclasses.field(default=None, kw_only=True)
+    final: bool = dataclasses.field(default=True, kw_only=True)
+    dataclass: type[typing.Any] | None = dataclasses.field(default=dict[str, typing.Any], kw_only=True)
     error_handler: ErrorHandlerT = dataclasses.field(
         default_factory=lambda: typing.cast(ErrorHandlerT, ErrorHandler()),
         kw_only=True,
@@ -47,6 +46,9 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, Function, ErrorHandle
     def __post_init__(self) -> None:
         self.dataclass = typing.get_origin(self.dataclass) or self.dataclass
 
+        if self.dataclass is not None and self.adapter is None:
+            self.adapter = DataclassAdapter(self.dataclass, self.update_type)
+
     @property
     def __call__(self) -> Function:
         return self.function
@@ -54,7 +56,7 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, Function, ErrorHandle
     def __repr__(self) -> str:
         return "<{}: {}={!r} with rules={!r}, dataclass={!r}, error_handler={!r}>".format(
             self.__class__.__name__,
-            "blocking function" if self.is_blocking else "function",
+            "final function" if self.final else "function",
             self.function.__qualname__,
             self.rules,
             self.dataclass,
@@ -62,9 +64,17 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, Function, ErrorHandle
         )
 
     @cached_property
-    def required_nodes(self) -> dict[str, type[Node]]:
+    def required_nodes(self) -> dict[str, type[NodeType]]:
         return get_nodes(self.function)
 
+    def get_name_event_param(self, event: Event) -> str | None:
+        event_class = self.dataclass or event.__class__
+        for k, v in get_annotations(self.function).items():
+            if isinstance(v := typing.get_origin(v) or v, type) and v is event_class:
+                self.func_event_param = k
+                return k
+        return None
+
     async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
         if self.update_type is not None and self.update_type != event.update_type:
             return False
@@ -72,7 +82,7 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, Function, ErrorHandle
         logger.debug("Checking handler {!r}...", self)
         ctx = Context(raw_update=event) if ctx is None else ctx
         temp_ctx = ctx.copy()
-        temp_ctx |= self.preset_context
+        temp_ctx |= self.preset_context.copy()
         update = event
 
         for rule in self.rules:
@@ -83,21 +93,15 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, Function, ErrorHandle
         nodes = self.required_nodes
         node_col = None
         if nodes:
-            result = await compose_nodes(nodes, ctx, data={Update: event, API: api})
+            result = await compose_nodes(nodes, ctx, data={Update: update, API: api})
             if not result:
-                logger.debug(f"Cannot compose nodes for handler. Error: {result.error!r}")
+                logger.debug(f"Cannot compose nodes for handler, error: {str(result.error)}")
                 return False
 
             node_col = result.value
             temp_ctx |= node_col.values
 
-            if EVENT_NODE_KEY in ctx:
-                for name, node in nodes.items():
-                    if node is ctx[EVENT_NODE_KEY] and name in temp_ctx:
-                        ctx[name] = temp_ctx.pop(name)
-
         logger.debug("All checks passed for handler.")
-
         temp_ctx["node_col"] = node_col
         ctx |= temp_ctx
         return True
@@ -109,27 +113,17 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, Function, ErrorHandle
         ctx: Context,
         node_col: "NodeCollection | None" = None,
     ) -> typing.Any:
-        logger.debug(f"Running func handler {self.function.__qualname__!r}")
-
-        if self.dataclass is not None and EVENT_NODE_KEY not in ctx:
-            if self.update_type is not None and isinstance(event, Update):
-                update = getattr(event, event.update_type.value).unwrap()
-                event = (
-                    self.dataclass.from_update(update, bound_api=api)
-                    if issubclass(self.dataclass, BaseCute)
-                    else self.dataclass(**update.to_dict())  # type: ignore
-                )
-
-            elif issubclass(self.dataclass, UpdateCute) and isinstance(event, Update):
-                event = self.dataclass.from_update(event, bound_api=api)
-
-            else:
-                event = self.dataclass(**event.to_dict())  # type: ignore
-
-        result = (await self.error_handler.run(self.function, event, api, ctx)).unwrap()
-        if node_col := ctx.node_col:
-            await node_col.close_all()
-        return result
+        logger.debug(f"Running handler {self!r}...")
+
+        try:
+            if event_param := self.get_name_event_param(event):
+                ctx = Context(**{event_param: event, **ctx})
+            return await self(**magic_bundle(self.function, ctx, start_idx=0))
+        except BaseException as exception:
+            return await self.error_handler.run(exception, event, api, ctx)
+        finally:
+            if node_col := ctx.node_col:
+                await node_col.close_all()
 
 
 __all__ = ("FuncHandler",)

telegrinder/bot/dispatch/handler/media_group_reply.py

@@ -1,20 +1,21 @@
 import typing
 
 from telegrinder.api.api import API
-from telegrinder.bot.cute_types.message import InputMediaType, MessageCute
+from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
 from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.objects import InputMedia
 
 
 class MediaGroupReplyHandler(BaseReplyHandler):
     def __init__(
         self,
-        media: InputMediaType | list[InputMediaType],
+        media: InputMedia | list[InputMedia],
         *rules: ABCRule,
         caption: str | list[str] | None = None,
         parse_mode: str | list[str] | None = None,
-        is_blocking: bool = True,
+        final: bool = True,
         as_reply: bool = False,
         preset_context: Context | None = None,
         **default_params: typing.Any,
@@ -24,7 +25,7 @@ class MediaGroupReplyHandler(BaseReplyHandler):
         self.caption = caption
         super().__init__(
             *rules,
-            is_blocking=is_blocking,
+            final=final,
             as_reply=as_reply,
             preset_context=preset_context,
             **default_params,

telegrinder/bot/dispatch/handler/message_reply.py

@@ -13,7 +13,7 @@ class MessageReplyHandler(BaseReplyHandler):
         text: str,
         *rules: ABCRule,
         parse_mode: str | None = None,
-        is_blocking: bool = True,
+        final: bool = True,
         as_reply: bool = False,
         preset_context: Context | None = None,
         **default_params: typing.Any,
@@ -22,7 +22,7 @@ class MessageReplyHandler(BaseReplyHandler):
         self.parse_mode = parse_mode
         super().__init__(
             *rules,
-            is_blocking=is_blocking,
+            final=final,
             as_reply=as_reply,
             preset_context=preset_context,
             **default_params,

telegrinder/bot/dispatch/handler/photo_reply.py

@@ -15,7 +15,7 @@ class PhotoReplyHandler(BaseReplyHandler):
         *rules: ABCRule,
         caption: str | None = None,
         parse_mode: str | None = None,
-        is_blocking: bool = True,
+        final: bool = True,
         as_reply: bool = False,
         preset_context: Context | None = None,
         **default_params: typing.Any,
@@ -25,7 +25,7 @@ class PhotoReplyHandler(BaseReplyHandler):
         self.caption = caption
         super().__init__(
             *rules,
-            is_blocking=is_blocking,
+            final=final,
             as_reply=as_reply,
             preset_context=preset_context,
             **default_params,

telegrinder/bot/dispatch/handler/sticker_reply.py

@@ -14,7 +14,7 @@ class StickerReplyHandler(BaseReplyHandler):
         sticker: InputFile | str,
         *rules: ABCRule,
         emoji: str | None = None,
-        is_blocking: bool = True,
+        final: bool = True,
         as_reply: bool = False,
         preset_context: Context | None = None,
         **default_params: typing.Any,
@@ -23,7 +23,7 @@ class StickerReplyHandler(BaseReplyHandler):
         self.emoji = emoji
         super().__init__(
             *rules,
-            is_blocking=is_blocking,
+            final=final,
             as_reply=as_reply,
             preset_context=preset_context,
             **default_params,

telegrinder/bot/dispatch/handler/video_reply.py

@@ -15,7 +15,7 @@ class VideoReplyHandler(BaseReplyHandler):
         *rules: ABCRule,
         caption: str | None = None,
         parse_mode: str | None = None,
-        is_blocking: bool = True,
+        final: bool = True,
         as_reply: bool = False,
         preset_context: Context | None = None,
         **default_params: typing.Any,
@@ -25,7 +25,7 @@ class VideoReplyHandler(BaseReplyHandler):
         self.caption = caption
         super().__init__(
             *rules,
-            is_blocking=is_blocking,
+            final=final,
             as_reply=as_reply,
             preset_context=preset_context,
             **default_params,

telegrinder/bot/dispatch/middleware/abc.py

@@ -1,22 +1,97 @@
-import typing
+from __future__ import annotations
+
 from abc import ABC
 
+import typing_extensions as typing
+from fntypes import Some
+
+from telegrinder.api import API
+from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.model import Model
+from telegrinder.modules import logger
+from telegrinder.tools.adapter.abc import ABCAdapter, run_adapter
+from telegrinder.tools.lifespan import Lifespan
 from telegrinder.types.objects import Update
 
-if typing.TYPE_CHECKING:
-    from telegrinder.bot.rules.adapter.abc import ABCAdapter
+ToEvent = typing.TypeVar("ToEvent", bound=Model, default=typing.Any)
+
+
+async def run_middleware[Event: Model, R: bool | None](
+    method: typing.Callable[typing.Concatenate[Event, Context, ...], typing.Awaitable[R]],
+    api: API[typing.Any],
+    event: Event,
+    ctx: Context,
+    raw_event: Update | None = None,
+    adapter: "ABCAdapter[Update, Event] | None" = None,
+    *args: typing.Any,
+    **kwargs: typing.Any,
+) -> R:
+    if adapter is not None:
+        if raw_event is None:
+            raise RuntimeError("raw_event must be specified to apply adapter")
+        match await run_adapter(adapter, api, raw_event, ctx):
+            case Some(val):
+                event = val
+            case _:
+                return False  # type: ignore
+
+    logger.debug("Running {}-middleware {!r}...", method.__name__, method.__qualname__.split(".")[0])
+    return await method(event, ctx, *args, **kwargs)  # type: ignore
+
 
-Event = typing.TypeVar("Event", bound=Model)
+class ABCMiddleware[Event: Model | BaseCute](ABC):
+    adapter: ABCAdapter[Update, Event] | None = None
 
+    def __repr__(self) -> str:
+        name = f"middleware {self.__class__.__name__!r}:"
+        has_pre = self.pre.__qualname__.split(".")[0] != "ABCMiddleware"
+        has_post = self.post.__qualname__.split(".")[0] != "ABCMiddleware"
 
-class ABCMiddleware(ABC, typing.Generic[Event]):
-    adapter: "ABCAdapter[Update, Event] | None" = None
+        if has_post:
+            name = "post-" + name
+        if has_pre:
+            name = "pre-" + name
+
+        return "<{} with adapter={!r}>".format(name, self.adapter)
 
     async def pre(self, event: Event, ctx: Context) -> bool: ...
 
-    async def post(self, event: Event, responses: list[typing.Any], ctx: Context) -> None: ...
+    async def post(self, event: Event, ctx: Context) -> None: ...
+
+    @typing.overload
+    def to_lifespan(self, event: Event, ctx: Context | None = None, *, api: API) -> Lifespan: ...
+
+    @typing.overload
+    def to_lifespan(self, event: Event, ctx: Context | None = None) -> Lifespan: ...
+
+    def to_lifespan(
+        self,
+        event: Event,
+        ctx: Context | None = None,
+        api: API | None = None,
+        **add_context: typing.Any,
+    ) -> Lifespan:
+        if api is None:
+            if not isinstance(event, BaseCute):
+                raise LookupError("Cannot get api, please pass as kwarg or provide BaseCute api-bound event")
+            api = event.api
+
+        ctx = ctx or Context()
+        ctx |= add_context
+        return Lifespan(
+            startup_tasks=[run_middleware(self.pre, api, event, raw_event=None, ctx=ctx, adapter=None)],
+            shutdown_tasks=[
+                run_middleware(
+                    self.post,
+                    api,
+                    event,
+                    raw_event=None,
+                    ctx=ctx,
+                    adapter=None,
+                )
+            ],
+        )
 
 
-__all__ = ("ABCMiddleware",)
+__all__ = ("ABCMiddleware", "run_middleware")

telegrinder/bot/dispatch/middleware/global_middleware.py

@@ -0,0 +1,70 @@
+import inspect
+import typing
+from contextlib import contextmanager
+
+from telegrinder.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.rules.abc import ABCRule, check_rule
+from telegrinder.node import IsNode, compose_nodes
+from telegrinder.tools.adapter.abc import ABCAdapter
+from telegrinder.tools.adapter.raw_update import RawUpdateAdapter
+from telegrinder.types import Update
+
+
+class GlobalMiddleware(ABCMiddleware):
+    adapter = RawUpdateAdapter()
+
+    def __init__(self):
+        self.filters: set[ABCRule] = set()
+        self.source_filters: dict[ABCAdapter | IsNode, dict[typing.Any, ABCRule]] = {}
+
+    async def pre(self, event: UpdateCute, ctx: Context) -> bool:
+        for filter in self.filters:
+            if not await check_rule(event.api, filter, event, ctx):
+                return False
+
+        # Simple implication.... Grouped by source categories
+        for source, identifiers in self.source_filters.items():
+            if isinstance(source, ABCAdapter):
+                result = source.adapt(event.api, event, ctx)
+                if inspect.isawaitable(result):
+                    result = await result
+
+                result = result.unwrap_or_none()
+                if result is None:
+                    return True
+
+            else:
+                result = await compose_nodes({"value": source}, ctx, {Update: event, API: event.api})
+                if result := result.unwrap():
+                    result = result.values["value"]
+                else:
+                    return True
+
+            if result in identifiers:
+                return await check_rule(event.api, identifiers[result], event, ctx)
+
+        return True
+
+    @contextmanager
+    def apply_filters(
+        self,
+        *filters: ABCRule,
+        source_filter: tuple[ABCAdapter | IsNode, typing.Any, ABCRule] | None = None,
+    ):
+        if source_filter is not None:
+            self.source_filters.setdefault(source_filter[0], {})
+            self.source_filters[source_filter[0]].update({source_filter[1]: source_filter[2]})
+
+        self.filters |= set(filters)
+        yield
+        self.filters.difference_update(filters)
+
+        if source_filter is not None:  # noqa: SIM102
+            if identifiers := self.source_filters.get(source_filter[0]):
+                identifiers.pop(source_filter[1], None)
+
+
+__all__ = ("GlobalMiddleware",)

telegrinder/bot/dispatch/process.py

@@ -1,68 +1,41 @@
-import inspect
 import typing
 
-from fntypes.option import Nothing, Option, Some
-from fntypes.result import Error, Ok
+from fntypes.option import Nothing, Some
 
 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.middleware.abc import ABCMiddleware, run_middleware
 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.adapter.abc import run_adapter
 from telegrinder.tools.i18n.abc import I18nEnum
 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
-    from telegrinder.bot.rules.adapter.abc import ABCAdapter
 
-T = typing.TypeVar("T")
-Event = typing.TypeVar("Event", bound=Model)
 
-
-async def run_adapter(
-    adapter: "ABCAdapter[Update, T]",
-    api: API,
-    update: Update,
-    context: Context,
-) -> Option[T]:
-    adapt_result = adapter.adapt(api, update, context)
-    match await adapt_result if inspect.isawaitable(adapt_result) else adapt_result:
-        case Ok(value):
-            return Some(value)
-        case Error(err):
-            logger.debug("Adapter failed with error message: {!r}", str(err))
-            return Nothing()
-
-
-async def process_inner(
+async def process_inner[Event: Model](
     api: API,
     event: Event,
     raw_event: Update,
+    ctx: Context,
     middlewares: list[ABCMiddleware[Event]],
     handlers: list["ABCHandler[Event]"],
     return_manager: ABCReturnManager[Event] | None = None,
 ) -> bool:
     logger.debug("Processing {!r}...", event.__class__.__name__)
-    ctx = Context(raw_update=raw_event)
     ctx[CONTEXT_STORE_NODES_KEY] = {}  # For per-event shared nodes
 
     logger.debug("Run pre middlewares...")
-    for middleware in middlewares:
-        if middleware.adapter is not None:
-            match await run_adapter(middleware.adapter, api, raw_event, ctx):
-                case Some(val):
-                    event = val
-                case Nothing():
-                    return False
-
-        middleware_result = await middleware.pre(event, ctx)
-        logger.debug("Middleware {!r} returned: {!r}", middleware.__class__.__qualname__, middleware_result)
-        if middleware_result is False:
+    for m in middlewares:
+        result = await run_middleware(m.pre, api, event, raw_event=raw_event, ctx=ctx, adapter=m.adapter)
+        logger.debug("Middleware {!r} returned: {!r}", m, result)
+        if result is False:
             return False
 
     found = False
@@ -70,23 +43,41 @@ async def process_inner(
     ctx_copy = ctx.copy()
 
     for handler in handlers:
+        adapted_event = event
+
         if await handler.check(api, raw_event, ctx):
-            logger.debug("Handler {!r} matched, run...", handler)
+            if handler.adapter is not None:
+                match await run_adapter(handler.adapter, api, raw_event, ctx):
+                    case Some(value):
+                        adapted_event = value
+                    case Nothing():
+                        continue
+
             found = True
-            response = await handler.run(api, event, ctx)
+            logger.debug("Handler {!r} matched, run...", handler)
+            response = await handler.run(api, adapted_event, ctx)
             logger.debug("Handler {!r} returned: {!r}", handler, response)
             responses.append(response)
+
             if return_manager is not None:
                 await return_manager.run(response, event, ctx)
-            if handler.is_blocking:
+            if handler.final:
                 break
 
         ctx = ctx_copy
 
     logger.debug("Run post middlewares...")
-    for middleware in middlewares:
-        logger.debug("Run post middleware {!r}", middleware.__class__.__qualname__)
-        await middleware.post(event, responses, ctx)
+    ctx.set("responses", responses)
+
+    for m in middlewares:
+        await run_middleware(
+            m.post,
+            api,
+            event,
+            raw_event=raw_event,
+            ctx=ctx,
+            adapter=m.adapter,
+        )
 
     for session in ctx.get(CONTEXT_STORE_NODES_KEY, {}).values():
         await session.close(scopes=(NodeScope.PER_EVENT,))
@@ -106,7 +97,9 @@ async def check_rule(
     ctx: Context,
 ) -> bool:
     """Checks requirements, adapts update.
-    Returns check result."""
+    Returns check result.
+    """
+    update_cute = None if not isinstance(update, UpdateCute) else update
 
     # Running adapter
     match await run_adapter(rule.adapter, api, update, ctx):
@@ -116,17 +109,17 @@ async def check_rule(
             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
+    if isinstance(adapted_value, UpdateCute):
+        update_cute = adapted_value
+    elif isinstance(adapted_val := ctx.get(rule.adapter.ADAPTED_VALUE_KEY or ""), UpdateCute):
+        update_cute = adapted_val
     else:
-        update = UpdateCute.from_update(update, bound_api=api)
+        update_cute = UpdateCute.from_update(update, bound_api=api)
 
     # Running subrules to fetch requirements
     ctx_copy = ctx.copy()
     for requirement in rule.requires:
-        if not await check_rule(api, requirement, update, ctx_copy):
+        if not await check_rule(api, requirement, update_cute, ctx_copy):
             return False
 
     # Translating translatable rules
@@ -141,11 +134,12 @@ async def check_rule(
     if nodes:
         result = await compose_nodes(nodes, ctx, data={Update: update, API: api})
         if not result:
+            logger.debug(f"Cannot compose nodes for rule, error: {str(result.error)}")
             return False
         node_col = result.value
 
     # Running check
-    result = await rule.bounding_check(adapted_value, ctx, node_col=node_col)
+    result = await rule.bounding_check(ctx, adapted_value=adapted_value, node_col=node_col)
 
     # Closing node sessions if there are any
     if node_col is not None:

telegrinder/bot/dispatch/return_manager/__init__.py

@@ -7,6 +7,7 @@ from telegrinder.bot.dispatch.return_manager.abc import (
 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
+from telegrinder.bot.dispatch.return_manager.pre_checkout_query import PreCheckoutQueryManager
 
 __all__ = (
     "ABCReturnManager",
@@ -15,5 +16,6 @@ __all__ = (
     "InlineQueryReturnManager",
     "Manager",
     "MessageReturnManager",
+    "PreCheckoutQueryManager",
     "register_manager",
 )