telegrinder 0.1.dev167__py3-none-any.whl → 0.1.dev169__py3-none-any.whl

telegrinder/bot/rules/chat_join.py

@@ -4,14 +4,15 @@ 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
 
 from .abc import ABCRule
 
 ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
 
 
-class ChatJoinRequestRule(ABCRule[ChatJoinRequestCute], requires=[]):
-    adapter = EventAdapter("chat_join_request", ChatJoinRequest)
+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:

telegrinder/bot/rules/command.py

@@ -2,24 +2,24 @@ import dataclasses
 import typing
 
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.node import Source
+from telegrinder.node.command import CommandInfo, single_split
+from telegrinder.node.me import Me
 
-from .abc import Message
-from .text import TextMessageRule
+from ...types import ChatType
+from .abc import ABCRule
 
 Validator = typing.Callable[[str], typing.Any | None]
 
 
-def single_split(s: str, separator: str) -> tuple[str, str]:
-    left, *right = s.split(separator, 1)
-    return left, (right[0] if right else "")
-
-
 @dataclasses.dataclass(frozen=True)
 class Argument:
     name: str
     validators: list[Validator] = dataclasses.field(default_factory=lambda: [])
     optional: bool = dataclasses.field(default=False, kw_only=True)
 
+    # NOTE: add optional param `description`
+
     def check(self, data: str) -> typing.Any | None:
         for validator in self.validators:
             data = validator(data)  # type: ignore
@@ -28,7 +28,7 @@ class Argument:
         return data
 
 
-class Command(TextMessageRule):
+class Command(ABCRule):
     def __init__(
         self,
         names: str | typing.Iterable[str],
@@ -36,12 +36,18 @@ class Command(TextMessageRule):
         prefixes: tuple[str, ...] = ("/",),
         separator: str = " ",
         lazy: bool = False,
+        validate_mention: bool = True,
+        mention_needed_in_chat: bool = False,
     ) -> None:
         self.names = [names] if isinstance(names, str) else names
         self.arguments = arguments
         self.prefixes = prefixes
         self.separator = separator
         self.lazy = lazy
+        self.validate_mention = validate_mention
+
+        # if true then we'll check for mention when message is from a group
+        self.mention_needed_in_chat = mention_needed_in_chat
 
     def remove_prefix(self, text: str) -> str | None:
         for prefix in self.prefixes:
@@ -93,19 +99,25 @@ class Command(TextMessageRule):
 
         return None
 
-    async def check(self, message: Message, ctx: Context) -> bool:
-        text = self.remove_prefix(message.text.unwrap())
-        if text is None:
+    async def check(self, command: CommandInfo, me: Me, src: Source, ctx: Context) -> bool:
+        name = self.remove_prefix(command.name)
+        if name is None:
             return False
 
-        name, arguments = single_split(text, self.separator)
         if name not in self.names:
             return False
 
+        if not command.mention and self.mention_needed_in_chat and src.chat.type is not ChatType.PRIVATE:
+            return False
+
+        if command.mention and self.validate_mention:  # noqa
+            if command.mention.unwrap().lower() != me.username.unwrap().lower():
+                return False
+
         if not self.arguments:
-            return not arguments
+            return not command.arguments
 
-        result = self.parse_arguments(list(self.arguments), arguments)
+        result = self.parse_arguments(list(self.arguments), command.arguments)
         if result is None:
             return False
 

telegrinder/bot/rules/enum_text.py

@@ -2,14 +2,14 @@ import enum
 import typing
 
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.text import Text
 
-from .abc import Message
-from .text import TextMessageRule
+from .abc import ABCRule
 
 T = typing.TypeVar("T", bound=enum.Enum)
 
 
