telegrinder 0.3.2__tar.gz → 0.3.3__tar.gz

{telegrinder-0.3.2 → telegrinder-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.3.2
+Version: 0.3.3
 Summary: Modern visionary telegram bot framework.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT

{telegrinder-0.3.2 → telegrinder-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.3.2"
+version = "0.3.3"
 description = "Modern visionary telegram bot framework."
 authors = ["timoniq <tesseradecades@mail.ru>"]
 maintainers = ["luwqz1 <howluwqz1@gmail.com>"]

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/cute_types/__init__.py

@@ -7,11 +7,11 @@ from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.cute_types.update import UpdateCute
 
 __all__ = (
-    "BaseCute",
-    "CallbackQueryCute",
-    "ChatJoinRequestCute",
-    "ChatMemberUpdatedCute",
-    "InlineQueryCute",
-    "MessageCute",
+    "BaseCute",
+    "CallbackQueryCute",
+    "ChatJoinRequestCute",
+    "ChatMemberUpdatedCute",
+    "InlineQueryCute",
+    "MessageCute",
     "UpdateCute",
 )

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/cute_types/callback_query.py

@@ -7,7 +7,7 @@ from fntypes.co import Nothing, Result, Some, Variative, unwrapping
 from telegrinder.api import API, APIError
 from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
 from telegrinder.bot.cute_types.message import MediaType, MessageCute, ReplyMarkup, execute_method_edit
-from telegrinder.model import get_params
+from telegrinder.model import From, field, get_params
 from telegrinder.msgspec_utils import Option, decoder
 from telegrinder.types.objects import *
 
@@ -15,7 +15,10 @@ from telegrinder.types.objects import *
 class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
     api: API
 
-    message: Option[Variative[MessageCute, InaccessibleMessage]] = Nothing()
+    message: Option[Variative[MessageCute, InaccessibleMessage]] = field(
+        default=Nothing(),
+        converter=From[MessageCute | InaccessibleMessage | None],
+    )
     """Optional. Message sent by the bot with the callback button that originated
     the query."""
 

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/cute_types/inline_query.py

@@ -15,11 +15,11 @@ class InlineQueryCute(BaseCute[InlineQuery], InlineQuery, kw_only=True):
     def from_user(self) -> User:
         return self.from_
 
-    @shortcut("answer_inline_query", custom_params={"results"})
+    @shortcut("answer_inline_query", custom_params={"results", "inline_query_id"})
     async def answer(
         self,
         results: InlineQueryResult | list[InlineQueryResult],
-        inline_query_id: str,
+        inline_query_id: str | None = None,
         cache_time: int | None = None,
         is_personal: bool | None = None,
         next_offset: str | None = None,
@@ -29,17 +29,7 @@ class InlineQueryCute(BaseCute[InlineQuery], InlineQuery, kw_only=True):
         """Shortcut `API.answer_inline_query()`, see the [documentation](https://core.telegram.org/bots/api#answerinlinequery)
 
         Use this method to send answers to an inline query. On success, True is returned.
-        No more than 50 results per query are allowed.
-        :param inline_query_id: Unique identifier for the answered query.
-
-        :param results: A JSON-serialized array of results for the inline query.
-
-        :param cache_time: The maximum amount of time in seconds that the result of the inline querymay be cached on the server. Defaults to 300.
-
-        :param is_personal: Pass True if results may be cached on the server side only for the user thatsent the query. By default, results may be returned to any user who sendsthe same query.
-
-        :param next_offset: Pass the offset that a client should send in the next query with the same textto receive more results. Pass an empty string if there are no more resultsor if you don't support pagination. Offset length can't exceed 64 bytes.
-        :param button: A JSON-serialized object describing a button to be shown above inline queryresults."""
+        No more than 50 results per query are allowed."""
 
         params = compose_method_params(
             get_params(locals()),

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/cute_types/message.py

@@ -13,7 +13,7 @@ from telegrinder.bot.cute_types.utils import (
     compose_reply_params,
     input_media,
 )
-from telegrinder.model import get_params
+from telegrinder.model import From, field, get_params
 from telegrinder.msgspec_utils import Nothing, Option
 from telegrinder.types import *
 
@@ -135,12 +135,18 @@ def get_entity_value(
 class MessageCute(BaseCute[Message], Message, kw_only=True):
     api: API
 
-    reply_to_message: Option[MessageCute] = Nothing
+    reply_to_message: Option[MessageCute] = field(
+        default=Nothing,
+        converter=From["MessageCute | None"],
+    )
     """Optional. For replies in the same chat and message thread, the original
     message. Note that the Message object in this field will not contain further
     reply_to_message fields even if it itself is a reply."""
 
-    pinned_message: Option[Variative[MessageCute, InaccessibleMessage]] = Nothing
+    pinned_message: Option[Variative[MessageCute, InaccessibleMessage]] = field(
+        default=Nothing,
+        converter=From["MessageCute | InaccessibleMessage | None"],
+    )
     """Optional. Specified message was pinned. Note that the Message object in
     this field will not contain further reply_to_message fields even if it
     itself is a reply."""

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/cute_types/update.py

@@ -10,6 +10,7 @@ from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
 from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
 from telegrinder.bot.cute_types.inline_query import InlineQueryCute
 from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.model import From, field
 from telegrinder.msgspec_utils import Option
 from telegrinder.types.objects import *
 
@@ -19,46 +20,79 @@ EventModel = typing.TypeVar("EventModel", bound=Model)
 class UpdateCute(BaseCute[Update], Update, kw_only=True):
     api: API
 
-    message: Option[MessageCute] = Nothing()
+    message: Option[MessageCute] = field(
+        default=Nothing(),
+        converter=From[MessageCute | None],
+    )
     """Optional. New incoming message of any kind - text, photo, sticker, etc."""
 
-    edited_message: Option[MessageCute] = Nothing()
+    edited_message: Option[MessageCute] = field(
+        default=Nothing(),
+        converter=From[MessageCute | None],
+    )
     """Optional. New version of a message that is known to the bot and was edited.
     This update may at times be triggered by changes to message fields that are
     either unavailable or not actively used by your bot."""
 
-    channel_post: Option[MessageCute] = Nothing()
+    channel_post: Option[MessageCute] = field(
+        default=Nothing(),
+        converter=From[MessageCute | None],
+    )
     """Optional. New incoming channel post of any kind - text, photo, sticker,
     etc."""
 
-    edited_channel_post: Option[MessageCute] = Nothing()
+    edited_channel_post: Option[MessageCute] = field(
+        default=Nothing(),
+        converter=From[MessageCute | None],
+    )
     """Optional. New version of a channel post that is known to the bot and was edited.
     This update may at times be triggered by changes to message fields that are
     either unavailable or not actively used by your bot."""
 
-    business_message: Option[MessageCute] = Nothing()
+    business_message: Option[MessageCute] = field(
+        default=Nothing(),
+        converter=From[MessageCute | None],
+    )
     """Optional. New message from a connected business account."""
 
-    edited_business_message: Option[MessageCute] = Nothing()
+    edited_business_message: Option[MessageCute] = field(
+        default=Nothing(),
+        converter=From[MessageCute | None],
+    )
     """Optional. New version of a message from a connected business account."""
 
-    inline_query: Option[InlineQueryCute] = Nothing()
+    inline_query: Option[InlineQueryCute] = field(
+        default=Nothing(),
+        converter=From[InlineQueryCute | None],
+    )
     """Optional. New incoming inline query."""
 
-    callback_query: Option[CallbackQueryCute] = Nothing()
+    callback_query: Option[CallbackQueryCute] = field(
+        default=Nothing(),
+        converter=From[CallbackQueryCute | None],
+    )
     """Optional. New incoming callback query."""
 
-    my_chat_member: Option[ChatMemberUpdatedCute] = Nothing()
+    my_chat_member: Option[ChatMemberUpdatedCute] = field(
+        default=Nothing(),
+        converter=From[ChatMemberUpdatedCute | None],
+    )
     """Optional. The bot's chat member status was updated in a chat. For private
     chats, this update is received only when the bot is blocked or unblocked
     by the user."""
 
-    chat_member: Option[ChatMemberUpdatedCute] = Nothing()
+    chat_member: Option[ChatMemberUpdatedCute] = field(
+        default=Nothing(),
+        converter=From[ChatMemberUpdatedCute | None],
+    )
     """Optional. A chat member's status was updated in a chat. The bot must be an
     administrator in the chat and must explicitly specify `chat_member` in
     the list of allowed_updates to receive these updates."""
 
-    chat_join_request: Option[ChatJoinRequestCute] = Nothing()
+    chat_join_request: Option[ChatJoinRequestCute] = field(
+        default=Nothing(),
+        converter=From[ChatJoinRequestCute | None],
+    )
     """Optional. A request to join the chat has been sent. The bot must have the can_invite_users
     administrator right in the chat to receive these updates."""
 

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/cute_types/utils.py

@@ -41,9 +41,9 @@ def compose_reactions(
         reactions = [reactions]
     return [
         (
-            ReactionTypeEmoji("emoji", emoji)
+            ReactionTypeEmoji(emoji)
             if isinstance(emoji, ReactionEmoji)
-            else (ReactionTypeEmoji("emoji", ReactionEmoji(emoji)) if isinstance(emoji, str) else emoji)
+            else (ReactionTypeEmoji(ReactionEmoji(emoji)) if isinstance(emoji, str) else emoji)
         )
         for emoji in ([reactions] if isinstance(reactions, str) else reactions)  # type: ignore
     ]
@@ -88,8 +88,8 @@ def input_media(
 
 
 __all__ = (
-    "compose_link_preview_options",
-    "compose_reactions",
-    "compose_reply_params",
+    "compose_link_preview_options",
+    "compose_reactions",
+    "compose_reply_params",
     "input_media",
 )

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/dispatch/context.py

@@ -1,9 +1,14 @@
+from __future__ import annotations
+
 import enum
 import typing
 from reprlib import recursive_repr
 
 from telegrinder.types.objects import Update
 
+if typing.TYPE_CHECKING:
+    from telegrinder.node.composer import NodeCollection
+
 T = typing.TypeVar("T")
 
 Key: typing.TypeAlias = str | enum.Enum
@@ -24,6 +29,7 @@ class Context(dict[str, AnyValue]):
     """
 
     raw_update: Update
+    node_col: NodeCollection | None = None
 
     def __init__(self, **kwargs: AnyValue) -> None:
         cls_vars = vars(self.__class__)

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/dispatch/handler/func.py

@@ -10,7 +10,7 @@ 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.composer import compose_nodes
+from telegrinder.node.composer import NodeCollection, compose_nodes
 from telegrinder.node.event import EVENT_NODE_KEY
 from telegrinder.tools.error_handler import ABCErrorHandler, ErrorHandler
 from telegrinder.types.enums import UpdateType
@@ -19,7 +19,8 @@ from telegrinder.types.objects import Update
 from .abc import ABCHandler
 
 if typing.TYPE_CHECKING:
-    from telegrinder.bot.rules import ABCRule
+    from telegrinder.bot.rules.abc import ABCRule
+    from telegrinder.node.composer import NodeCollection
 
 Rest = typing.ParamSpec("Rest")
 Result = typing.TypeVar("Result")
@@ -101,7 +102,13 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, Function, ErrorHandle
         ctx |= temp_ctx
         return True
 
-    async def run(self, api: API, event: Event, ctx: Context) -> typing.Any:
+    async def run(
+        self,
+        api: API,
+        event: Event,
+        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:

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/dispatch/waiter_machine/hasher/callback.py

@@ -51,7 +51,7 @@ CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE = Hasher(
 
 
 __all__ = (
-    "CALLBACK_QUERY_FOR_MESSAGE",
-    "CALLBACK_QUERY_FROM_CHAT",
+    "CALLBACK_QUERY_FOR_MESSAGE",
+    "CALLBACK_QUERY_FROM_CHAT",
     "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
 )

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/dispatch/waiter_machine/hasher/message.py

@@ -47,7 +47,7 @@ MESSAGE_FROM_USER_IN_CHAT = Hasher(
 
 
 __all__ = (
-    "MESSAGE_FROM_USER",
-    "MESSAGE_FROM_USER_IN_CHAT",
+    "MESSAGE_FROM_USER",
+    "MESSAGE_FROM_USER_IN_CHAT",
     "MESSAGE_IN_CHAT",
 )

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -51,12 +51,11 @@ class WaiterMachine:
         for hasher in self.storage:
             for ident, short_state in self.storage[hasher].items():
                 if short_state.context:
-                    await self.drop(
-                        hasher,
-                        ident,
-                    )
+                    await self.drop(hasher, ident)
                 else:
-                    short_state.cancel()
+                    await short_state.cancel()
+
+            del self.storage[hasher]
 
     async def drop(
         self,
@@ -79,7 +78,7 @@ class WaiterMachine:
         if on_drop := short_state.actions.get("on_drop"):
             on_drop(short_state, **context)
 
-        short_state.cancel()
+        await short_state.cancel()
 
     async def wait_from_event(
         self,
@@ -135,7 +134,7 @@ class WaiterMachine:
             self.storage[hasher] = LimitedDict(maxlimit=self.max_storage_size)
 
         if (deleted_short_state := self.storage[hasher].set(waiter_hash, short_state)) is not None:
-            deleted_short_state.cancel()
+            await deleted_short_state.cancel()
 
         await event.wait()
         self.storage[hasher].pop(waiter_hash, None)

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -2,6 +2,7 @@ import asyncio
 import dataclasses
 import datetime
 import typing
+from contextlib import suppress
 
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.context import Context
@@ -51,7 +52,7 @@ class ShortState(typing.Generic[EventModel]):
         self.creation_date = datetime.datetime.now()
         self.expiration_date = (self.creation_date + expiration) if expiration is not None else None
 
-    def cancel(self) -> None:
+    async def cancel(self) -> None:
         """Cancel schedule waiters."""
 
         waiters = typing.cast(
@@ -60,6 +61,8 @@ class ShortState(typing.Generic[EventModel]):
         )
         for future in waiters:
             future.cancel()
+            with suppress(asyncio.CancelledError):
+                await future
 
 
 __all__ = ("ShortState", "ShortStateContext")

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/rules/abc.py

@@ -24,7 +24,7 @@ if typing.TYPE_CHECKING:
 
 AdaptTo = typing.TypeVar("AdaptTo", default=typing.Any, contravariant=True)
 
-CheckResult: typing.TypeAlias = bool | typing.Coroutine[typing.Any, typing.Any, bool]
+CheckResult: typing.TypeAlias = bool | typing.Awaitable[bool]
 Message: typing.TypeAlias = MessageCute
 Update: typing.TypeAlias = UpdateCute
 
@@ -48,31 +48,6 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
 
     if typing.TYPE_CHECKING:
 
-        @typing.overload
-        def check(self) -> CheckResult: ...
-
-        @typing.overload
-        def check(self, event: AdaptTo, /) -> CheckResult: ...
-
-        @typing.overload
-        def check(self, event: AdaptTo, ctx: Context, /) -> CheckResult: ...
-
-        @typing.overload
-        def check(
-            self,
-            event: AdaptTo,
-            ctx: Context,
-            /,
-            *args: typing.Any,
-            **kwargs: typing.Any,
-        ) -> CheckResult: ...
-
-        @typing.overload
-        def check(self, event: AdaptTo, /, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
-
-        @typing.overload
-        def check(self, ctx: Context, /, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
-
         @abstractmethod
         def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult:
             pass
@@ -230,9 +205,9 @@ __all__ = (
     "ABCRule",
     "Always",
     "AndRule",
+    "CheckResult",
     "Never",
     "NotRule",
     "OrRule",
-    "CheckResult",
     "with_caching_translations",
 )

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/rules/adapter/abc.py

@@ -4,7 +4,7 @@ import typing
 
 from fntypes.result import Result
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter.errors import AdapterError
 from telegrinder.model import Model

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/rules/adapter/event.py

@@ -2,12 +2,12 @@ import typing
 
 from fntypes.result import Error, Ok, Result
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter.abc import ABCAdapter
 from telegrinder.bot.rules.adapter.errors import AdapterError
-from telegrinder.msgspec_utils import Nothing
+from telegrinder.bot.rules.adapter.raw_update import RawUpdateAdapter
 from telegrinder.types.enums import UpdateType
 from telegrinder.types.objects import Model, Update
 
@@ -42,35 +42,26 @@ class EventAdapter(ABCAdapter[Update, ToCute]):
         if self.ADAPTED_VALUE_KEY in context:
             return Ok(context[self.ADAPTED_VALUE_KEY])
 
-        if isinstance(self.event, UpdateType):
-            if update.update_type != self.event:
-                return Error(
-                    AdapterError(f"Update is not of event type {self.event!r}."),
-                )
-
-            if isinstance(event := getattr(update, self.event.value, Nothing), type(Nothing)):
-                return Error(
-                    AdapterError(f"Update is not an {self.event!r}."),
-                )
-
-            event = event.unwrap()
-
-            if type(event) is self.cute_model:
-                adapted = event
-            else:
-                adapted = self.cute_model.from_update(event, bound_api=api)
-        else:
-            event = getattr(update, update.update_type.value).unwrap()
-            if not update.update_type or not issubclass(type(event), self.event):
-                return Error(AdapterError(f"Update is not an {self.event.__name__!r}."))
-
-            if type(event) is self.cute_model:
-                adapted = event
-            else:
-                adapted = self.cute_model.from_update(event, bound_api=api)
-
-        context[self.ADAPTED_VALUE_KEY] = adapted
-        return Ok(adapted)  # type: ignore
+        match await RawUpdateAdapter().adapt(api, update, context):
+            case Ok(update_cute):
+                incoming_update = None
+                if isinstance(self.event, UpdateType) and self.event == update_cute.update_type:
+                    incoming_update = update_cute.incoming_update
+                if not isinstance(self.event, UpdateType) and (event := update_cute.get_event(self.event)):
+                    incoming_update = update_cute.get_event(self.event).unwrap_or_none()
+
+                if incoming_update is not None:
+                    adapted = (
+                        typing.cast(ToCute, incoming_update)
+                        if isinstance(incoming_update, BaseCute)
+                        else self.cute_model.from_update(incoming_update, bound_api=api)
+                    )
+                    context[self.ADAPTED_VALUE_KEY] = adapted
+                    return Ok(adapted)
+
+                return Error(AdapterError(f"Update is not an {self.event!r}."))
+            case Error(_) as err:
+                return err
 
 
 __all__ = ("EventAdapter",)

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/rules/adapter/node.py

@@ -1,7 +1,7 @@
 import typing_extensions as typing
 from fntypes.result import Error, Ok, Result
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter.abc import ABCAdapter, Event
 from telegrinder.bot.rules.adapter.errors import AdapterError

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/rules/adapter/raw_update.py

@@ -1,6 +1,6 @@
 from fntypes.result import Ok, Result
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter.abc import ABCAdapter

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/rules/callback_data.py

@@ -26,8 +26,7 @@ class CallbackQueryRule(ABCRule[CallbackQuery], abc.ABC):
     adapter: EventAdapter[CallbackQuery] = EventAdapter(UpdateType.CALLBACK_QUERY, CallbackQuery)
 
     @abc.abstractmethod
-    def check(self, event: CallbackQuery, context: Context) -> CheckResult:
-        pass
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
 
 
 class HasData(CallbackQueryRule):

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/rules/chat_join.py

@@ -2,7 +2,6 @@ import abc
 import typing
 
 from telegrinder.bot.cute_types import ChatJoinRequestCute
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter import EventAdapter
 from telegrinder.types.enums import UpdateType
 
@@ -15,8 +14,7 @@ class ChatJoinRequestRule(ABCRule[ChatJoinRequest], requires=[]):
     adapter: EventAdapter[ChatJoinRequest] = EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest)
 
     @abc.abstractmethod
-    def check(self, event: ChatJoinRequest, context: Context) -> CheckResult:
-        pass
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
 
 
 class HasInviteLink(ChatJoinRequestRule):

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/rules/inline.py

@@ -16,7 +16,7 @@ class InlineQueryRule(ABCRule[InlineQuery], abc.ABC):
     adapter: EventAdapter[InlineQuery] = EventAdapter(UpdateType.INLINE_QUERY, InlineQuery)
 
     @abc.abstractmethod
-    def check(self, query: InlineQuery, ctx: Context) -> CheckResult: ...
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
 
 
 class HasLocation(InlineQueryRule):

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/rules/is_from.py

@@ -123,24 +123,24 @@ class IsPhoto(MessageRule):
 
 
 __all__ = (
-    "IsBot",
-    "IsChat",
-    "IsChatId",
-    "IsDice",
-    "IsDiceEmoji",
-    "IsDocument",
-    "IsForum",
-    "IsForward",
-    "IsForwardType",
-    "IsGroup",
-    "IsLanguageCode",
-    "IsPhoto",
-    "IsPremium",
-    "IsPrivate",
-    "IsReply",
-    "IsSticker",
-    "IsSuperGroup",
-    "IsUser",
-    "IsUserId",
+    "IsBot",
+    "IsChat",
+    "IsChatId",
+    "IsDice",
+    "IsDiceEmoji",
+    "IsDocument",
+    "IsForum",
+    "IsForward",
+    "IsForwardType",
+    "IsGroup",
+    "IsLanguageCode",
+    "IsPhoto",
+    "IsPremium",
+    "IsPrivate",
+    "IsReply",
+    "IsSticker",
+    "IsSuperGroup",
+    "IsUser",
+    "IsUserId",
     "IsVideoNote",
 )

{telegrinder-0.3.2 → telegrinder-0.3.3}/telegrinder/bot/rules/message.py

@@ -1,6 +1,6 @@
 import abc
+import typing
 
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.types.objects import Message as MessageEvent
 
 from .abc import ABCRule, CheckResult, Message
@@ -11,7 +11,7 @@ class MessageRule(ABCRule[Message], abc.ABC):
     adapter: EventAdapter[Message] = EventAdapter(MessageEvent, Message)
 
     @abc.abstractmethod
-    def check(self, message: Message, ctx: Context) -> CheckResult: ...
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
 
 
 __all__ = ("MessageRule",)