telegrinder 0.1.dev168__py3-none-any.whl → 0.1.dev170__py3-none-any.whl

telegrinder/bot/cute_types/update.py

@@ -15,16 +15,12 @@ class UpdateCute(BaseCute[Update], Update, kw_only=True):
     api: ABCAPI
 
     @property
-    def incoming_update(self) -> Option[Model]:
-        return getattr(
-            self,
-            self.update_type.expect("Update object has no incoming update.").value,
-        )
+    def incoming_update(self) -> Model:
+        return getattr(self, self.update_type.value).unwrap()
 
     def get_event(self, event_model: type[ModelT]) -> Option[ModelT]:
-        match self.incoming_update:
-            case Some(event) if isinstance(event, event_model):
-                return Some(event)
+        if isinstance(self.incoming_update, event_model):
+            return Some(self.incoming_update)
         return Nothing()
 
 

telegrinder/bot/cute_types/utils.py

@@ -78,11 +78,7 @@ def compose_reactions(
         (
             ReactionTypeEmoji("emoji", emoji)
             if isinstance(emoji, ReactionEmoji)
-            else (
-                ReactionTypeEmoji("emoji", ReactionEmoji(emoji))
-                if isinstance(emoji, str)
-                else emoji
-            )
+            else (ReactionTypeEmoji("emoji", ReactionEmoji(emoji)) if isinstance(emoji, str) else emoji)
         )
         for emoji in ([reactions] if isinstance(reactions, str) else reactions)
     ]

telegrinder/bot/dispatch/__init__.py

@@ -1,5 +1,4 @@
 from .abc import ABCDispatch
-from .composition import CompositionDispatch
 from .context import Context
 from .dispatch import ABCRule, Dispatch, TelegrinderCtx
 from .handler import ABCHandler, FuncHandler, MessageReplyHandler
@@ -27,7 +26,7 @@ from .view import (
     RawEventView,
     ViewBox,
 )
