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

telegrinder/__init__.py

@@ -69,7 +69,6 @@ from .bot import (
     Polling,
     RawEventView,
     ShortState,
-    ShortStateStorage,
     SingleChoice,
     Telegrinder,
     UpdateCute,
@@ -189,7 +188,6 @@ __all__ = (
     "RawEventView",
     "RowButtons",
     "ShortState",
-    "ShortStateStorage",
     "SimpleI18n",
     "SimpleTranslator",
     "SingleChoice",

telegrinder/bot/__init__.py

@@ -33,7 +33,6 @@ from .dispatch import (
     MessageView,
     RawEventView,
     ShortState,
-    ShortStateStorage,
     ViewBox,
     WaiterMachine,
     register_manager,
@@ -80,7 +79,6 @@ __all__ = (
     "Polling",
     "RawEventView",
     "ShortState",
-    "ShortStateStorage",
     "SingleChoice",
     "Telegrinder",
     "UpdateCute",

telegrinder/bot/bot.py

@@ -57,9 +57,7 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
 
     def run_forever(self, *, offset: int = 0, skip_updates: bool = False) -> None:
         logger.debug("Running blocking polling (id={})", self.api.id)
-        self.loop_wrapper.add_task(
-            self.run_polling(offset=offset, skip_updates=skip_updates)
-        )
+        self.loop_wrapper.add_task(self.run_polling(offset=offset, skip_updates=skip_updates))
         self.loop_wrapper.run_event_loop()
 
 

telegrinder/bot/cute_types/base.py

@@ -74,9 +74,7 @@ def compose_method_params(
         if param_name not in params:
             if param_name in validators and not validators[param_name](update):
                 continue
-            params[param_name] = getattr(
-                update, param if isinstance(param, str) else param[1]
-            )
+            params[param_name] = getattr(update, param if isinstance(param, str) else param[1])
 
     return params
 
@@ -105,21 +103,14 @@ def shortcut(
             index = 0
 
             for k, p in signature_params.items():
-                if (
-                    p.kind in (p.POSITIONAL_OR_KEYWORD, p.POSITIONAL_ONLY)
-                    and len(args) > index
-                ):
+                if p.kind in (p.POSITIONAL_OR_KEYWORD, p.POSITIONAL_ONLY) and len(args) > index:
                     params[k] = args[index]
                     index += 1
                     continue
                 if p.kind in (p.VAR_KEYWORD, p.VAR_POSITIONAL):
                     params[k] = kwargs.copy() if p.kind is p.VAR_KEYWORD else args[index:]
                     continue
-                params[k] = (
-                    kwargs.pop(k, p.default)
-                    if p.default is not p.empty
-                    else kwargs.pop(k)
-                )
+                params[k] = kwargs.pop(k, p.default) if p.default is not p.empty else kwargs.pop(k)
 
             return await executor(self, method_name, get_params(params))
 

telegrinder/bot/cute_types/callback_query.py

@@ -44,9 +44,7 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True, di
         by the bot with the callback button that originated the query."""
 
         return self.message.map(
-            lambda m: m.only()
-            .map(lambda m: m.is_topic_message.unwrap_or(False))
-            .unwrap_or(False)
+            lambda m: m.only().map(lambda m: m.is_topic_message.unwrap_or(False)).unwrap_or(False)
         )
 
     @property
@@ -219,7 +217,7 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True, di
     )
     async def edit_text(
         self,
-        text: str | None,
+        text: str,
         inline_message_id: int | None = None,
         chat_id: int | str | None = None,
         message_id: int | None = None,

telegrinder/bot/cute_types/chat_join_request.py

@@ -9,7 +9,9 @@ from .base import BaseCute, shortcut
 from .chat_member_updated import ChatMemberShortcuts, chat_member_interaction
 
 
-class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMemberShortcuts, kw_only=True):
+class ChatJoinRequestCute(
+    BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMemberShortcuts, kw_only=True
+):
     api: ABCAPI
 
     @property

telegrinder/bot/cute_types/chat_member_updated.py

@@ -232,7 +232,9 @@ class ChatMemberShortcuts:
         ...
 
 
-class ChatMemberUpdatedCute(BaseCute[ChatMemberUpdated], ChatMemberUpdated, ChatMemberShortcuts, kw_only=True):
+class ChatMemberUpdatedCute(
+    BaseCute[ChatMemberUpdated], ChatMemberUpdated, ChatMemberShortcuts, kw_only=True
+):
     api: ABCAPI
 
     @property

telegrinder/bot/cute_types/message.py

@@ -71,16 +71,12 @@ async def execute_method_answer(
     link_preview_options = params.get("link_preview_options")
 
     if reply_parameters is not None and isinstance(reply_parameters, dict):
-        reply_parameters.setdefault(
-            "message_id", params.get("message_id", message.message_id)
-        )
+        reply_parameters.setdefault("message_id", params.get("message_id", message.message_id))
         reply_parameters.setdefault("chat_id", params.get("chat_id"))
         params["reply_parameters"] = compose_reply_params(**reply_parameters)
 
     if link_preview_options is not None and isinstance(link_preview_options, dict):
-        params["link_preview_options"] = compose_link_preview_options(
-            **link_preview_options
-        )
+        params["link_preview_options"] = compose_link_preview_options(**link_preview_options)
 
     result = await getattr(message.ctx_api, method_name)(**params)
     return result.map(
@@ -124,8 +120,7 @@ async def execute_method_edit(
             "message_thread_id": lambda x: (
                 x.is_topic_message.unwrap_or(False)
                 if isinstance(x, MessageCute)
-                else bool(x.message)
-                and getattr(x.message.unwrap().v, "is_topic_message", False)
+                else bool(x.message) and getattr(x.message.unwrap().v, "is_topic_message", False)
             ),
         },
     )
@@ -330,9 +325,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
             params=get_params(locals()),
             update=self,
             default_params={"chat_id", "message_id", "message_thread_id"},
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         return await self.ctx_api.delete_message(**params)
 
@@ -450,9 +443,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
                 ("from_chat_id", "chat_id"),
                 "message_thread_id",
             },
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         if isinstance(reply_parameters, dict):
             reply_parameters.setdefault("message_id", params.get("message_id"))
@@ -467,11 +458,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     async def react(
         self,
         reaction: (
-            str
-            | ReactionEmoji
-            | ReactionType
-            | list[str | ReactionEmoji | ReactionType]
-            | None
+            str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType] | None
         ) = None,
         chat_id: int | str | None = None,
         message_thread_id: int | None = None,
@@ -507,9 +494,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
             params=get_params(locals()),
             update=self,
             default_params={"chat_id", "message_id", "message_thread_id"},
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         if reaction:
             params["reaction"] = compose_reactions(
@@ -557,9 +542,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
                 "message_id",
                 "message_thread_id",
             },
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         return (await self.ctx_api.forward_message(**params)).map(
             lambda message: MessageCute.from_update(message, bound_api=self.api),
@@ -599,9 +582,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
             params=get_params(locals()),
             update=self,
             default_params={"chat_id", "message_id", "message_thread_id"},
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         return await self.ctx_api.pin_chat_message(**params)
 
@@ -632,9 +613,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
             params=get_params(locals()),
             update=self,
             default_params={"chat_id", "message_id", "message_thread_id"},
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         return await self.ctx_api.pin_chat_message(**params)
 

telegrinder/bot/cute_types/utils.py

@@ -69,9 +69,7 @@ INPUT_MEDIA_TYPES: typing.Final[dict[str, type[InputMedia]]] = {
 
 
 def compose_reactions(
-    reactions: (
-        str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType]
-    ),
+    reactions: (str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType]),
     /,
 ) -> list[ReactionType]:
     if not isinstance(reactions, list):

telegrinder/bot/dispatch/__init__.py

@@ -27,7 +27,7 @@ from .view import (
     RawEventView,
     ViewBox,
 )
-from .waiter_machine import ShortState, ShortStateStorage, WaiterMachine
+from .waiter_machine import ShortState, WaiterMachine
 
 __all__ = (
     "ABCDispatch",
@@ -56,7 +56,6 @@ __all__ = (
     "MessageView",
     "RawEventView",
     "ShortState",
-    "ShortStateStorage",
     "TelegrinderCtx",
     "ViewBox",
     "WaiterMachine",

telegrinder/bot/dispatch/composition.py

@@ -78,9 +78,7 @@ class CompositionDispatch(ABCDispatch):
         def wrapper(func: typing.Callable):
             composition = Composition(func, is_blocking)
             if container_nodes:
-                composition.nodes["container"] = ContainerNode.link_nodes(
-                    list(container_nodes)
-                )
+                composition.nodes["container"] = ContainerNode.link_nodes(list(container_nodes))
             self.compositions.append(composition)
             return func
 

telegrinder/bot/dispatch/dispatch.py

@@ -135,7 +135,9 @@ class Dispatch(
 
     async def feed(self, event: Update, api: ABCAPI) -> bool:
         logger.debug("Processing update (update_id={})", event.update_id)
-        await self.raw_event.process(event, api)
+        loop = asyncio.get_running_loop()
+        loop.create_task(self.raw_event.process(event, api))
+        
         for view in self.get_views().values():
             if await view.check(event):
                 logger.debug(
@@ -143,10 +145,9 @@ class Dispatch(
                     event.update_id,
                     view.__class__.__name__,
                 )
-                await view.process(event, api)
+                loop.create_task(view.process(event, api))
                 return True
 
-        loop = asyncio.get_running_loop()
         ctx = Context()
         found = False
         for handler in self.default_handlers:
@@ -160,9 +161,7 @@ class Dispatch(
     def load(self, external: typing.Self) -> None:
         view_external = external.get_views()
         for name, view in self.get_views().items():
-            assert (
-                name in view_external
-            ), f"View {name!r} is undefined in external dispatch."
+            assert name in view_external, f"View {name!r} is undefined in external dispatch."
             view.load(view_external[name])
             setattr(external, name, view)
 

telegrinder/bot/dispatch/handler/func.py

@@ -18,14 +18,10 @@ if typing.TYPE_CHECKING:
 
 F = typing.TypeVar(
     "F",
-    bound=typing.Callable[
-        typing.Concatenate[typing.Any, ...], typing.Awaitable[typing.Any]
-    ],
+    bound=typing.Callable[typing.Concatenate[typing.Any, ...], typing.Awaitable[typing.Any]],
 )
 EventT = typing.TypeVar("EventT", bound=BaseCute)
-ErrorHandlerT = typing.TypeVar(
-    "ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler
-)
+ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
 
 
 @dataclasses.dataclass(repr=False)
@@ -50,12 +46,9 @@ class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
             self.dataclass,
             self.error_handler,
         )
-
+    
     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.unwrap_or_none():
             return False
         ctx = ctx or Context()
         temp_ctx = ctx.copy()

telegrinder/bot/dispatch/return_manager/abc.py

@@ -66,9 +66,7 @@ class BaseReturnManager(ABCReturnManager[EventT]):
 
     async def run(self, response: typing.Any, event: EventT, ctx: Context) -> None:
         for manager in self.managers:
-            if typing.Any in manager.types or any(
-                type(response) is x for x in manager.types
-            ):
+            if typing.Any in manager.types or any(type(response) is x for x in manager.types):
                 await manager(response, event, ctx)
 
     @typing.overload
@@ -79,24 +77,22 @@ class BaseReturnManager(ABCReturnManager[EventT]):
     ]: ...
 
     @typing.overload
-    def register_manager(self, return_type: tuple[type[T], ...]) -> typing.Callable[
+    def register_manager(
+        self,
+        return_type: tuple[type[T], ...],
+    ) -> typing.Callable[
         [typing.Callable[[tuple[T, ...], EventT, Context], typing.Awaitable[typing.Any]]],
         Manager,
     ]: ...
 
     def register_manager(
-        self, return_type: type[T] | tuple[type[T], ...]
+        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, ...], EventT, Context], typing.Awaitable[typing.Any]]],
         Manager,
     ]:
-        def wrapper(
-            func: typing.Callable[[T, EventT, Context], typing.Awaitable]
-        ) -> Manager:
+        def wrapper(func: typing.Callable[[T, EventT, 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/message.py

@@ -16,23 +16,21 @@ class MessageReturnManager(BaseReturnManager[MessageCute]):
     @register_manager(list | tuple)
     @staticmethod
     async def seq_manager(
-        value: list[str] | tuple[str, ...], event: MessageCute, ctx: Context
+        value: list[str] | tuple[str, ...],
+        event: MessageCute,
+        ctx: Context,
     ) -> None:
         for message in value:
             await event.answer(message)
 
     @register_manager(dict)
     @staticmethod
-    async def dict_manager(
-        value: dict[str, typing.Any], event: MessageCute, ctx: Context
-    ) -> None:
+    async def dict_manager(value: dict[str, typing.Any], event: MessageCute, ctx: Context) -> None:
         await event.answer(**value)
 
     @register_manager(HTMLFormatter)
     @staticmethod
-    async def htmlformatter_manager(
-        value: HTMLFormatter, event: MessageCute, ctx: Context
-    ) -> None:
+    async def htmlformatter_manager(value: HTMLFormatter, event: MessageCute, ctx: Context) -> None:
         await event.answer(value, parse_mode=HTMLFormatter.PARSE_MODE)
 
 

telegrinder/bot/dispatch/view/abc.py

@@ -63,19 +63,68 @@ class BaseView(ABCView, typing.Generic[EventType]):
         for base in cls.__dict__.get("__orig_bases__", ()):
             if issubclass(typing.get_origin(base) or base, ABCView):
                 for generic_type in typing.get_args(base):
-                    if issubclass(
-                        typing.get_origin(generic_type) or generic_type, BaseCute
-                    ):
+                    if issubclass(typing.get_origin(generic_type) or generic_type, BaseCute):
                         return Some(generic_type)
         return Nothing()
 
-    @classmethod
-    def get_raw_event(cls, update: Update) -> Option[Model]:
+    @staticmethod
+    def get_raw_event(update: Update) -> Option[Model]:
         match update.update_type:
             case Some(update_type):
                 return getattr(update, update_type.value)
             case _:
                 return Nothing()
+    
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule[EventType],
+    ) -> typing.Callable[
+        [FuncType[EventType]],
+        FuncHandler[EventType, FuncType[EventType], ErrorHandler[EventType]],
+    ]: ...
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule[EventType],
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [FuncType[EventType]], FuncHandler[EventType, FuncType[EventType], ErrorHandlerT]
+    ]: ...
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule[EventType],
+        error_handler: typing.Literal[None] = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [FuncType[EventType]],
+        FuncHandler[EventType, FuncType[EventType], ErrorHandler[EventType]],
+    ]: ...
+
+    @classmethod
+    def to_handler(  # type: ignore
+        cls,
+        *rules: ABCRule[EventType],
+        error_handler: ABCErrorHandler | None = None,
+        is_blocking: bool = True,
+    ):
+        def wrapper(func: FuncType[EventType]):
+            return FuncHandler(
+                func,
+                list(rules),
+                is_blocking=is_blocking,
+                dataclass=None,
+                error_handler=error_handler or ErrorHandler(),
+            )
+
+        return wrapper
 
     @typing.overload
     def __call__(

telegrinder/bot/dispatch/view/box.py

@@ -12,16 +12,12 @@ from .inline_query import InlineQueryView
 from .message import MessageView
 from .raw import RawEventView
 
-CallbackQueryViewT = typing.TypeVar(
-    "CallbackQueryViewT", bound=ABCView, default=CallbackQueryView
-)
+CallbackQueryViewT = typing.TypeVar("CallbackQueryViewT", bound=ABCView, default=CallbackQueryView)
 ChatJoinRequestViewT = typing.TypeVar(
     "ChatJoinRequestViewT", bound=ABCView, default=ChatJoinRequestView
 )
 ChatMemberViewT = typing.TypeVar("ChatMemberViewT", bound=ABCView, default=ChatMemberView)
-InlineQueryViewT = typing.TypeVar(
-    "InlineQueryViewT", bound=ABCView, default=InlineQueryView
-)
+InlineQueryViewT = typing.TypeVar("InlineQueryViewT", bound=ABCView, default=InlineQueryView)
 MessageViewT = typing.TypeVar("MessageViewT", bound=ABCView, default=MessageView)
 RawEventViewT = typing.TypeVar("RawEventViewT", bound=ABCView, default=RawEventView)
 
@@ -100,11 +96,7 @@ class ViewBox(
     def get_views(self) -> dict[str, ABCView]:
         """Get all views."""
 
-        return {
-            name: view
-            for name, view in self.__dict__.items()
-            if isinstance(view, ABCView)
-        }
+        return {name: view for name, view in self.__dict__.items() if isinstance(view, ABCView)}
 
 
 __all__ = ("ViewBox",)

telegrinder/bot/dispatch/view/raw.py

@@ -41,9 +41,7 @@ class RawEventView(BaseView[UpdateCute]):
         update_type: UpdateType,
         *rules: ABCRule[UpdateCute],
         dataclass: type[T],
-    ) -> typing.Callable[
-        [FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandler[T]]
-    ]: ...
+    ) -> typing.Callable[[FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandler[T]]]: ...
 
     @typing.overload
     def __call__(
@@ -64,9 +62,7 @@ class RawEventView(BaseView[UpdateCute]):
         dataclass: type[T],
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[
-        [FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandlerT]
-    ]: ...
+    ) -> typing.Callable[[FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandlerT]]: ...
 
     @typing.overload
     def __call__(

telegrinder/bot/dispatch/waiter_machine/__init__.py

@@ -1,10 +1,9 @@
-from .machine import ShortStateStorage, WaiterMachine
+from .machine import WaiterMachine
 from .middleware import WaiterMiddleware
 from .short_state import ShortState
 
 __all__ = (
     "ShortState",
-    "ShortStateStorage",
     "WaiterMachine",
     "WaiterMiddleware",
 )