telegrinder 0.1.dev170__py3-none-any.whl → 0.2.0__py3-none-any.whl

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -2,16 +2,20 @@ import asyncio
 import datetime
 import typing
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.view.abc import ABCStateView, BaseStateView
+from telegrinder.bot.dispatch.waiter_machine.middleware import WaiterMiddleware
+from telegrinder.bot.dispatch.waiter_machine.short_state import (
+    Behaviour,
+    EventModel,
+    ShortState,
+    ShortStateContext,
+)
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.tools.limited_dict import LimitedDict
 from telegrinder.types import Update
 
-from .middleware import WaiterMiddleware
-from .short_state import Behaviour, EventModel, ShortState, ShortStateContext
-
 if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch import Dispatch
 
@@ -67,7 +71,7 @@ class WaiterMachine:
     async def wait(
         self,
         state_view: "BaseStateView[EventModel]",
-        linked: EventModel | tuple[ABCAPI, Identificator],
+        linked: EventModel | tuple[API, Identificator],
         *rules: ABCRule,
         default: Behaviour[EventModel] | None = None,
         on_drop: Behaviour[EventModel] | None = None,
@@ -77,7 +81,7 @@ class WaiterMachine:
         if isinstance(expiration, int | float):
             expiration = datetime.timedelta(seconds=expiration)
 
-        api: ABCAPI
+        api: API
         key: Identificator
         api, key = linked if isinstance(linked, tuple) else (linked.ctx_api, state_view.get_state_key(linked))  # type: ignore
         if not key:
@@ -123,7 +127,7 @@ class WaiterMachine:
 
         ctx = Context(**context)
         if await behaviour.check(event.api, update, ctx):
-            await behaviour.run(event, ctx)
+            await behaviour.run(event.api, event, ctx)
             return True
 
         return False
@@ -132,7 +136,7 @@ class WaiterMachine:
         self,
         views: typing.Iterable[ABCStateView[EventModel]],
         absolutely_dead_time: datetime.timedelta = WEEK,
-    ):
+    ) -> None:
         """Clears storage.
 
         :param absolutely_dead_time: timedelta when state can be forgotten.

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -83,7 +83,7 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         result = await handler.check(event.ctx_api, ctx.raw_update, ctx)
 
         if result is True:
-            await handler.run(event, ctx)
+            await handler.run(event.api, event, ctx)
 
         elif short_state.default_behaviour is not None:
             await self.machine.call_behaviour(

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -3,7 +3,7 @@ import dataclasses
 import datetime
 import typing
 
-from telegrinder.api import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
@@ -24,10 +24,10 @@ class ShortStateContext(typing.Generic[EventModel], typing.NamedTuple):
     context: Context
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class ShortState(typing.Generic[EventModel]):
     key: "Identificator"
-    ctx_api: ABCAPI
+    ctx_api: API
     event: asyncio.Event
     rules: tuple[ABCRule, ...]
     expiration: dataclasses.InitVar[datetime.timedelta | None] = dataclasses.field(
@@ -38,6 +38,7 @@ class ShortState(typing.Generic[EventModel]):
     on_drop_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None, kw_only=True)
     exit_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None, kw_only=True)
     expiration_date: datetime.datetime | None = dataclasses.field(init=False, kw_only=True)
+    creation_date: datetime.datetime = dataclasses.field(init=False)
     context: ShortStateContext[EventModel] | None = dataclasses.field(default=None, init=False, kw_only=True)
 
     def __post_init__(self, expiration: datetime.timedelta | None = None) -> None:

telegrinder/bot/polling/abc.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 
 import msgspec
 
-from telegrinder.types import Update
+from telegrinder.types.objects import Update
 
 
 class ABCPolling(ABC):

telegrinder/bot/polling/polling.py

@@ -5,25 +5,25 @@ import aiohttp
 import msgspec
 from fntypes.result import Error, Ok
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.api.error import InvalidTokenError
 from telegrinder.bot.polling.abc import ABCPolling
 from telegrinder.modules import logger
 from telegrinder.msgspec_utils import decoder
-from telegrinder.types import Update, UpdateType
+from telegrinder.types.objects import Update, UpdateType
 
 
 class Polling(ABCPolling):
     def __init__(
         self,
-        api: ABCAPI,
+        api: API,
         *,
         offset: int = 0,
         reconnection_timeout: float = 5,
         max_reconnetions: int = 10,
         include_updates: set[str | UpdateType] | None = None,
         exclude_updates: set[str | UpdateType] | None = None,
-    ):
+    ) -> None:
         self.api = api
         self.allowed_updates = self.get_allowed_updates(
             include_updates=include_updates,
@@ -48,8 +48,8 @@ class Polling(ABCPolling):
             self.reconnection_timeout,
         )
 
+    @staticmethod
     def get_allowed_updates(
-        self,
         *,
         include_updates: set[str | UpdateType] | None = None,
         exclude_updates: set[str | UpdateType] | None = None,
@@ -111,7 +111,7 @@ class Polling(ABCPolling):
                     exit(6)
                 else:
                     logger.warning(
-                        "Server disconnected, waiting 5 seconds to reconnet...",
+                        "Server disconnected, waiting 5 seconds to reconnect...",
                     )
                     reconn_counter += 1
                     await asyncio.sleep(self.reconnection_timeout)

telegrinder/bot/rules/__init__.py

@@ -1,5 +1,5 @@
-from .abc import ABCRule, AndRule, NotRule, OrRule
-from .callback_data import (
+from telegrinder.bot.rules.abc import ABCRule, AndRule, NotRule, OrRule
+from telegrinder.bot.rules.callback_data import (
     CallbackDataEq,
     CallbackDataJsonEq,
     CallbackDataJsonModel,
@@ -9,25 +9,25 @@ from .callback_data import (
     CallbackQueryRule,
     HasData,
 )
-from .chat_join import (
+from telegrinder.bot.rules.chat_join import (
     ChatJoinRequestRule,
     HasInviteLink,
     InviteLinkByCreator,
     InviteLinkName,
 )
-from .command import Argument, Command
-from .enum_text import EnumTextRule
-from .func import FuncRule
-from .fuzzy import FuzzyText
-from .inline import (
+from telegrinder.bot.rules.command import Argument, Command
+from telegrinder.bot.rules.enum_text import EnumTextRule
+from telegrinder.bot.rules.func import FuncRule
+from telegrinder.bot.rules.fuzzy import FuzzyText
+from telegrinder.bot.rules.inline import (
     HasLocation,
     InlineQueryChatType,
     InlineQueryMarkup,
     InlineQueryRule,
     InlineQueryText,
 )
-from .integer import IntegerInRange, IsInteger
-from .is_from import (
+from telegrinder.bot.rules.integer import IntegerInRange, IsInteger
+from telegrinder.bot.rules.is_from import (
     IsBot,
     IsChat,
     IsChatId,
@@ -45,16 +45,16 @@ from .is_from import (
     IsUser,
     IsUserId,
 )
-from .markup import Markup
-from .mention import HasMention
-from .message import MessageRule
-from .message_entities import HasEntities, MessageEntities
-from .node import NodeRule
-from .regex import Regex
-from .rule_enum import RuleEnum
-from .start import StartCommand
-from .text import HasText, Text
-from .update import IsUpdateType
+from telegrinder.bot.rules.markup import Markup
+from telegrinder.bot.rules.mention import HasMention
+from telegrinder.bot.rules.message import MessageRule
+from telegrinder.bot.rules.message_entities import HasEntities, MessageEntities
+from telegrinder.bot.rules.node import NodeRule
+from telegrinder.bot.rules.regex import Regex
+from telegrinder.bot.rules.rule_enum import RuleEnum
+from telegrinder.bot.rules.start import StartCommand
+from telegrinder.bot.rules.text import HasText, Text
+from telegrinder.bot.rules.update import IsUpdateType
 
 __all__ = (
     "ABCRule",

telegrinder/bot/rules/abc.py

@@ -1,5 +1,6 @@
 import inspect
 from abc import ABC, abstractmethod
+from functools import cached_property
 
 import typing_extensions as typing
 
@@ -8,12 +9,19 @@ from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.process import check_rule
 from telegrinder.bot.rules.adapter import ABCAdapter, RawUpdateAdapter
 from telegrinder.bot.rules.adapter.node import Event
-from telegrinder.node.base import Node, is_node
-from telegrinder.node.composer import NodeCollection
+from telegrinder.node.base import Node, get_nodes, is_node
 from telegrinder.tools.i18n.base import ABCTranslator
-from telegrinder.tools.magic import cache_translation, get_annotations, get_cached_translation
+from telegrinder.tools.magic import (
+    cache_translation,
+    get_annotations,
+    get_cached_translation,
+    get_default_args,
+)
 from telegrinder.types.objects import Update as UpdateObject
 
+if typing.TYPE_CHECKING:
+    from telegrinder.node.composer import NodeCollection
+
 AdaptTo = typing.TypeVar("AdaptTo", default=typing.Any)
 
 Message: typing.TypeAlias = MessageCute
@@ -34,50 +42,16 @@ def with_caching_translations(func: typing.Callable[..., typing.Any]):
 
 
 class ABCRule(ABC, typing.Generic[AdaptTo]):
-    adapter: ABCAdapter[UpdateObject, AdaptTo] = RawUpdateAdapter()  # type: ignore
+    adapter: ABCAdapter[UpdateObject, AdaptTo]
     requires: list["ABCRule"] = []
 
+    if not typing.TYPE_CHECKING:
+        adapter = RawUpdateAdapter()
+
     @abstractmethod
     async def check(self, event: AdaptTo, *, ctx: Context) -> bool:
         pass
 
-    def get_required_nodes(self) -> dict[str, type[Node]]:
-        return {k: v for k, v in get_annotations(self.check).items() if is_node(v)}
-
-    async def bounding_check(
-        self,
-        adapted_value: AdaptTo,
-        ctx: Context,
-        node_col: NodeCollection | None = None,
-    ) -> bool:
-        kw = {}
-        node_col_values = node_col.values() if node_col is not None else {}
-
-        for i, (k, v) in enumerate(get_annotations(self.check).items()):
-            if (isinstance(adapted_value, Event) and not i) or (
-                isinstance(v, type) and isinstance(adapted_value, v)
-            ):
-                kw[k] = adapted_value if not isinstance(adapted_value, Event) else adapted_value.obj
-            elif is_node(v):
-                assert k in node_col_values, "Node is undefined, error while bounding."
-                kw[k] = node_col_values[k]
-            elif k in ctx:
-                kw[k] = ctx[k]
-            elif v is Context:
-                kw[k] = ctx
-            else:
-                raise LookupError(
-                    f"Cannot bound {k!r} of type {v!r} to '{self.__class__.__name__}.check()', because it cannot be resolved."
-                )
-
-        return await self.check(**kw)
-
-    def optional(self) -> "ABCRule":
-        return self | Always()
-
-    def should_fail(self) -> "ABCRule":
-        return self & Never()
-
     def __init_subclass__(cls, requires: list["ABCRule"] | None = None) -> None:
         """Merges requirements from inherited classes and rule-specific requirements."""
 
@@ -128,6 +102,46 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
             self.adapter,
         )
 
+    @cached_property
+    def required_nodes(self) -> dict[str, type[Node]]:
+        return get_nodes(self.check)
+
+    def as_optional(self) -> "ABCRule":
+        return self | Always()
+
+    def should_fail(self) -> "ABCRule":
+        return self & Never()
+
+    async def bounding_check(
+        self,
+        adapted_value: AdaptTo,
+        ctx: Context,
+        node_col: "NodeCollection | None" = None,
+    ) -> bool:
+        kw = {}
+        node_col_values = node_col.values if node_col is not None else {}
+        temp_ctx = get_default_args(self.check) | ctx
+
+        for i, (k, v) in enumerate(get_annotations(self.check).items()):
+            if (isinstance(adapted_value, Event) and not i) or (
+                isinstance(v, type) and isinstance(adapted_value, v)
+            ):
+                kw[k] = adapted_value if not isinstance(adapted_value, Event) else adapted_value.obj
+            elif is_node(v):
+                assert k in node_col_values, "Node is undefined, error while bounding."
+                kw[k] = node_col_values[k]
+            elif k in temp_ctx:
+                kw[k] = temp_ctx[k]
+            elif v is Context:
+                kw[k] = ctx
+            else:
+                raise LookupError(
+                    f"Cannot bound {k!r} of type {v!r} to '{self.__class__.__qualname__}.check()', "
+                    "because it cannot be resolved."
+                )
+
+        return await self.check(**kw)
+
     async def translate(self, translator: ABCTranslator) -> typing.Self:
         return self
 
@@ -179,10 +193,10 @@ class Always(ABCRule):
 
 __all__ = (
     "ABCRule",
+    "Always",
     "AndRule",
+    "Never",
     "NotRule",
     "OrRule",
     "with_caching_translations",
-    "Never",
-    "Always",
 )

telegrinder/bot/rules/adapter/__init__.py

@@ -1,8 +1,8 @@
-from .abc import ABCAdapter, Event
-from .errors import AdapterError
-from .event import EventAdapter
-from .node import NodeAdapter
-from .raw_update import RawUpdateAdapter
+from telegrinder.bot.rules.adapter.abc import ABCAdapter, Event
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.bot.rules.adapter.event import EventAdapter
+from telegrinder.bot.rules.adapter.node import NodeAdapter
+from telegrinder.bot.rules.adapter.raw_update import RawUpdateAdapter
 
 __all__ = (
     "ABCAdapter",

telegrinder/bot/rules/adapter/abc.py

@@ -4,7 +4,8 @@ import typing
 
 from fntypes.result import Result
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
+from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter.errors import AdapterError
 from telegrinder.model import Model
 
@@ -13,12 +14,14 @@ To = typing.TypeVar("To")
 
 
 class ABCAdapter(abc.ABC, typing.Generic[From, To]):
+    ADAPTED_VALUE_KEY: str | None = None
+
     @abc.abstractmethod
-    async def adapt(self, api: ABCAPI, update: From) -> Result[To, AdapterError]:
+    async def adapt(self, api: API, update: From, context: Context) -> Result[To, AdapterError]:
         pass
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class Event(typing.Generic[To]):
     obj: To
 

telegrinder/bot/rules/adapter/errors.py

@@ -1,4 +1,5 @@
-class AdapterError(RuntimeError): ...
+class AdapterError(RuntimeError):
+    pass
 
 
 __all__ = ("AdapterError",)

telegrinder/bot/rules/adapter/event.py

@@ -2,8 +2,9 @@ import typing
 
 from fntypes.result import Error, Ok, Result
 
-from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.cute_types import BaseCute
+from telegrinder.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
@@ -14,6 +15,8 @@ ToCute = typing.TypeVar("ToCute", bound=BaseCute)
 
 
 class EventAdapter(ABCAdapter[Update, ToCute]):
+    ADAPTED_VALUE_KEY: str = "_adapted_cute_event"
+
     def __init__(self, event: UpdateType | type[Model], cute_model: type[ToCute]) -> None:
         self.event = event
         self.cute_model = cute_model
@@ -29,33 +32,45 @@ class EventAdapter(ABCAdapter[Update, ToCute]):
         else:
             raw_update_type = self.event.__name__
 
-        return "<{}: adapt {} -> {}>".format(
+        return "<{}: adapt Update -> {} -> {}>".format(
             self.__class__.__name__,
             raw_update_type,
             self.cute_model.__name__,
         )
 
-    async def adapt(self, api: ABCAPI, update: Update) -> Result[ToCute, AdapterError]:
-        update_dct = update.to_dict()
+    async def adapt(self, api: API, update: Update, context: Context) -> Result[ToCute, AdapterError]:
+        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 update_dct[self.event.value] is Nothing:
+            if isinstance(event := getattr(update, self.event.value, Nothing), type(Nothing)):
                 return Error(
                     AdapterError(f"Update is not an {self.event!r}."),
                 )
 
-            return Ok(
-                self.cute_model.from_update(update_dct[self.event.value].unwrap(), bound_api=api),
-            )
+            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)
 
-        event = update_dct[update.update_type.value].unwrap()
-        if not update.update_type or not issubclass(event.__class__, self.event):
-            return Error(AdapterError(f"Update is not an {self.event.__name__!r}."))
-        return Ok(self.cute_model.from_update(event, bound_api=api))
+        context[self.ADAPTED_VALUE_KEY] = adapted
+        return Ok(adapted)  # type: ignore
 
 
 __all__ = ("EventAdapter",)

telegrinder/bot/rules/adapter/node.py

@@ -1,17 +1,18 @@
-import typing
-
+import typing_extensions as typing
 from fntypes.result import Error, Ok, Result
 
-from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.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
-from telegrinder.node.base import ComposeError
-from telegrinder.node.composer import NodeSession, compose_node
+from telegrinder.msgspec_utils import repr_type
+from telegrinder.node.composer import NodeSession, compose_nodes
 from telegrinder.types.objects import Update
 
-Ts = typing.TypeVarTuple("Ts")
+if typing.TYPE_CHECKING:
+    from telegrinder.node.base import Node
+
+Ts = typing.TypeVarTuple("Ts", default=typing.Unpack[tuple[type["Node"], ...]])
 
 
 class NodeAdapter(typing.Generic[*Ts], ABCAdapter[Update, Event[tuple[*Ts]]]):
@@ -19,24 +20,29 @@ class NodeAdapter(typing.Generic[*Ts], ABCAdapter[Update, Event[tuple[*Ts]]]):
         self.nodes = nodes
 
     def __repr__(self) -> str:
-        return "<{}: adapt Update -> {}>".format(
+        return "<{}: adapt Update -> ({})>".format(
             self.__class__.__name__,
-            Update.__name__,
-            ", ".join(node.__name__ for node in self.nodes),  # type: ignore
+            ", ".join(repr_type(node) for node in self.nodes),
+        )
+
+    async def adapt(
+        self,
+        api: API,
+        update: Update,
+        context: Context,
+    ) -> Result[Event[tuple[*Ts]], AdapterError]:
+        result = await compose_nodes(
+            nodes={str(i): typing.cast(type["Node"], node) for i, node in enumerate(self.nodes)},
+            ctx=context,
+            data={Update: update, API: api},
         )
 
-    async def adapt(self, api: ABCAPI, update: Update) -> Result[Event[tuple[*Ts]], AdapterError]:
-        update_cute = UpdateCute.from_update(update, api)
-        node_sessions: list[NodeSession] = []
-        for node_t in self.nodes:
-            try:
-                # FIXME: adapters should have context
-                node_sessions.append(await compose_node(node_t, update_cute, Context()))  # type: ignore
-            except ComposeError:
-                for session in node_sessions:
-                    await session.close(with_value=None)
-                return Error(AdapterError(f"Couldn't compose nodes, error on {node_t}"))
-        return Ok(Event(tuple(node_sessions)))  # type: ignore
+        match result:
+            case Ok(collection):
+                sessions: list[NodeSession] = list(collection.sessions.values())
+                return Ok(Event(tuple(sessions)))  # type: ignore
+            case Error(err):
+                return Error(AdapterError(f"Couldn't compose nodes, error: {err}."))
 
 
 __all__ = ("NodeAdapter",)

telegrinder/bot/rules/adapter/raw_update.py

@@ -1,24 +1,32 @@
 from fntypes.result import Ok, Result
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.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
 from telegrinder.bot.rules.adapter.errors import AdapterError
 from telegrinder.types.objects import Update
 
 
 class RawUpdateAdapter(ABCAdapter[Update, UpdateCute]):
+    ADAPTED_VALUE_KEY: str = "_adapted_update_cute"
+
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}: adapt Update -> UpdateCute>"
 
     async def adapt(
         self,
-        api: ABCAPI,
+        api: API,
         update: Update,
+        context: Context,
     ) -> Result[UpdateCute, AdapterError]:
-        if not isinstance(update, UpdateCute):
-            return Ok(UpdateCute.from_update(update, api))
-        return Ok(update)
+        if self.ADAPTED_VALUE_KEY not in context:
+            context[self.ADAPTED_VALUE_KEY] = (
+                UpdateCute.from_update(update, api)
+                if not isinstance(update, UpdateCute)
+                else update
+            )
+        return Ok(context[self.ADAPTED_VALUE_KEY])
 
 
 __all__ = ("RawUpdateAdapter",)

telegrinder/bot/rules/callback_data.py

@@ -26,12 +26,12 @@ class CallbackQueryRule(ABCRule[CallbackQuery], abc.ABC):
     adapter: EventAdapter[CallbackQuery] = EventAdapter(UpdateType.CALLBACK_QUERY, CallbackQuery)
 
     @abc.abstractmethod
-    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+    async def check(self, event: CallbackQuery, context: Context) -> bool:
         pass
 
 
 class HasData(CallbackQueryRule):
-    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+    async def check(self, event: CallbackQuery) -> bool:
         return bool(event.data.unwrap_or_none())
 
 
@@ -122,7 +122,7 @@ class CallbackDataEq(CallbackQueryDataRule):
     def __init__(self, value: str, /) -> None:
         self.value = value
 
-    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+    async def check(self, event: CallbackQuery) -> bool:
         return event.data.unwrap() == self.value
 
 
@@ -130,7 +130,7 @@ class CallbackDataJsonEq(CallbackQueryDataRule):
     def __init__(self, d: dict[str, typing.Any], /) -> None:
         self.d = d
 
-    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+    async def check(self, event: CallbackQuery) -> bool:
         return event.decode_callback_data().unwrap_or_none() == self.d
 
 

telegrinder/bot/rules/chat_join.py

@@ -15,12 +15,12 @@ class ChatJoinRequestRule(ABCRule[ChatJoinRequest], requires=[]):
     adapter: EventAdapter[ChatJoinRequest] = EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest)
 
     @abc.abstractmethod
-    async def check(self, event: ChatJoinRequest, ctx: Context) -> bool:
+    async def check(self, event: ChatJoinRequest, context: Context) -> bool:
         pass
 
 
 class HasInviteLink(ChatJoinRequestRule):
-    async def check(self, event: ChatJoinRequest, ctx: Context) -> bool:
+    async def check(self, event: ChatJoinRequest) -> bool:
         return bool(event.invite_link)
 
 
@@ -28,7 +28,7 @@ class InviteLinkName(ChatJoinRequestRule, requires=[HasInviteLink()]):
     def __init__(self, name: str, /) -> None:
         self.name = name
 
-    async def check(self, event: ChatJoinRequest, ctx: Context) -> bool:
+    async def check(self, event: ChatJoinRequest) -> bool:
         return event.invite_link.unwrap().name.unwrap_or_none() == self.name
 
 
@@ -36,7 +36,7 @@ class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
     def __init__(self, creator_id: int, /) -> None:
         self.creator_id = creator_id
 
-    async def check(self, event: ChatJoinRequest, ctx: Context) -> bool:
+    async def check(self, event: ChatJoinRequest) -> bool:
         return event.invite_link.unwrap().creator.id == self.creator_id