telegrinder 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

telegrinder/bot/dispatch/__init__.py

@@ -1,7 +1,17 @@
 from telegrinder.bot.dispatch.abc import ABCDispatch
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.dispatch import Dispatch, TelegrinderContext
-from telegrinder.bot.dispatch.handler import ABCHandler, FuncHandler, MessageReplyHandler
+from telegrinder.bot.dispatch.handler import (
+    ABCHandler,
+    AudioReplyHandler,
+    DocumentReplyHandler,
+    FuncHandler,
+    MediaGroupReplyHandler,
+    MessageReplyHandler,
+    PhotoReplyHandler,
+    StickerReplyHandler,
+    VideoReplyHandler,
+)
 from telegrinder.bot.dispatch.middleware import ABCMiddleware
 from telegrinder.bot.dispatch.process import check_rule, process_inner
 from telegrinder.bot.dispatch.return_manager import (
@@ -26,7 +36,19 @@ from telegrinder.bot.dispatch.view import (
     RawEventView,
     ViewBox,
 )
-from telegrinder.bot.dispatch.waiter_machine import ShortState, WaiterMachine, clear_wm_storage_worker
+from telegrinder.bot.dispatch.waiter_machine import (
+    CALLBACK_QUERY_FOR_MESSAGE,
+    CALLBACK_QUERY_FROM_CHAT,
+    CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE,
+    MESSAGE_FROM_USER,
+    MESSAGE_FROM_USER_IN_CHAT,
+    MESSAGE_IN_CHAT,
+    Hasher,
+    ShortState,
+    StateViewHasher,
+    WaiterMachine,
+    clear_wm_storage_worker,
+)
 
 __all__ = (
     "ABCDispatch",
@@ -35,29 +57,44 @@ __all__ = (
     "ABCReturnManager",
     "ABCStateView",
     "ABCView",
+    "AudioReplyHandler",
     "BaseReturnManager",
     "BaseStateView",
     "BaseView",
+    "CALLBACK_QUERY_FOR_MESSAGE",
+    "CALLBACK_QUERY_FROM_CHAT",
+    "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
     "CallbackQueryReturnManager",
     "CallbackQueryView",
     "ChatJoinRequestView",
     "ChatMemberView",
     "Context",
     "Dispatch",
+    "DocumentReplyHandler",
     "FuncHandler",
+    "Hasher",
     "InlineQueryReturnManager",
     "InlineQueryView",
+    "MESSAGE_FROM_USER",
+    "MESSAGE_FROM_USER_IN_CHAT",
+    "MESSAGE_IN_CHAT",
     "Manager",
+    "MediaGroupReplyHandler",
     "MessageReplyHandler",
     "MessageReturnManager",
     "MessageView",
+    "PhotoReplyHandler",
     "RawEventView",
     "ShortState",
+    "StateViewHasher",
+    "StickerReplyHandler",
     "TelegrinderContext",
+    "VideoReplyHandler",
     "ViewBox",
     "WaiterMachine",
     "check_rule",
+    "clear_wm_storage_worker",
+    "clear_wm_storage_worker",
     "process_inner",
     "register_manager",
-    "clear_wm_storage_worker",
 )

telegrinder/bot/dispatch/abc.py

@@ -1,10 +1,14 @@
 import typing
 from abc import ABC, abstractmethod
 
-from telegrinder.api import API
+from fntypes import Option
+
+from telegrinder.api.api import API
 from telegrinder.tools.global_context.abc import ABCGlobalContext
 from telegrinder.types.objects import Update
 
+T = typing.TypeVar("T")
+
 
 class ABCDispatch(ABC):
     @property
@@ -24,5 +28,8 @@ class ABCDispatch(ABC):
         for external in externals:
             self.load(external)
 
+    @abstractmethod
+    def get_view(self, of_type: type[T]) -> Option[T]: ...
+
 
 __all__ = ("ABCDispatch",)

telegrinder/bot/dispatch/context.py

@@ -2,7 +2,7 @@ import enum
 import typing
 from reprlib import recursive_repr
 
-from telegrinder.types import Update
+from telegrinder.types.objects import Update
 
 T = typing.TypeVar("T")
 
@@ -63,7 +63,7 @@ class Context(dict[str, AnyValue]):
         return key if isinstance(key, str) else str(key.value)
 
     def copy(self) -> typing.Self:
-        return self.__class__(**self)
+        return self.__class__(**dict.copy(self))
 
     def set(self, key: Key, value: AnyValue) -> None:
         self[key] = value

telegrinder/bot/dispatch/dispatch.py

@@ -1,9 +1,10 @@
 import dataclasses
 import typing
 
+from fntypes import Nothing, Option, Some
 from vbml.patcher import Patcher
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.abc import ABCDispatch
@@ -188,6 +189,12 @@ class Dispatch(
             view.load(view_external[name])
             setattr(external, name, view)
 
+    def get_view(self, of_type: type[T]) -> Option[T]:
+        for view in self.get_views().values():
+            if isinstance(view, of_type):
+                return Some(view)
+        return Nothing()
+
     __call__ = handle
 
 

telegrinder/bot/dispatch/handler/__init__.py

@@ -1,5 +1,21 @@
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.handler.audio_reply import AudioReplyHandler
+from telegrinder.bot.dispatch.handler.document_reply import DocumentReplyHandler
 from telegrinder.bot.dispatch.handler.func import FuncHandler
+from telegrinder.bot.dispatch.handler.media_group_reply import MediaGroupReplyHandler
 from telegrinder.bot.dispatch.handler.message_reply import MessageReplyHandler
+from telegrinder.bot.dispatch.handler.photo_reply import PhotoReplyHandler
+from telegrinder.bot.dispatch.handler.sticker_reply import StickerReplyHandler
+from telegrinder.bot.dispatch.handler.video_reply import VideoReplyHandler
 
-__all__ = ("ABCHandler", "FuncHandler", "MessageReplyHandler")
+__all__ = (
+    "ABCHandler",
+    "AudioReplyHandler",
+    "DocumentReplyHandler",
+    "FuncHandler",
+    "MediaGroupReplyHandler",
+    "MessageReplyHandler",
+    "PhotoReplyHandler",
+    "StickerReplyHandler",
+    "VideoReplyHandler",
+)

telegrinder/bot/dispatch/handler/audio_reply.py

@@ -0,0 +1,44 @@
+import typing
+
+from telegrinder.api.api import API
+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 InputFile
+
+
+class AudioReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        audio: InputFile | str,
+        *rules: ABCRule,
+        caption: str | None = None,
+        parse_mode: str | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.audio = audio
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_audio if not self.as_reply else event.reply_audio
+        await method(
+            audio=self.audio,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("AudioReplyHandler",)

telegrinder/bot/dispatch/handler/base.py

@@ -0,0 +1,57 @@
+import abc
+import typing
+
+from fntypes.result import Result
+
+from telegrinder.api.api import API
+from telegrinder.api.error import APIError
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.modules import logger
+from telegrinder.types.objects import Update
+
+APIMethod: typing.TypeAlias = typing.Callable[
+    typing.Concatenate[MessageCute, ...], typing.Awaitable[Result[typing.Any, APIError]]
+]
+
+
+class BaseReplyHandler(ABCHandler[MessageCute], abc.ABC):
+    def __init__(
+        self,
+        *rules: ABCRule,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.rules = list(rules)
+        self.as_reply = as_reply
+        self.is_blocking = is_blocking
+        self.default_params = default_params
+        self.preset_context = preset_context or Context()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__qualname__}>"
+
+    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
+        ctx = Context(raw_update=event) if ctx is None else ctx
+        temp_ctx = ctx.copy()
+        temp_ctx |= self.preset_context
+
+        for rule in self.rules:
+            if not await check_rule(api, rule, event, ctx):
+                logger.debug("Rule {!r} failed!", rule)
+                return False
+
+        ctx |= temp_ctx
+        return True
+
+    @abc.abstractmethod
+    async def run(self, api: API, event: MessageCute, ctx: Context) -> typing.Any:
+        pass
+
+
+__all__ = ("BaseReplyHandler",)

telegrinder/bot/dispatch/handler/document_reply.py

@@ -0,0 +1,44 @@
+import typing
+
+from telegrinder.api.api import API
+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 InputFile
+
+
+class DocumentReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        document: InputFile | str,
+        *rules: ABCRule,
+        caption: str | None = None,
+        parse_mode: str | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.document = document
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_document if not self.as_reply else event.reply_document
+        await method(
+            document=self.document,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("DocumentReplyHandler",)

telegrinder/bot/dispatch/handler/func.py

@@ -3,7 +3,7 @@ from functools import cached_property
 
 import typing_extensions as typing
 
-from telegrinder.api import API
+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
@@ -72,7 +72,7 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
         if nodes:
             result = await compose_nodes(nodes, ctx, data={Update: event, API: api})
             if not result:
-                logger.debug(f"Cannot compose nodes for handler. {result.error}")
+                logger.debug(f"Cannot compose nodes for handler. Error: {result.error!r}")
                 return False
 
             node_col = result.value
@@ -95,7 +95,7 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
         return True
 
     async def run(self, api: API, event: Event, ctx: Context) -> typing.Any:
-        logger.debug(f"Running func handler {self.func}")
+        logger.debug(f"Running func handler {self.func.__qualname__!r}")
         dataclass_type = typing.get_origin(self.dataclass) or self.dataclass
 
         if dataclass_type is Update and (event_node := ctx.pop(EVENT_NODE_KEY, None)) is not None:

telegrinder/bot/dispatch/handler/media_group_reply.py

@@ -0,0 +1,43 @@
+import typing
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.message import InputMediaType, MessageCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
+from telegrinder.bot.rules.abc import ABCRule
+
+
+class MediaGroupReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        media: InputMediaType | list[InputMediaType],
+        *rules: ABCRule,
+        caption: str | list[str] | None = None,
+        parse_mode: str | list[str] | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.media = media
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_media_group if not self.as_reply else event.reply_media_group
+        await method(
+            media=self.media,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("MediaGroupReplyHandler",)

telegrinder/bot/dispatch/handler/message_reply.py

@@ -3,57 +3,34 @@ import typing
 from telegrinder.api.api import API
 from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.handler.abc import ABCHandler
-from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
 from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.modules import logger
-from telegrinder.types.objects import ReplyParameters, Update
 
 
-class MessageReplyHandler(ABCHandler[MessageCute]):
+class MessageReplyHandler(BaseReplyHandler):
     def __init__(
         self,
         text: str,
         *rules: ABCRule,
+        parse_mode: str | None = None,
         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.default_params = default_params
-        self.preset_context = preset_context or Context()
-
-    def __repr__(self) -> str:
-        return "<{}: with rules={!r}, {}: {!r}>".format(
-            ("blocking " if self.is_blocking else "") + self.__class__.__name__,
-            self.rules,
-            "answer text as reply" if self.as_reply else "answer text",
-            self.text,
+        self.parse_mode = parse_mode
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
         )
 
-    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
-        ctx = Context(raw_update=event) if ctx is None else ctx
-        temp_ctx = ctx.copy()
-        temp_ctx |= self.preset_context
-
-        for rule in self.rules:
-            if not await check_rule(api, rule, event, ctx):
-                logger.debug("Rule {!r} failed!", rule)
-                return False
-
-        ctx |= temp_ctx
-        return True
-
     async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
-        await event.answer(
-            text=self.text,
-            reply_parameters=ReplyParameters(event.message_id) if self.as_reply else None,
-            **self.default_params,
-        )
+        method = event.answer if not self.as_reply else event.reply
+        await method(text=self.text, parse_mode=self.parse_mode, **self.default_params)
 
 
 __all__ = ("MessageReplyHandler",)

telegrinder/bot/dispatch/handler/photo_reply.py

@@ -0,0 +1,44 @@
+import typing
+
+from telegrinder.api.api import API
+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 InputFile
+
+
+class PhotoReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        photo: InputFile | str,
+        *rules: ABCRule,
+        caption: str | None = None,
+        parse_mode: str | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.photo = photo
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_photo if not self.as_reply else event.reply_photo
+        await method(
+            photo=self.photo,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("PhotoReplyHandler",)

telegrinder/bot/dispatch/handler/sticker_reply.py

@@ -0,0 +1,37 @@
+import typing
+
+from telegrinder.api.api import API
+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 InputFile
+
+
+class StickerReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        sticker: InputFile | str,
+        *rules: ABCRule,
+        emoji: str | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.sticker = sticker
+        self.emoji = emoji
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_sticker if not self.as_reply else event.reply_sticker
+        await method(sticker=self.sticker, emoji=self.emoji, **self.default_params)
+
+
+__all__ = ("StickerReplyHandler",)

telegrinder/bot/dispatch/handler/video_reply.py

@@ -0,0 +1,44 @@
+import typing
+
+from telegrinder.api.api import API
+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 InputFile
+
+
+class VideoReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        video: InputFile | str,
+        *rules: ABCRule,
+        caption: str | None = None,
+        parse_mode: str | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.video = video
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_video if not self.as_reply else event.reply_video
+        await method(
+            video=self.video,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("VideoReplyHandler",)

telegrinder/bot/dispatch/process.py

@@ -35,7 +35,7 @@ async def process_inner(
     logger.debug("Run pre middlewares...")
     for middleware in middlewares:
         middleware_result = await middleware.pre(event, ctx)
-        logger.debug("Middleware {!r} returned {!r}", middleware.__class__.__name__, middleware_result)
+        logger.debug("Middleware {!r} returned: {!r}", middleware.__class__.__qualname__, middleware_result)
         if middleware_result is False:
             return False
 
@@ -59,7 +59,7 @@ async def process_inner(
 
     logger.debug("Run post middlewares...")
     for middleware in middlewares:
-        logger.debug("Run post middleware {!r}", middleware.__class__.__name__)
+        logger.debug("Run post middleware {!r}", middleware.__class__.__qualname__)
         await middleware.post(event, responses, ctx)
 
     for session in ctx.get(CONTEXT_STORE_NODES_KEY, {}).values():

telegrinder/bot/dispatch/return_manager/abc.py

@@ -27,13 +27,10 @@ def register_manager(return_type: type[typing.Any] | types.UnionType):
 @dataclasses.dataclass(frozen=True, slots=True)
 class Manager:
     types: tuple[type, ...]
-    callback: typing.Callable[..., typing.Awaitable]
+    callback: typing.Callable[..., typing.Awaitable[typing.Any]]
 
     async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
-        try:
-            await self.callback(*args, **kwargs)
-        except BaseException as ex:
-            logger.exception(ex)
+        await self.callback(*args, **kwargs)
 
 
 class ABCReturnManager(ABC, typing.Generic[Event]):
@@ -51,11 +48,16 @@ class BaseReturnManager(ABCReturnManager[Event]):
 
     @property
     def managers(self) -> list[Manager]:
-        return [
+        managers = self.__dict__.get("managers")
+        if managers is not None:
+            return managers
+        managers_lst = [
             manager
             for manager in (vars(BaseReturnManager) | vars(self.__class__)).values()
             if isinstance(manager, Manager)
         ]
+        self.__dict__["managers"] = managers_lst
+        return managers_lst
 
     @register_manager(Context)
     @staticmethod
@@ -73,7 +75,8 @@ class BaseReturnManager(ABCReturnManager[Event]):
 
     @typing.overload
     def register_manager(
-        self, return_type: type[T]
+        self,
+        return_type: type[T],
     ) -> typing.Callable[[typing.Callable[[T, Event, Context], typing.Awaitable[typing.Any]]], Manager]: ...
 
     @typing.overload
@@ -94,7 +97,7 @@ class BaseReturnManager(ABCReturnManager[Event]):
     ]:
         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)
+            self.managers.append(manager)
             return manager
 
         return wrapper

telegrinder/bot/dispatch/return_manager/callback_query.py

@@ -1,6 +1,6 @@
 import typing
 
-from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
 
@@ -11,7 +11,7 @@ class CallbackQueryReturnManager(BaseReturnManager[CallbackQueryCute]):
     async def str_manager(value: str, event: CallbackQueryCute, ctx: Context) -> None:
         await event.answer(value)
 
-    @register_manager(dict)
+    @register_manager(dict[str, typing.Any])
     @staticmethod
     async def dict_manager(value: dict[str, typing.Any], event: CallbackQueryCute, ctx: Context) -> None:
         await event.answer(**value)