-from .waiter_machine import ShortState, WaiterMachine
+from .waiter_machine import ShortState, WaiterMachine, clear_wm_storage_worker
 
 __all__ = (
     "ABCDispatch",
@@ -44,7 +43,6 @@ __all__ = (
     "CallbackQueryView",
     "ChatJoinRequestView",
     "ChatMemberView",
-    "CompositionDispatch",
     "Context",
     "Dispatch",
     "FuncHandler",
@@ -62,4 +60,5 @@ __all__ = (
     "check_rule",
     "process_inner",
     "register_manager",
+    "clear_wm_storage_worker",
 )

telegrinder/bot/dispatch/abc.py

@@ -17,5 +17,9 @@ class ABCDispatch(ABC):
     def load(self, external: typing.Self) -> None:
         pass
 
+    def load_many(self, *externals: typing.Self) -> None:
+        for external in externals:
+            self.load(external)
+
 
 __all__ = ("ABCDispatch",)

telegrinder/bot/dispatch/context.py

@@ -15,7 +15,7 @@ class Context(dict[str, AnyValue]):
     """Context class for rules and middlewares.
     ```
     class MyRule(ABCRule[T]):
-        adapter: ABCAdapter[Update, T] = RawUpdateAdapter()
+        adapter = RawUpdateAdapter()
 
         async def check(self, event: T, ctx: Context) -> bool:
             ctx.set("value", (await event.ctx_api.get_me()).unwrap())
@@ -28,17 +28,17 @@ class Context(dict[str, AnyValue]):
     def __init__(self, **kwargs: AnyValue) -> None:
         cls_vars = vars(self.__class__)
         defaults = {}
+
         for k in self.__class__.__annotations__:
             if k in cls_vars:
                 defaults[k] = cls_vars[k]
                 delattr(self.__class__, k)
+
         dict.__init__(self, **defaults | kwargs)
 
     @recursive_repr()
     def __repr__(self) -> str:
-        return "{}({})".format(
-            self.__class__.__name__, ", ".join(f"{k}={v!r}" for k, v in self.items())
-        )
+        return "{}({})".format(self.__class__.__name__, ", ".join(f"{k}={v!r}" for k, v in self.items()))
 
     def __setitem__(self, __key: Key, __value: AnyValue) -> None:
         dict.__setitem__(self, self.key_to_str(__key), __value)
@@ -71,6 +71,11 @@ class Context(dict[str, AnyValue]):
     def get(self, key: Key, default: T | None = None) -> T | AnyValue:
         return dict.get(self, key, default)
 
+    def get_or_set(self, key: Key, default: T) -> T:
+        if key not in self:
+            self.set(key, default)
+        return self.get(key)
+
     def delete(self, key: Key) -> None:
         del self[key]
 

telegrinder/bot/dispatch/dispatch.py

@@ -6,6 +6,7 @@ from vbml.patcher import Patcher
 
 from telegrinder.api.abc import ABCAPI
 from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules import ABCRule
 from telegrinder.modules import logger
@@ -17,21 +18,19 @@ from .abc import ABCDispatch
 from .handler import ABCHandler, FuncHandler
 from .handler.func import ErrorHandlerT
 from .view.box import (
-    CallbackQueryViewT,
-    ChatJoinRequestViewT,
-    ChatMemberViewT,
-    InlineQueryViewT,
-    MessageViewT,
-    RawEventViewT,
+    CallbackQueryView,
+    ChatJoinRequestView,
+    ChatMemberView,
+    InlineQueryView,
+    MessageView,
+    RawEventView,
     ViewBox,
 )
 
 T = typing.TypeVar("T")
 R = typing.TypeVar("R")
 P = typing.ParamSpec("P")
-Handler = typing.Callable[
-    typing.Concatenate[T, ...], typing.Coroutine[typing.Any, typing.Any, typing.Any]
-]
+Handler = typing.Callable[typing.Concatenate[T, ...], typing.Coroutine[typing.Any, typing.Any, typing.Any]]
 Event = typing.TypeVar("Event", bound=BaseCute)
 
 DEFAULT_DATACLASS: typing.Final[type[Update]] = Update
@@ -41,12 +40,12 @@ DEFAULT_DATACLASS: typing.Final[type[Update]] = Update
 class Dispatch(
     ABCDispatch,
     ViewBox[
-        CallbackQueryViewT,
-        ChatJoinRequestViewT,
-        ChatMemberViewT,
-        InlineQueryViewT,
-        MessageViewT,
-        RawEventViewT,
+        CallbackQueryView,
+        ChatJoinRequestView,
+        ChatMemberView,
+        InlineQueryView,
+        MessageView,
+        RawEventView,
     ],
 ):
     global_context: TelegrinderCtx = dataclasses.field(
@@ -63,55 +62,56 @@ class Dispatch(
 
     @property
     def patcher(self) -> Patcher:
-        """Alias `patcher` to get `vbml.Patcher` from the global context"""
+        """Alias `patcher` to get `vbml.Patcher` from the global context."""
+
         return self.global_context.vbml_patcher
 
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule[Event],
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]: ...
+        *rules: ABCRule,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule[Event],
+        *rules: ABCRule,
         is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]: ...
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule[Event],
+        *rules: ABCRule,
         dataclass: type[T],
         is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]: ...
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(  # type: ignore
         self,
-        *rules: ABCRule[Event],
+        *rules: ABCRule,
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandlerT]]: ...
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
 
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule[Event],
+        *rules: ABCRule,
         dataclass: type[T],
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandlerT]]: ...
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
 
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule[Event],
+        *rules: ABCRule,
         dataclass: type[T] = DEFAULT_DATACLASS,
         error_handler: typing.Literal[None] = None,
         is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]: ...
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
     def handle(  # type: ignore
         self,
@@ -135,20 +135,20 @@ class Dispatch(
 
     async def feed(self, event: Update, api: ABCAPI) -> bool:
         logger.debug("Processing update (update_id={})", event.update_id)
-        loop = asyncio.get_running_loop()
-        loop.create_task(self.raw_event.process(event, api))
-        
+        await self.raw_event.process(event, api)
+
         for view in self.get_views().values():
             if await view.check(event):
                 logger.debug(
-                    "Update (update_id={}) matched view {!r}",
+                    "Update (update_id={}) matched view {!r}.",
                     event.update_id,
                     view.__class__.__name__,
                 )
-                loop.create_task(view.process(event, api))
+                await view.process(event, api)
                 return True
 
         ctx = Context()
+        loop = asyncio.get_running_loop()
         found = False
         for handler in self.default_handlers:
             if await handler.check(api, event, ctx):
@@ -165,5 +165,7 @@ class Dispatch(
             view.load(view_external[name])
             setattr(external, name, view)
 
+    __call__ = handle
+
 
 __all__ = ("Dispatch",)

telegrinder/bot/dispatch/handler/func.py

@@ -3,11 +3,13 @@ import dataclasses
 import typing_extensions as typing
 
 from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.cute_types import BaseCute
+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.modules import logger
+from telegrinder.node import Node, compose_nodes, is_node
 from telegrinder.tools.error_handler import ABCErrorHandler, ErrorHandler
+from telegrinder.tools.magic import get_annotations
 from telegrinder.types import Update
 from telegrinder.types.enums import UpdateType
 
@@ -20,22 +22,22 @@ F = typing.TypeVar(
     "F",
     bound=typing.Callable[typing.Concatenate[typing.Any, ...], typing.Awaitable[typing.Any]],
 )
-EventT = typing.TypeVar("EventT", bound=BaseCute)
+Event = typing.TypeVar("Event", bound=BaseCute)
 ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
 
 
 @dataclasses.dataclass(repr=False)
-class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
+class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
     func: F
-    rules: list["ABCRule[EventT]"]
-    _: dataclasses.KW_ONLY
-    is_blocking: bool = dataclasses.field(default=True)
-    dataclass: type[typing.Any] | None = dataclasses.field(default=dict)
+    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)
     error_handler: ErrorHandlerT = dataclasses.field(
         default_factory=lambda: typing.cast(ErrorHandlerT, ErrorHandler()),
+        kw_only=True,
     )
-    preset_context: Context = dataclasses.field(default_factory=lambda: Context())
-    update_type: UpdateType | None = dataclasses.field(default=None)
+    preset_context: Context = dataclasses.field(default_factory=lambda: Context(), kw_only=True)
+    update_type: UpdateType | None = dataclasses.field(default=None, kw_only=True)
 
     def __repr__(self) -> str:
         return "<{}: {}={!r} with rules={!r}, dataclass={!r}, error_handler={!r}>".format(
@@ -46,24 +48,39 @@ class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
             self.dataclass,
             self.error_handler,
         )
-    
+
+    def get_required_nodes(self) -> dict[str, type[Node]]:
+        return {k: v for k, v in get_annotations(self.func).items() if is_node(v)}
+
     async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
-        if self.update_type is not None and self.update_type != event.update_type.unwrap_or_none():
+        if self.update_type is not None and self.update_type != event.update_type:
             return False
+
         ctx = ctx or Context()
         temp_ctx = ctx.copy()
         temp_ctx |= self.preset_context
 
+        nodes = self.get_required_nodes()
+        node_col = None
+
+        if nodes:
+            node_col = await compose_nodes(nodes, UpdateCute.from_update(event, api), ctx)
+            if node_col is None:
+                return False
+            temp_ctx |= node_col.values()
+
         for rule in self.rules:
             if not await check_rule(api, rule, event, temp_ctx):
                 logger.debug("Rule {!r} failed!", rule)
                 return False
 
+        temp_ctx["node_col"] = node_col
         ctx |= temp_ctx
         return True
 
-    async def run(self, event: EventT, ctx: Context) -> typing.Any:
+    async def run(self, event: Event, ctx: Context) -> typing.Any:
         api = event.api
+
         if self.dataclass is not None:
             if self.update_type is not None:
                 update = event.to_dict()[self.update_type.value].unwrap()
@@ -74,7 +91,11 @@ class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
                 )
             else:
                 event = self.dataclass(**event.to_dict())
-        return (await self.error_handler.run(self.func, event, api, ctx)).unwrap()
+
+        result = (await self.error_handler.run(self.func, event, api, ctx)).unwrap()
+        if node_col := ctx.node_col:
+            await node_col.close_all()
+        return result
 
 
 __all__ = ("FuncHandler",)

telegrinder/bot/dispatch/handler/message_reply.py

@@ -6,7 +6,6 @@ from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.process import check_rule
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.modules import logger
-from telegrinder.msgspec_utils import Nothing
 from telegrinder.types.objects import ReplyParameters, Update
 
 from .abc import ABCHandler
@@ -16,15 +15,18 @@ class MessageReplyHandler(ABCHandler[MessageCute]):
     def __init__(
         self,
         text: str,
-        *rules: ABCRule[MessageCute],
+        *rules: ABCRule,
         is_blocking: bool = True,
         as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
     ) -> None:
         self.text = text
         self.rules = list(rules)
         self.as_reply = as_reply
         self.is_blocking = is_blocking
-        self.preset_context = Context()
+        self.default_params = default_params
+        self.preset_context = preset_context or Context()
 
     def __repr__(self) -> str:
         return "<{}: with rules={!r}, {}: {!r}>".format(
@@ -51,6 +53,7 @@ class MessageReplyHandler(ABCHandler[MessageCute]):
         await event.answer(
             text=self.text,
             reply_parameters=ReplyParameters(event.message_id) if self.as_reply else None,
+            **self.default_params,
         )
 
 

telegrinder/bot/dispatch/middleware/abc.py

@@ -4,13 +4,13 @@ from abc import ABC
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.context import Context
 
-T = typing.TypeVar("T", bound=BaseCute)
+Event = typing.TypeVar("Event", bound=BaseCute)
 
 
-class ABCMiddleware(ABC, typing.Generic[T]):
-    async def pre(self, event: T, ctx: Context) -> bool: ...
+class ABCMiddleware(ABC, typing.Generic[Event]):
+    async def pre(self, event: Event, ctx: Context) -> bool: ...
 
-    async def post(self, event: T, responses: list[typing.Any], ctx: Context) -> None: ...
+    async def post(self, event: Event, responses: list[typing.Any], ctx: Context) -> None: ...
 
 
 __all__ = ("ABCMiddleware",)

telegrinder/bot/dispatch/process.py

@@ -1,11 +1,13 @@
 import typing
 
-from fntypes.result import Error
+from fntypes.result import Error, Ok
 
 from telegrinder.api.abc import ABCAPI
 from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
+from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, NodeScope, compose_nodes
 from telegrinder.tools.i18n.base import I18nEnum
 from telegrinder.types import Update
 
@@ -16,19 +18,20 @@ if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch.handler.abc import ABCHandler
     from telegrinder.bot.rules.abc import ABCRule
 
-T = typing.TypeVar("T", bound=BaseCute)
+Event = typing.TypeVar("Event", bound=BaseCute)
 _: typing.TypeAlias = typing.Any
 
 
 async def process_inner(
-    event: T,
+    event: Event,
     raw_event: Update,
-    middlewares: list[ABCMiddleware[T]],
-    handlers: list["ABCHandler[T]"],
-    return_manager: ABCReturnManager[T] | None = None,
+    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
 
     for middleware in middlewares:
         if await middleware.pre(event, ctx) is False:
@@ -42,45 +45,69 @@ async def process_inner(
         if await handler.check(event.api, raw_event, ctx):
             found = True
             response = await handler.run(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:
                 break
-            ctx = ctx_copy
+
+        ctx = ctx_copy
 
     for middleware in middlewares:
         await middleware.post(event, responses, ctx)
 
+    for session in ctx.get(CONTEXT_STORE_NODES_KEY, {}).values():
+        await session.close(scopes=(NodeScope.PER_EVENT,))
+
     return found
 
 
 async def check_rule(
     api: ABCAPI,
-    rule: "ABCRule[T]",
+    rule: "ABCRule",
     update: Update,
     ctx: Context,
 ) -> bool:
     """Checks requirements, adapts update.
     Returns check result."""
 
-    cute_model = await rule.adapter.adapt(api, update)
-    match cute_model:
+    # Running adapter
+    match await rule.adapter.adapt(api, update):
+        case Ok(value):
+            adapted_value = value
         case Error(err):
             logger.debug("Adapter failed with error message: {!r}", str(err))
             return False
 
+    # Running subrules to fetch requirements
     ctx_copy = ctx.copy()
     for requirement in rule.requires:
         if not await check_rule(api, requirement, update, ctx_copy):
             return False
 
-    ctx |= ctx_copy
-
+    # Translating translatable rules
     if I18nEnum.I18N in ctx:
         rule = await rule.translate(ctx.get(I18nEnum.I18N))
 
-    return await rule.check(cute_model.unwrap(), ctx)
+    ctx |= ctx_copy
+
+    # Composing required nodes
+    nodes = rule.get_required_nodes()
+    node_col = None
+    if nodes:
+        node_col = await compose_nodes(nodes, UpdateCute.from_update(update, api), ctx)
+        if node_col is None:
+            return False
+
+    # Running check
+    result = await rule.bounding_check(adapted_value, ctx, node_col)
+
+    # Closing node sessions if there are any
+    if node_col is not None:
+        await node_col.close_all()
+
+    return result
 
 
 __all__ = ("check_rule", "process_inner")

telegrinder/bot/dispatch/return_manager/abc.py

@@ -8,7 +8,7 @@ from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
 
 T = typing.TypeVar("T")
-EventT = typing.TypeVar("EventT", bound=BaseCute, contravariant=True)
+Event = typing.TypeVar("Event", bound=BaseCute, contravariant=True)
 
 
 def get_union_types(t: types.UnionType) -> tuple[type, ...] | None:
@@ -36,13 +36,13 @@ class Manager:
             logger.exception(ex)
 
 
-class ABCReturnManager(ABC, typing.Generic[EventT]):
+class ABCReturnManager(ABC, typing.Generic[Event]):
     @abstractmethod
-    async def run(self, response: typing.Any, event: EventT, ctx: Context) -> None:
+    async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
         pass
 
 
-class BaseReturnManager(ABCReturnManager[EventT]):
+class BaseReturnManager(ABCReturnManager[Event]):
     def __repr__(self) -> str:
         return "<{}: {}>".format(
             self.__class__.__name__,
@@ -59,29 +59,29 @@ class BaseReturnManager(ABCReturnManager[EventT]):
 
     @register_manager(Context)
     @staticmethod
-    async def ctx_manager(value: Context, event: EventT, ctx: Context) -> None:
+    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: EventT, ctx: Context) -> None:
+    async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
+        logger.debug("Run return manager for response: {!r}", response)
         for manager in self.managers:
             if typing.Any in manager.types or any(type(response) is x for x in manager.types):
+                logger.debug("Run manager {!r}...", manager.callback.__name__)
                 await manager(response, event, ctx)
 
     @typing.overload
     def register_manager(
         self, return_type: type[T]
-    ) -> typing.Callable[
-        [typing.Callable[[T, EventT, Context], typing.Awaitable[typing.Any]]], Manager
-    ]: ...
+    ) -> typing.Callable[[typing.Callable[[T, Event, Context], typing.Awaitable[typing.Any]]], Manager]: ...
 
     @typing.overload
     def register_manager(
         self,
         return_type: tuple[type[T], ...],
     ) -> typing.Callable[
-        [typing.Callable[[tuple[T, ...], EventT, Context], typing.Awaitable[typing.Any]]],
+        [typing.Callable[[tuple[T, ...], Event, Context], typing.Awaitable[typing.Any]]],
         Manager,
     ]: ...
 
@@ -89,10 +89,10 @@ class BaseReturnManager(ABCReturnManager[EventT]):
         self,
         return_type: type[T] | tuple[type[T], ...],
     ) -> typing.Callable[
-        [typing.Callable[[T | tuple[T, ...], EventT, Context], typing.Awaitable[typing.Any]]],
+        [typing.Callable[[T | tuple[T, ...], Event, Context], typing.Awaitable[typing.Any]]],
         Manager,
     ]:
-        def wrapper(func: typing.Callable[[T, EventT, Context], typing.Awaitable]) -> Manager:
+        def wrapper(func: typing.Callable[[T, Event, Context], typing.Awaitable]) -> Manager:
             manager = Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
             setattr(self.__class__, func.__name__, manager)
             return manager

telegrinder/bot/dispatch/return_manager/callback_query.py

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

telegrinder/bot/dispatch/return_manager/inline_query.py

@@ -9,9 +9,7 @@ from .abc import BaseReturnManager, register_manager
 class InlineQueryReturnManager(BaseReturnManager[InlineQueryCute]):
     @register_manager(dict)
     @staticmethod
-    async def dict_manager(
-        value: dict[str, typing.Any], event: InlineQueryCute, ctx: Context
-    ) -> None:
+    async def dict_manager(value: dict[str, typing.Any], event: InlineQueryCute, ctx: Context) -> None:
         await event.answer(**value)