telegrinder 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/bot/rules/callback_data.py

@@ -1,164 +1,123 @@
-import abc
-import inspect
-import typing
-from contextlib import suppress
-
-import msgspec
-
-from telegrinder.bot.cute_types import CallbackQueryCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.adapter import EventAdapter
-from telegrinder.model import decoder
-from telegrinder.tools.buttons import DataclassInstance
-from telegrinder.types.enums import UpdateType
-
-from .abc import ABCRule, CheckResult
-from .markup import Markup, PatternLike, check_string
-
-CallbackQuery: typing.TypeAlias = CallbackQueryCute
-Validator: typing.TypeAlias = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
-MapDict: typing.TypeAlias = dict[str, "typing.Any | type[typing.Any] | Validator | list[MapDict] | MapDict"]
-CallbackMap: typing.TypeAlias = list[tuple[str, "typing.Any | type[typing.Any] | Validator | CallbackMap"]]
-CallbackMapStrict: typing.TypeAlias = list[tuple[str, "Validator | CallbackMapStrict"]]
-
-
-class CallbackQueryRule(ABCRule[CallbackQuery], abc.ABC):
-    adapter: EventAdapter[CallbackQuery] = EventAdapter(UpdateType.CALLBACK_QUERY, CallbackQuery)
-
-    @abc.abstractmethod
-    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
-
-
-class HasData(CallbackQueryRule):
-    def check(self, event: CallbackQuery) -> bool:
-        return bool(event.data.unwrap_or_none())
-
-
-class CallbackQueryDataRule(CallbackQueryRule, abc.ABC, requires=[HasData()]):
-    pass
-
-
-class CallbackDataMap(CallbackQueryDataRule):
-    def __init__(self, mapping: MapDict, /) -> None:
-        self.mapping = self.transform_to_callbacks(
-            self.transform_to_map(mapping),
-        )
-
-    @classmethod
-    def transform_to_map(cls, mapping: MapDict) -> CallbackMap:
-        """Transforms MapDict to CallbackMap."""
-
-        callback_map = []
-
-        for k, v in mapping.items():
-            if isinstance(v, dict):
-                v = cls.transform_to_map(v)
-            callback_map.append((k, v))
-
-        return callback_map
-
-    @classmethod
-    def transform_to_callbacks(cls, callback_map: CallbackMap) -> CallbackMapStrict:
-        """Transforms `CallbackMap` to `CallbackMapStrict`."""
-
-        callback_map_result = []
-
-        for key, value in callback_map:
-            if isinstance(value, type):
-                validator = (lambda tp: lambda v: isinstance(v, tp))(value)
-            elif isinstance(value, list):
-                validator = cls.transform_to_callbacks(value)
-            elif not callable(value):
-                validator = (lambda val: lambda v: val == v)(value)
-            else:
-                validator = value
-            callback_map_result.append((key, validator))
-
-        return callback_map_result
-
-    @staticmethod
-    async def run_validator(value: typing.Any, validator: Validator) -> bool:
-        """Run async or sync validator."""
-
-        with suppress(BaseException):
-            result = validator(value)
-            if inspect.isawaitable(result):
-                result = await result
-            return result
-
-        return False
-
-    @classmethod
-    async def match(cls, callback_data: dict[str, typing.Any], callback_map: CallbackMapStrict) -> bool:
-        """Matches callback_data with callback_map recursively."""
-
-        for key, validator in callback_map:
-            if key not in callback_data:
-                return False
-
-            if isinstance(validator, list):
-                if not (
-                    isinstance(callback_data[key], dict) and await cls.match(callback_data[key], validator)
-                ):
-                    return False
-
-            elif not await cls.run_validator(callback_data[key], validator):
-                return False
-
-        return True
-
-    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
-        callback_data = event.decode_callback_data().unwrap_or_none()
-        if callback_data is None:
-            return False
-        if await self.match(callback_data, self.mapping):
-            ctx.update(callback_data)
-            return True
-        return False
-
-
-class CallbackDataEq(CallbackQueryDataRule):
-    def __init__(self, value: str, /) -> None:
-        self.value = value
-
-    def check(self, event: CallbackQuery) -> bool:
-        return event.data.unwrap() == self.value
-
-
-class CallbackDataJsonEq(CallbackQueryDataRule):
-    def __init__(self, d: dict[str, typing.Any], /) -> None:
-        self.d = d
-
-    def check(self, event: CallbackQuery) -> bool:
-        return event.decode_callback_data().unwrap_or_none() == self.d
-
-
-class CallbackDataJsonModel(CallbackQueryDataRule):
-    def __init__(
-        self,
-        model: type[msgspec.Struct] | type[DataclassInstance],
-        *,
-        alias: str | None = None,
-    ) -> None:
-        self.model = model
-        self.alias = alias or "data"
-
-    def check(self, event: CallbackQuery, ctx: Context) -> bool:
-        with suppress(BaseException):
-            ctx.set(self.alias, decoder.decode(event.data.unwrap().encode(), type=self.model))
-            return True
-        return False
-
-
-class CallbackDataMarkup(CallbackQueryDataRule):
-    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
-        self.patterns = Markup(patterns).patterns
-
-    def check(self, event: CallbackQuery, ctx: Context) -> bool:
-        return check_string(self.patterns, event.data.unwrap(), ctx)
-
-
-__all__ = (
+import abc
+import inspect
+import typing
+from contextlib import suppress
+
+from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule, CheckResult
+from telegrinder.bot.rules.payload import (
+    PayloadEqRule,
+    PayloadJsonEqRule,
+    PayloadMarkupRule,
+    PayloadModelRule,
+)
+from telegrinder.tools.adapter.event import EventAdapter
+from telegrinder.types.enums import UpdateType
+
+CallbackQuery: typing.TypeAlias = CallbackQueryCute
+Validator: typing.TypeAlias = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
+MapDict: typing.TypeAlias = dict[str, "typing.Any | type[typing.Any] | Validator | list[MapDict] | MapDict"]
+CallbackMap: typing.TypeAlias = list[tuple[str, "typing.Any | type[typing.Any] | Validator | CallbackMap"]]
+CallbackMapStrict: typing.TypeAlias = list[tuple[str, "Validator | CallbackMapStrict"]]
+CallbackDataEq: typing.TypeAlias = PayloadEqRule
+CallbackDataJsonEq: typing.TypeAlias = PayloadJsonEqRule
+CallbackDataMarkup: typing.TypeAlias = PayloadMarkupRule
+CallbackDataJsonModel: typing.TypeAlias = PayloadModelRule
+
+
+class CallbackQueryRule(
+    ABCRule[CallbackQuery],
+    abc.ABC,
+    adapter=EventAdapter(UpdateType.CALLBACK_QUERY, CallbackQuery),
+):
+    @abc.abstractmethod
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
+
+
+class HasData(CallbackQueryRule):
+    def check(self, event: CallbackQuery) -> bool:
+        return bool(event.data)
+
+
+class CallbackQueryDataRule(CallbackQueryRule, abc.ABC, requires=[HasData()]):
+    pass
+
+
+class CallbackDataMap(CallbackQueryDataRule):
+    def __init__(self, mapping: MapDict, /) -> None:
+        self.mapping = self.transform_to_callbacks(
+            self.transform_to_map(mapping),
+        )
+
+    @classmethod
+    def transform_to_map(cls, mapping: MapDict) -> CallbackMap:
+        """Transforms MapDict to CallbackMap."""
+        callback_map = []
+
+        for k, v in mapping.items():
+            if isinstance(v, dict):
+                v = cls.transform_to_map(v)
+            callback_map.append((k, v))
+
+        return callback_map
+
+    @classmethod
+    def transform_to_callbacks(cls, callback_map: CallbackMap) -> CallbackMapStrict:
+        """Transforms `CallbackMap` to `CallbackMapStrict`."""
+        callback_map_result = []
+
+        for key, value in callback_map:
+            if isinstance(value, type):
+                validator = (lambda tp: lambda v: isinstance(v, tp))(value)
+            elif isinstance(value, list):
+                validator = cls.transform_to_callbacks(value)
+            elif not callable(value):
+                validator = (lambda val: lambda v: val == v)(value)
+            else:
+                validator = value
+            callback_map_result.append((key, validator))
+
+        return callback_map_result
+
+    @staticmethod
+    async def run_validator(value: typing.Any, validator: Validator) -> bool:
+        """Run async or sync validator."""
+        with suppress(BaseException):
+            result = validator(value)
+            if inspect.isawaitable(result):
+                result = await result
+            return result
+
+        return False
+
+    @classmethod
+    async def match(cls, callback_data: dict[str, typing.Any], callback_map: CallbackMapStrict) -> bool:
+        """Matches callback_data with callback_map recursively."""
+        for key, validator in callback_map:
+            if key not in callback_data:
+                return False
+
+            if isinstance(validator, list):
+                if not (isinstance(callback_data[key], dict) and await cls.match(callback_data[key], validator)):
+                    return False
+
+            elif not await cls.run_validator(callback_data[key], validator):
+                return False
+
+        return True
+
+    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+        callback_data = event.decode_data().unwrap_or_none()
+        if callback_data is None:
+            return False
+        if await self.match(callback_data, self.mapping):
+            ctx.update(callback_data)
+            return True
+        return False
+
+
+__all__ = (
     "CallbackDataEq",
     "CallbackDataJsonEq",
     "CallbackDataJsonModel",
@@ -166,5 +125,5 @@ __all__ = (
     "CallbackDataMarkup",
     "CallbackQueryDataRule",
     "CallbackQueryRule",
-    "HasData",
-)
+    "HasData",
+)

telegrinder/bot/rules/chat_join.py

@@ -1,46 +1,48 @@
-import abc
-import typing
-
-from telegrinder.bot.cute_types import ChatJoinRequestCute
-from telegrinder.bot.rules.adapter import EventAdapter
-from telegrinder.types.enums import UpdateType
-
-from .abc import ABCRule, CheckResult
-
-ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
-
-
-class ChatJoinRequestRule(ABCRule[ChatJoinRequest], requires=[]):
-    adapter: EventAdapter[ChatJoinRequest] = EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest)
-
-    @abc.abstractmethod
-    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
-
-
-class HasInviteLink(ChatJoinRequestRule):
-    def check(self, event: ChatJoinRequest) -> bool:
-        return bool(event.invite_link)
-
-
-class InviteLinkName(ChatJoinRequestRule, requires=[HasInviteLink()]):
-    def __init__(self, name: str, /) -> None:
-        self.name = name
-
-    def check(self, event: ChatJoinRequest) -> bool:
-        return event.invite_link.unwrap().name.unwrap_or_none() == self.name
-
-
-class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
-    def __init__(self, creator_id: int, /) -> None:
-        self.creator_id = creator_id
-
-    def check(self, event: ChatJoinRequest) -> bool:
-        return event.invite_link.unwrap().creator.id == self.creator_id
-
-
-__all__ = (
+import abc
+import typing
+
+from telegrinder.bot.cute_types import ChatJoinRequestCute
+from telegrinder.tools.adapter.event import EventAdapter
+from telegrinder.types.enums import UpdateType
+
+from .abc import ABCRule, CheckResult
+
+ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
+
+
+class ChatJoinRequestRule(
+    ABCRule[ChatJoinRequest],
+    abc.ABC,
+    adapter=EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest),
+):
+    @abc.abstractmethod
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
+
+
+class HasInviteLink(ChatJoinRequestRule):
+    def check(self, event: ChatJoinRequest) -> bool:
+        return bool(event.invite_link)
+
+
+class InviteLinkName(ChatJoinRequestRule, requires=[HasInviteLink()]):
+    def __init__(self, name: str, /) -> None:
+        self.name = name
+
+    def check(self, event: ChatJoinRequest) -> bool:
+        return event.invite_link.unwrap().name.unwrap_or_none() == self.name
+
+
+class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
+    def __init__(self, creator_id: int, /) -> None:
+        self.creator_id = creator_id
+
+    def check(self, event: ChatJoinRequest) -> bool:
+        return event.invite_link.unwrap().creator.id == self.creator_id
+
+
+__all__ = (
     "ChatJoinRequestRule",
     "HasInviteLink",
     "InviteLinkByCreator",
-    "InviteLinkName",
-)
+    "InviteLinkName",
+)