-class EnumTextRule(TextMessageRule, typing.Generic[T]):
+class EnumTextRule(ABCRule, typing.Generic[T]):
     def __init__(self, enum_t: type[T], *, lower_case: bool = True) -> None:
         self.enum_t = enum_t
         self.texts = list(
@@ -25,8 +25,8 @@ class EnumTextRule(TextMessageRule, typing.Generic[T]):
                 return enumeration
         raise KeyError("Enumeration is undefined.")
 
-    async def check(self, message: Message, ctx: Context) -> bool:
-        text = message.text.unwrap().lower()
+    async def check(self, text: Text, ctx: Context) -> bool:
+        text = text.lower()  # type: ignore
         if text not in self.texts:
             return False
         ctx.enum_text = self.find(text)

telegrinder/bot/rules/func.py

@@ -4,19 +4,19 @@ import typing
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.types import Update
 
-from .abc import ABCAdapter, ABCRule, RawUpdateAdapter, T
+from .abc import ABCAdapter, ABCRule, AdaptTo, RawUpdateAdapter
 
 
-class FuncRule(ABCRule, typing.Generic[T]):
+class FuncRule(ABCRule, typing.Generic[AdaptTo]):
     def __init__(
         self,
-        func: typing.Callable[[T, Context], typing.Awaitable[bool] | bool],
-        adapter: ABCAdapter[Update, T] | None = None,
+        func: typing.Callable[[AdaptTo, Context], typing.Awaitable[bool] | bool],
+        adapter: ABCAdapter[Update, AdaptTo] | None = None,
     ):
         self.func = func
-        self.adapter = adapter or RawUpdateAdapter()
+        self.adapter = adapter or RawUpdateAdapter()  # type: ignore
 
-    async def check(self, event: T, ctx: Context) -> bool:
+    async def check(self, event: AdaptTo, ctx: Context) -> bool:
         result = self.func(event, ctx)
         if inspect.isawaitable(result):
             return await result

telegrinder/bot/rules/fuzzy.py

@@ -1,22 +1,20 @@
 import difflib
 
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.text import Text
 
-from .abc import Message
-from .text import TextMessageRule
+from .abc import ABCRule
 
 
-class FuzzyText(TextMessageRule):
+class FuzzyText(ABCRule):
     def __init__(self, texts: str | list[str], min_ratio: float = 0.7):
         if isinstance(texts, str):
             texts = [texts]
         self.texts = texts
         self.min_ratio = min_ratio
 
-    async def check(self, message: Message, ctx: Context) -> bool:
-        match = max(
-            difflib.SequenceMatcher(a=message.text.unwrap(), b=text).ratio() for text in self.texts
-        )
+    async def check(self, message_text: Text, ctx: Context) -> bool:
+        match = max(difflib.SequenceMatcher(a=message_text, b=text).ratio() for text in self.texts)
         if match < self.min_ratio:
             return False
         ctx.fuzzy_ratio = match

telegrinder/bot/rules/inline.py

@@ -5,7 +5,7 @@ from telegrinder.bot.cute_types import InlineQueryCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.bot.rules.adapter import EventAdapter
-from telegrinder.types.enums import ChatType
+from telegrinder.types.enums import ChatType, UpdateType
 
 from .markup import Markup, PatternLike, check_string
 
@@ -13,11 +13,11 @@ InlineQuery: typing.TypeAlias = InlineQueryCute
 
 
 class InlineQueryRule(ABCRule[InlineQuery], abc.ABC):
-    adapter = EventAdapter("inline_query", InlineQuery)
+    adapter: EventAdapter[InlineQuery] = EventAdapter(UpdateType.INLINE_QUERY, InlineQuery)
 
     @abc.abstractmethod
     async def check(self, query: InlineQuery, ctx: Context) -> bool:
-        pass
+        ...
 
 
 class HasLocation(InlineQueryRule):
@@ -36,8 +36,7 @@ class InlineQueryChatType(InlineQueryRule):
 class InlineQueryText(InlineQueryRule):
     def __init__(self, texts: str | list[str], *, lower_case: bool = False) -> None:
         self.texts = [
-            text.lower() if lower_case else text
-            for text in ([texts] if isinstance(texts, str) else texts)
+            text.lower() if lower_case else text for text in ([texts] if isinstance(texts, str) else texts)
         ]
         self.lower_case = lower_case
 

telegrinder/bot/rules/integer.py

@@ -1,19 +1,21 @@
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.text import TextInteger
 
-from .text import Message, TextMessageRule
+from .abc import ABCRule
+from .node import NodeRule
 
 
-class Integer(TextMessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.text.unwrap().isdigit()
+class IsInteger(NodeRule):
+    def __init__(self) -> None:
+        super().__init__(TextInteger)
 
 
-class IntegerInRange(TextMessageRule, requires=[Integer()]):
+class IntegerInRange(ABCRule):
     def __init__(self, rng: range):
         self.rng = rng
 
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return int(message.text.unwrap()) in self.rng
+    async def check(self, integer: TextInteger) -> bool:
+        return integer in self.rng
 
 
-__all__ = ("Integer", "IntegerInRange")
+__all__ = ("IsInteger", "IntegerInRange")

telegrinder/bot/rules/is_from.py

@@ -1,145 +1,117 @@
 import typing
 
-from fntypes.co import Nothing, Some
-
-from telegrinder.bot.cute_types.base import BaseCute
-from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.msgspec_utils import Option
+from telegrinder.node.source import ChatSource, UserSource
 from telegrinder.types.enums import ChatType, DiceEmoji
-from telegrinder.types.objects import User
 
 from .abc import ABCRule, Message
 from .message import MessageRule
 
-T = typing.TypeVar("T", bound=BaseCute)
-
-
-def get_from_user(obj: typing.Any) -> User:
-    assert isinstance(obj, FromUserProto)
-    return obj.from_.unwrap() if isinstance(obj.from_, Some | Nothing) else obj.from_
-
-
-@typing.runtime_checkable
-class FromUserProto(typing.Protocol):
-    from_: User | Option[User]
-
 
-class HasFrom(ABCRule[T]):
-    async def check(self, event: UpdateCute, ctx: Context) -> bool:
-        event_model = event.incoming_update.unwrap()
-        return isinstance(event_model, FromUserProto) and bool(event_model.from_)
+class IsBot(ABCRule):
+    async def check(self, user: UserSource) -> bool:
+        return user.is_bot
 
 
-class HasDice(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return bool(message.dice)
-
+class IsUser(ABCRule):
+    async def check(self, user: UserSource) -> bool:
+        return not user.is_bot
 
-class IsForward(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return bool(message.forward_origin)
 
+class IsPremium(ABCRule):
+    async def check(self, user: UserSource) -> bool:
+        return user.is_premium.unwrap_or(False)
 
-class IsForwardType(MessageRule, requires=[IsForward()]):
-    def __init__(
-        self, fwd_type: typing.Literal["user", "hidden_user", "chat", "channel"], /
-    ) -> None:
-        self.fwd_type = fwd_type
-
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.forward_origin.unwrap().v.type == self.fwd_type
 
+class IsLanguageCode(ABCRule):
+    def __init__(self, lang_codes: str | list[str], /) -> None:
+        self.lang_codes = [lang_codes] if isinstance(lang_codes, str) else lang_codes
 
-class IsReply(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return bool(message.reply_to_message)
+    async def check(self, user: UserSource) -> bool:
+        return user.language_code.unwrap_or_none() in self.lang_codes
 
 
-class IsSticker(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return bool(message.sticker)
+class IsUserId(ABCRule):
+    def __init__(self, user_ids: int | list[int], /) -> None:
+        self.user_ids = [user_ids] if isinstance(user_ids, int) else user_ids
 
+    async def check(self, user: UserSource) -> bool:
+        return user.id in self.user_ids
 
-class IsBot(ABCRule[T], requires=[HasFrom()]):
-    async def check(self, event: UpdateCute, ctx: Context) -> bool:
-        return get_from_user(event.incoming_update.unwrap()).is_bot
 
+class IsForum(ABCRule):
+    async def check(self, chat: ChatSource) -> bool:
+        return chat.is_forum.unwrap_or(False)
 
-class IsUser(ABCRule[T], requires=[HasFrom()]):
-    async def check(self, event: UpdateCute, ctx: Context) -> bool:
-        return not get_from_user(event.incoming_update.unwrap()).is_bot
 
+class IsChatId(ABCRule):
+    def __init__(self, chat_ids: int | list[int], /) -> None:
+        self.chat_ids = [chat_ids] if isinstance(chat_ids, int) else chat_ids
 
-class IsPremium(ABCRule[T], requires=[HasFrom()]):
-    async def check(self, event: UpdateCute, ctx: Context) -> bool:
-        return get_from_user(event.incoming_update.unwrap()).is_premium.unwrap_or(False)
+    async def check(self, chat: ChatSource) -> bool:
+        return chat.id in self.chat_ids
 
 
-class IsLanguageCode(ABCRule[T], requires=[HasFrom()]):
-    def __init__(self, lang_codes: str | list[str], /) -> None:
-        self.lang_codes = [lang_codes] if isinstance(lang_codes, str) else lang_codes
+class IsPrivate(ABCRule):
+    async def check(self, chat: ChatSource) -> bool:
+        return chat.type == ChatType.PRIVATE
 
-    async def check(self, event: UpdateCute, ctx: Context) -> bool:
-        return (
-            get_from_user(event.incoming_update.unwrap()).language_code.unwrap_or_none()
-            in self.lang_codes
-        )
 
+class IsGroup(ABCRule):
+    async def check(self, chat: ChatSource) -> bool:
+        return chat.type == ChatType.GROUP
 
-class IsForum(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.chat.is_forum.unwrap_or(False)
 
+class IsSuperGroup(ABCRule):
+    async def check(self, chat: ChatSource) -> bool:
+        return chat.type == ChatType.SUPERGROUP
 
-class IsUserId(ABCRule[T], requires=[HasFrom()]):
-    def __init__(self, user_ids: int | list[int], /) -> None:
-        self.user_ids = [user_ids] if isinstance(user_ids, int) else user_ids
 
-    async def check(self, event: UpdateCute, ctx: Context) -> bool:
-        return get_from_user(event.incoming_update.unwrap()).id in self.user_ids
+class IsChat(ABCRule):
+    async def check(self, chat: ChatSource) -> bool:
+        return chat.type in (ChatType.GROUP, ChatType.SUPERGROUP)
 
 
-class IsChatId(MessageRule):
-    def __init__(self, chat_ids: int | list[int], /) -> None:
-        self.chat_ids = [chat_ids] if isinstance(chat_ids, int) else chat_ids
+class IsDice(MessageRule):
+    async def check(self, message: Message) -> bool:
+        return bool(message.dice)
 
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.chat.id in self.chat_ids
 
+class IsDiceEmoji(MessageRule, requires=[IsDice()]):
+    def __init__(self, dice_emoji: DiceEmoji, /) -> None:
+        self.dice_emoji = dice_emoji
 
-class IsPrivate(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.chat.type == ChatType.PRIVATE
+    async def check(self, message: Message) -> bool:
+        return message.dice.unwrap().emoji == self.dice_emoji
 
 
-class IsGroup(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.chat.type == ChatType.GROUP
+class IsForward(MessageRule):
+    async def check(self, message: Message) -> bool:
+        return bool(message.forward_origin)
 
 
-class IsSuperGroup(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.chat.type == ChatType.SUPERGROUP
+class IsForwardType(MessageRule, requires=[IsForward()]):
+    def __init__(self, fwd_type: typing.Literal["user", "hidden_user", "chat", "channel"], /) -> None:
+        self.fwd_type = fwd_type
 
+    async def check(self, message: Message) -> bool:
+        return message.forward_origin.unwrap().v.type == self.fwd_type
 
-class IsChat(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.chat.type in (ChatType.GROUP, ChatType.SUPERGROUP)
 
+class IsReply(MessageRule):
+    async def check(self, message: Message) -> bool:
+        return bool(message.reply_to_message)
 
-class IsDiceEmoji(MessageRule, requires=[HasDice()]):
-    def __init__(self, dice_emoji: DiceEmoji, /) -> None:
-        self.dice_emoji = dice_emoji
 
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.dice.unwrap().emoji == self.dice_emoji
+class IsSticker(MessageRule):
+    async def check(self, message: Message) -> bool:
+        return bool(message.sticker)
 
 
 __all__ = (
     "IsBot",
     "IsChat",
     "IsChatId",
+    "IsDice",
     "IsDiceEmoji",
     "IsForum",
     "IsForward",

telegrinder/bot/rules/markup.py

@@ -3,10 +3,10 @@ import typing
 import vbml
 
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.text import Text
 from telegrinder.tools.global_context import TelegrinderCtx
 
-from .abc import Message
-from .text import TextMessageRule
+from .abc import ABCRule
 
 PatternLike: typing.TypeAlias = str | vbml.Pattern
 global_ctx = TelegrinderCtx()
@@ -23,7 +23,7 @@ def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
     return False
 
 
-class Markup(TextMessageRule):
+class Markup(ABCRule):
     def __init__(self, patterns: PatternLike | list[PatternLike], /):
         if not isinstance(patterns, list):
             patterns = [patterns]
@@ -31,8 +31,8 @@ class Markup(TextMessageRule):
             vbml.Pattern(pattern) if isinstance(pattern, str) else pattern for pattern in patterns
         ]
 
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return check_string(self.patterns, message.text.unwrap(), ctx)
+    async def check(self, text: Text, ctx: Context) -> bool:
+        return check_string(self.patterns, text, ctx)
 
 
 __all__ = ("Markup", "check_string")

telegrinder/bot/rules/mention.py

@@ -1,11 +1,11 @@
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.types.enums import MessageEntityType
 
-from .text import Message, TextMessageRule
+from .message import Message, MessageRule
+from .text import HasText
 
 
-class HasMention(TextMessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
+class HasMention(MessageRule, requires=[HasText()]):
+    async def check(self, message: Message) -> bool:
         if not message.entities.unwrap_or_none():
             return False
         return any(entity.type == MessageEntityType.MENTION for entity in message.entities.unwrap())

telegrinder/bot/rules/message.py

@@ -8,7 +8,7 @@ from .adapter import EventAdapter
 
 
 class MessageRule(ABCRule[Message], abc.ABC):
-    adapter = EventAdapter(MessageEvent, Message)
+    adapter: EventAdapter[Message] = EventAdapter(MessageEvent, Message)
 
     @abc.abstractmethod
     async def check(self, message: Message, ctx: Context) -> bool: ...

telegrinder/bot/rules/node.py

@@ -0,0 +1,27 @@
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node import Node
+
+from .abc import ABCRule
+from .adapter.node import NodeAdapter
+
+
+class NodeRule(ABCRule[tuple[Node, ...]]):
+    def __init__(self, *nodes: type[Node] | tuple[str, type[Node]]) -> None:
+        bindings = [binding if isinstance(binding, tuple) else (None, binding) for binding in nodes]
+        self.nodes = [binding[1] for binding in bindings]
+        self.node_keys = [binding[0] for binding in bindings]
+
+    @property
+    def adapter(self) -> NodeAdapter:
+        return NodeAdapter(*self.nodes)
+
+    async def check(self, resolved_nodes: tuple[Node, ...], ctx: Context) -> typing.Literal[True]:
+        for i, node in enumerate(resolved_nodes):
+            if key := self.node_keys[i]:
+                ctx[key] = node
+        return True
+
+
+__all__ = ("NodeRule",)

telegrinder/bot/rules/regex.py

@@ -2,14 +2,14 @@ import re
 import typing
 
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.text import Text
 
-from .abc import Message
-from .text import TextMessageRule
+from .abc import ABCRule
 
 PatternLike: typing.TypeAlias = str | typing.Pattern[str]
 
 
-class Regex(TextMessageRule):
+class Regex(ABCRule):
     def __init__(self, regexp: PatternLike | list[PatternLike]):
         self.regexp: list[re.Pattern[str]] = []
         match regexp:
@@ -22,9 +22,9 @@ class Regex(TextMessageRule):
                     re.compile(regexp) if isinstance(regexp, str) else regexp for regexp in regexp
                 )
 
-    async def check(self, message: Message, ctx: Context) -> bool:
+    async def check(self, text: Text, ctx: Context) -> bool:
         for regexp in self.regexp:
-            response = re.match(regexp, message.text.unwrap())
+            response = re.match(regexp, text)
             if response is not None:
                 if matches := response.groupdict():
                     ctx |= matches

telegrinder/bot/rules/rule_enum.py

@@ -3,7 +3,7 @@ import typing
 
 from telegrinder.bot.dispatch.context import Context
 
-from .abc import ABCRule, T, Update, check_rule
+from .abc import ABCRule, Update, check_rule
 from .func import FuncRule
 
 
@@ -17,10 +17,10 @@ class RuleEnumState:
         return self.cls == other.cls and self.name == other.name
 
 
-class RuleEnum(ABCRule[T]):
+class RuleEnum(ABCRule):
     __enum__: list[RuleEnumState]
 
-    def __init_subclass__(cls, *args, **kwargs):
+    def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
         new_attributes = set(cls.__dict__) - set(RuleEnum.__dict__) - {"__enum__", "__init__"}
         enum_lst: list[RuleEnumState] = []
 
@@ -34,7 +34,7 @@ class RuleEnum(ABCRule[T]):
             setattr(
                 self,
                 attribute.name,
-                self & FuncRule(lambda _, ctx: self.must_be_state(ctx, attribute)),
+                self & FuncRule(lambda _, ctx: self.must_be_state(ctx, attribute)),  # type: ignore
             )
             enum_lst.append(attribute)
 

telegrinder/bot/rules/start.py

@@ -4,7 +4,7 @@ from telegrinder.bot.dispatch.context import Context
 from telegrinder.types.enums import MessageEntityType
 
 from .is_from import IsPrivate
-from .markup import Markup, Message
+from .markup import Markup
 from .message import MessageRule
 from .message_entities import MessageEntities
 
@@ -12,9 +12,9 @@ from .message_entities import MessageEntities
 class StartCommand(
     MessageRule,
     requires=[
-        IsPrivate()
-        & MessageEntities(MessageEntityType.BOT_COMMAND)
-        & Markup(["/start <param>", "/start"]),
+        IsPrivate(), 
+        MessageEntities(MessageEntityType.BOT_COMMAND),
+        Markup(["/start <param>", "/start"]),
     ],
 ):
     def __init__(
@@ -28,7 +28,7 @@ class StartCommand(
         self.validator = validator
         self.alias = alias
 
-    async def check(self, _: Message, ctx: Context) -> bool:
+    async def check(self, ctx: Context) -> bool:
         param: str | None = ctx.pop("param", None)
         validated_param = self.validator(param) if self.validator and param is not None else param