telegrinder/bot/rules/command.py

@@ -1,126 +1,126 @@
-import dataclasses
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.command import CommandInfo, single_split
-from telegrinder.node.me import Me
-from telegrinder.node.source import Source
-from telegrinder.types.enums import ChatType
-
-from .abc import ABCRule
-
-Validator: typing.TypeAlias = typing.Callable[[str], typing.Any | None]
-
-
-@dataclasses.dataclass(frozen=True, slots=True)
-class Argument:
-    name: str
-    validators: list[Validator] = dataclasses.field(default_factory=lambda: [])
-    optional: bool = dataclasses.field(default=False, kw_only=True)
-
-    def check(self, data: str) -> typing.Any | None:
-        for validator in self.validators:
-            data = validator(data)  # type: ignore
-            if data is None:
-                return None
-        return data
-
-
-class Command(ABCRule):
-    def __init__(
-        self,
-        names: str | typing.Iterable[str],
-        *arguments: Argument,
-        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:
-            if text.startswith(prefix):
-                return text.removeprefix(prefix)
-        return None
-
-    def parse_argument(
-        self,
-        arguments: list[Argument],
-        data_s: str,
-        new_s: str,
-        s: str,
-    ) -> dict | None:
-        argument = arguments[0]
-        data = argument.check(data_s)
-        if data is None and not argument.optional:
-            return None
-
-        if data is None:
-            return self.parse_arguments(arguments[1:], s)
-
-        with_argument = self.parse_arguments(arguments[1:], new_s)
-        if with_argument is not None:
-            return {argument.name: data, **with_argument}
-
-        if not argument.optional:
-            return None
-
-        return self.parse_arguments(arguments[1:], s)
-
-    def parse_arguments(self, arguments: list[Argument], s: str) -> dict[str, typing.Any] | None:
-        if not arguments:
-            return {} if not s else None
-
-        if self.lazy:
-            return self.parse_argument(arguments, *single_split(s, self.separator), s)
-
-        all_split = s.split(self.separator)
-        for i in range(1, len(all_split) + 1):
-            ctx = self.parse_argument(
-                arguments,
-                self.separator.join(all_split[:i]),
-                self.separator.join(all_split[i:]),
-                s,
-            )
-            if ctx is not None:
-                return ctx
-
-        return None
-
-    def check(self, command: CommandInfo, me: Me, src: Source, ctx: Context) -> bool:
-        name = self.remove_prefix(command.name)
-        if name is None:
-            return False
-
-        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 command.arguments
-
-        result = self.parse_arguments(list(self.arguments), command.arguments)
-        if result is None:
-            return False
-
-        ctx.update(result)
-        return True
-
-
-__all__ = ("Argument", "Command", "single_split")
+import dataclasses
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.command import CommandInfo, single_split
+from telegrinder.node.me import Me
+from telegrinder.node.source import ChatSource
+from telegrinder.types.enums import ChatType
+
+from .abc import ABCRule
+
+type Validator = typing.Callable[[str], typing.Any | None]
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Argument:
+    name: str
+    validators: list[Validator] = dataclasses.field(default_factory=lambda: [])
+    optional: bool = dataclasses.field(default=False, kw_only=True)
+
+    def check(self, data: str) -> typing.Any | None:
+        for validator in self.validators:
+            data = validator(data)  # type: ignore
+            if data is None:
+                return None
+        return data
+
+
+class Command(ABCRule):
+    def __init__(
+        self,
+        names: str | typing.Iterable[str],
+        *arguments: Argument,
+        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:
+            if text.startswith(prefix):
+                return text.removeprefix(prefix)
+        return None
+
+    def parse_argument(
+        self,
+        arguments: list[Argument],
+        data_s: str,
+        new_s: str,
+        s: str,
+    ) -> dict | None:
+        argument = arguments[0]
+        data = argument.check(data_s)
+        if data is None and not argument.optional:
+            return None
+
+        if data is None:
+            return self.parse_arguments(arguments[1:], s)
+
+        with_argument = self.parse_arguments(arguments[1:], new_s)
+        if with_argument is not None:
+            return {argument.name: data, **with_argument}
+
+        if not argument.optional:
+            return None
+
+        return self.parse_arguments(arguments[1:], s)
+
+    def parse_arguments(self, arguments: list[Argument], s: str) -> dict[str, typing.Any] | None:
+        if not arguments:
+            return {} if not s else None
+
+        if self.lazy:
+            return self.parse_argument(arguments, *single_split(s, self.separator), s)
+
+        all_split = s.split(self.separator)
+        for i in range(1, len(all_split) + 1):
+            ctx = self.parse_argument(
+                arguments,
+                self.separator.join(all_split[:i]),
+                self.separator.join(all_split[i:]),
+                s,
+            )
+            if ctx is not None:
+                return ctx
+
+        return None
+
+    def check(self, command: CommandInfo, me: Me, chat: ChatSource, ctx: Context) -> bool:
+        name = self.remove_prefix(command.name)
+        if name is None:
+            return False
+
+        if name not in self.names:
+            return False
+
+        if not command.mention and self.mention_needed_in_chat and 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 command.arguments
+
+        result = self.parse_arguments(list(self.arguments), command.arguments)
+        if result is None:
+            return False
+
+        ctx.update(result)
+        return True
+
+
+__all__ = ("Argument", "Command", "single_split")