telegrinder 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

telegrinder/bot/rules/abc.py

@@ -1,52 +1,21 @@
-import inspect
 from abc import ABC, abstractmethod
+from collections import deque
 from functools import cached_property
 
 import typing_extensions as typing
 
-from telegrinder.bot.cute_types import MessageCute, UpdateCute
+from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.process import check_rule
-from telegrinder.node.base import NodeType, get_nodes, is_node
-from telegrinder.tools.adapter import ABCAdapter
-from telegrinder.tools.adapter.node import Event
-from telegrinder.tools.adapter.raw_update import RawUpdateAdapter
-from telegrinder.tools.i18n.abc import ABCTranslator
-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, contravariant=True)
+from telegrinder.node.base import IsNode, get_nodes
+from telegrinder.tools.fullname import fullname
+from telegrinder.types.objects import Update
 
 type CheckResult = bool | typing.Awaitable[bool]
 
-Message: typing.TypeAlias = MessageCute
-Update: typing.TypeAlias = UpdateCute
-
-
-def with_caching_translations(func: typing.Callable[..., typing.Any]):
-    """Should be used as decorator for .translate method. Caches rule translations."""
 
-    async def wrapper(self: "ABCRule", translator: ABCTranslator):
-        if translation := get_cached_translation(self, translator.locale):
-            return translation
-        translation = await func(self, translator)
-        cache_translation(self, translator.locale, translation)
-        return translation
-
-    return wrapper
-
-
-class ABCRule(ABC, typing.Generic[AdaptTo]):
-    adapter: ABCAdapter[UpdateObject, AdaptTo]
-    requires: list["ABCRule"] = []
+class ABCRule(ABC):
+    requires: deque["ABCRule"] = deque()
 
     if typing.TYPE_CHECKING:
 
@@ -54,7 +23,6 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
         def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult:
             pass
     else:
-        adapter = RawUpdateAdapter()
 
         @abstractmethod
         def check(self, *args, **kwargs):
@@ -63,59 +31,41 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
     def __init_subclass__(
         cls,
         *,
-        requires: list["ABCRule"] | None = None,
-        adapter: ABCAdapter[UpdateObject, AdaptTo] | None = None,
+        requires: typing.Iterable["ABCRule"] | None = None,
     ) -> None:
         """Merges requirements from inherited classes and rule-specific requirements."""
-        if adapter is not None:
-            cls.adapter = adapter
-
-        requirements = []
-        for base in inspect.getmro(cls):
+        requirements = list[ABCRule]()
+        for base in cls.__mro__:
             if issubclass(base, ABCRule) and base != cls:
-                requirements.extend(base.requires or ())  # type: ignore
+                requirements.extend(base.requires or ())
 
         requirements.extend(requires or ())
-        cls.requires = list(dict.fromkeys(requirements))
-
-    def __and__(self, other: "ABCRule") -> "AndRule":
-        """And Rule.
+        cls.requires = deque(dict.fromkeys(requirements))
 
-        ```python
-        rule = HasText() & HasCaption()
-        rule #> AndRule(HasText(), HasCaption()) -> True if all rules in an AndRule are True, otherwise False.
-        ```
-        """
+    def __and__(self, other: object, /) -> "AndRule":
+        if not isinstance(other, ABCRule):
+            return NotImplemented
         return AndRule(self, other)
 
-    def __or__(self, other: "ABCRule") -> "OrRule":
-        """Or Rule.
+    def __iadd__(self, other: object, /) -> "AndRule":
+        return self.__and__(other)
 
-        ```python
-        rule = HasText() | HasCaption()
-        rule #> OrRule(HasText(), HasCaption()) -> True if any rule in an OrRule are True, otherwise False.
-        ```
-        """
+    def __or__(self, other: object, /) -> "OrRule":
+        if not isinstance(other, ABCRule):
+            return NotImplemented
         return OrRule(self, other)
 
-    def __invert__(self) -> "NotRule":
-        """Not Rule.
+    def __ior__(self, other: object, /) -> "OrRule":
+        return self.__or__(other)
 
-        ```python
-        rule = ~HasText()
-        rule # NotRule(HasText()) -> True if rule returned False, otherwise False.
-        ```
-        """
+    def __invert__(self) -> "NotRule":
         return NotRule(self)
 
     def __repr__(self) -> str:
-        return "<{}: adapter={!r}>".format(
-            self.__class__.__name__,
-            self.adapter,
-        )
+        return "<{}, requires={!r}>".format(fullname(self), self.requires)
 
     @cached_property
-    def required_nodes(self) -> dict[str, type[NodeType]]:
+    def required_nodes(self) -> dict[str, IsNode]:
         return get_nodes(self.check)
 
     def as_optional(self) -> "ABCRule":
@@ -124,54 +74,18 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
     def should_fail(self) -> "ABCRule":
         return self & Never()
 
-    async def bounding_check(
-        self,
-        ctx: Context,
-        *,
-        adapted_value: AdaptTo,
-        node_col: "NodeCollection | None" = None,
-    ) -> bool:
-        bound_check_rule = self.check
-        kw = {}
-        node_col_values = node_col.values if node_col is not None else {}
-        temp_ctx = get_default_args(bound_check_rule) | ctx
-
-        for i, (k, v) in enumerate(get_annotations(bound_check_rule).items()):
-            if (isinstance(adapted_value, Event) and i == 0) or (  # First arg is Event
-                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."
-                )
-
-        result = bound_check_rule(**kw)  # type: ignore
-        if inspect.isawaitable(result):
-            result = await result
-        return result
-
-    async def translate(self, translator: ABCTranslator) -> typing.Self:
-        return self
-
 
 class AndRule(ABCRule):
     def __init__(self, *rules: ABCRule) -> None:
         self.rules = rules
 
-    async def check(self, event: Update, ctx: Context) -> bool:
+    async def check(self, event: Update, api: API, ctx: Context) -> bool:
         ctx_copy = ctx.copy()
+
         for rule in self.rules:
-            if not await check_rule(event.ctx_api, rule, event, ctx_copy):
+            if not await check_rule(api, rule, event, ctx_copy):
                 return False
+
         ctx |= ctx_copy
         return True
 
@@ -180,12 +94,14 @@ class OrRule(ABCRule):
     def __init__(self, *rules: ABCRule) -> None:
         self.rules = rules
 
-    async def check(self, event: Update, ctx: Context) -> bool:
+    async def check(self, event: Update, api: API, ctx: Context) -> bool:
         for rule in self.rules:
             ctx_copy = ctx.copy()
-            if await check_rule(event.ctx_api, rule, event, ctx_copy):
+
+            if await check_rule(api, rule, event, ctx_copy):
                 ctx |= ctx_copy
                 return True
+
         return False
 
 
@@ -193,18 +109,22 @@ class NotRule(ABCRule):
     def __init__(self, rule: ABCRule) -> None:
         self.rule = rule
 
-    async def check(self, event: Update, ctx: Context) -> bool:
+    async def check(self, event: Update, api: API, ctx: Context) -> bool:
         ctx_copy = ctx.copy()
-        return not await check_rule(event.ctx_api, self.rule, event, ctx_copy)
+        return not await check_rule(api, self.rule, event, ctx_copy)
 
 
 class Never(ABCRule):
-    async def check(self) -> typing.Literal[False]:
+    """Neutral element for `|` (OrRule)."""
+
+    def check(self) -> typing.Literal[False]:
         return False
 
 
 class Always(ABCRule):
-    async def check(self) -> typing.Literal[True]:
+    """Neutral element for `&` (AndRule)."""
+
+    def check(self) -> typing.Literal[True]:
         return True
 
 
@@ -216,5 +136,5 @@ __all__ = (
     "Never",
     "NotRule",
     "OrRule",
-    "with_caching_translations",
+    "check_rule",
 )

telegrinder/bot/rules/callback_data.py

@@ -1,76 +1,56 @@
 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.abc import ABCRule
 from telegrinder.bot.rules.payload import (
     PayloadEqRule,
     PayloadJsonEqRule,
     PayloadMarkupRule,
     PayloadModelRule,
 )
-from telegrinder.tools.adapter.event import EventAdapter
-from telegrinder.types.enums import UpdateType
+from telegrinder.tools.aio import maybe_awaitable
+
+type Validator = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
+type CallbackMap = dict[str, typing.Any | type[typing.Any] | Validator | CallbackMap]
+type CallbackMapStrict = dict[str, Validator | CallbackMapStrict]
 
 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):
+class HasData(ABCRule):
     def check(self, event: CallbackQuery) -> bool:
         return bool(event.data)
 
 
-class CallbackQueryDataRule(CallbackQueryRule, abc.ABC, requires=[HasData()]):
+class CallbackQueryDataRule(ABCRule, 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
+    def __init__(self, mapping: CallbackMap, /, *, allow_extra_fields: bool = False) -> None:
+        """Callback data map validation.
+        :param mapping: A callback data mapping with validators.
+        :param allow_extra_fields: Allows extra fields in a callback query data.
+        """
+        self.mapping = self.transform_to_callbacks(mapping)
+        self.allow_extra_fields = allow_extra_fields
 
     @classmethod
     def transform_to_callbacks(cls, callback_map: CallbackMap) -> CallbackMapStrict:
         """Transforms `CallbackMap` to `CallbackMapStrict`."""
         callback_map_result = []
 
-        for key, value in callback_map:
+        for key, value in callback_map.items():
             if isinstance(value, type):
                 validator = (lambda tp: lambda v: isinstance(v, tp))(value)
-            elif isinstance(value, list):
+            elif isinstance(value, dict):
                 validator = cls.transform_to_callbacks(value)
             elif not callable(value):
                 validator = (lambda val: lambda v: val == v)(value)
@@ -78,27 +58,23 @@ class CallbackDataMap(CallbackQueryDataRule):
                 validator = value
             callback_map_result.append((key, validator))
 
-        return callback_map_result
+        return dict(callback_map_result)
 
     @staticmethod
     async def run_validator(value: typing.Any, validator: Validator) -> bool:
-        """Run async or sync validator."""
+        """Runs sync/async validator."""
         with suppress(BaseException):
-            result = validator(value)
-            if inspect.isawaitable(result):
-                result = await result
-            return result
-
+            return await maybe_awaitable(validator(value))
         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:
+        """Matches `callback_data` with `callback_map` recursively."""
+        for key, validator in callback_map.items():
             if key not in callback_data:
                 return False
 
-            if isinstance(validator, list):
+            if isinstance(validator, dict):
                 if not (isinstance(callback_data[key], dict) and await cls.match(callback_data[key], validator)):
                     return False
 
@@ -111,9 +87,14 @@ class CallbackDataMap(CallbackQueryDataRule):
         callback_data = event.decode_data().unwrap_or_none()
         if callback_data is None:
             return False
+
+        if not self.allow_extra_fields and self.mapping.keys() != callback_data.keys():
+            return False
+
         if await self.match(callback_data, self.mapping):
-            ctx.update(callback_data)
+            ctx.update({k: callback_data[k] for k in self.mapping})
             return True
+
         return False
 
 
@@ -124,6 +105,5 @@ __all__ = (
     "CallbackDataMap",
     "CallbackDataMarkup",
     "CallbackQueryDataRule",
-    "CallbackQueryRule",
     "HasData",
 )

telegrinder/bot/rules/chat_join.py

@@ -1,30 +1,17 @@
-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
+from telegrinder.bot.rules.abc import ABCRule
 
 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):
+class HasInviteLink(ABCRule):
     def check(self, event: ChatJoinRequest) -> bool:
         return bool(event.invite_link)
 
 
-class InviteLinkName(ChatJoinRequestRule, requires=[HasInviteLink()]):
+class InviteLinkName(ABCRule, requires=[HasInviteLink()]):
     def __init__(self, name: str, /) -> None:
         self.name = name
 
@@ -32,7 +19,7 @@ class InviteLinkName(ChatJoinRequestRule, requires=[HasInviteLink()]):
         return event.invite_link.unwrap().name.unwrap_or_none() == self.name
 
 
-class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
+class InviteLinkByCreator(ABCRule, requires=[HasInviteLink()]):
     def __init__(self, creator_id: int, /) -> None:
         self.creator_id = creator_id
 
@@ -40,9 +27,4 @@ class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
         return event.invite_link.unwrap().creator.id == self.creator_id
 
 
-__all__ = (
-    "ChatJoinRequestRule",
-    "HasInviteLink",
-    "InviteLinkByCreator",
-    "InviteLinkName",
-)
+__all__ = ("HasInviteLink", "InviteLinkByCreator", "InviteLinkName")

telegrinder/bot/rules/command.py

@@ -2,13 +2,12 @@ import dataclasses
 import typing
 
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
 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]
 
 
@@ -36,13 +35,16 @@ class Command(ABCRule):
         lazy: bool = False,
         validate_mention: bool = True,
         mention_needed_in_chat: bool = False,
+        ignore_case: bool = False,
     ) -> None:
-        self.names = [names] if isinstance(names, str) else names
+        names = [names] if isinstance(names, str) else names
+        self.names = [n.lower() for n in names] if ignore_case else names
         self.arguments = arguments
         self.prefixes = prefixes
         self.separator = separator
         self.lazy = lazy
         self.validate_mention = validate_mention
+        self.ignore_case = ignore_case
 
         # if true then we'll check for mention when message is from a group
         self.mention_needed_in_chat = mention_needed_in_chat
@@ -102,7 +104,9 @@ class Command(ABCRule):
         if name is None:
             return False
 
-        if name not in self.names:
+        target_name = name.lower() if self.ignore_case else name
+
+        if target_name not in self.names:
             return False
 
         if not command.mention and self.mention_needed_in_chat and chat.type is not ChatType.PRIVATE:

telegrinder/bot/rules/enum_text.py

@@ -1,15 +1,14 @@
 import enum
 
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.node.text import Text
 
-from .abc import ABCRule
-
 
 class EnumTextRule[T: enum.Enum](ABCRule):
     def __init__(self, enum_t: type[T], *, lower_case: bool = True) -> None:
         self.enum_t = enum_t
-        self.texts = list(
+        self.texts = set[str](
             map(
                 lambda x: x.value.lower() if lower_case else x.value,
                 self.enum_t,
@@ -23,7 +22,7 @@ class EnumTextRule[T: enum.Enum](ABCRule):
         raise KeyError("Enumeration is undefined.")
 
     def check(self, text: Text, ctx: Context) -> bool:
-        text = text.lower()  # type: ignore
+        text = text.lower()
         if text not in self.texts:
             return False
         ctx.enum_text = self.find(text)

telegrinder/bot/rules/func.py

@@ -1,28 +1,21 @@
-import inspect
 import typing
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.tools.adapter.abc import ABCAdapter
-from telegrinder.tools.adapter.raw_update import RawUpdateAdapter
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.tools.aio import maybe_awaitable
 from telegrinder.types.objects import Update
 
-from .abc import ABCRule, AdaptTo
 
-
-class FuncRule(ABCRule, typing.Generic[AdaptTo]):
+class FuncRule(ABCRule):
     def __init__(
         self,
-        func: typing.Callable[[AdaptTo, Context], typing.Awaitable[bool] | bool],
-        adapter: ABCAdapter[Update, AdaptTo] | None = None,
+        func: typing.Callable[[Update, Context], typing.Awaitable[bool] | bool],
+        /,
     ) -> None:
         self.func = func
-        self.adapter = adapter or RawUpdateAdapter()  # type: ignore
 
-    async def check(self, event: AdaptTo, ctx: Context) -> bool:
-        result = self.func(event, ctx)
-        if inspect.isawaitable(result):
-            result = await result
-        return result
+    async def check(self, update: Update, ctx: Context) -> bool:
+        return await maybe_awaitable(self.func(update, ctx))
 
 
 __all__ = ("FuncRule",)

telegrinder/bot/rules/fuzzy.py

@@ -1,16 +1,15 @@
 import difflib
 
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.node.text import Text
 
-from .abc import ABCRule
-
 
 class FuzzyText(ABCRule):
-    def __init__(self, texts: str | list[str], /, min_ratio: float = 0.7) -> None:
+    def __init__(self, texts: str | list[str], /, *, min_ratio: float = 0.7) -> None:
         if isinstance(texts, str):
             texts = [texts]
-        self.texts = texts
+        self.texts = set(texts)
         self.min_ratio = min_ratio
 
     def check(self, message_text: Text, ctx: Context) -> bool:

telegrinder/bot/rules/inline.py

@@ -1,32 +1,21 @@
-import abc
 import typing
 
 from telegrinder.bot.cute_types import InlineQueryCute
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.abc import ABCRule, CheckResult
-from telegrinder.tools.adapter.event import EventAdapter
-from telegrinder.types.enums import ChatType, UpdateType
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.enums import ChatType
 
 from .markup import Markup, PatternLike, check_string
 
 InlineQuery: typing.TypeAlias = InlineQueryCute
 
 
-class InlineQueryRule(
-    ABCRule[InlineQuery],
-    abc.ABC,
-    adapter=EventAdapter(UpdateType.INLINE_QUERY, InlineQuery),
-):
-    @abc.abstractmethod
-    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
-
-
-class HasLocation(InlineQueryRule):
+class HasLocation(ABCRule):
     def check(self, query: InlineQuery) -> bool:
         return bool(query.location)
 
 
-class InlineQueryChatType(InlineQueryRule):
+class InlineQueryChatType(ABCRule):
     def __init__(self, chat_type: ChatType, /) -> None:
         self.chat_type = chat_type
 
@@ -34,18 +23,18 @@ class InlineQueryChatType(InlineQueryRule):
         return query.chat_type.map(lambda x: x == self.chat_type).unwrap_or(False)
 
 
-class InlineQueryText(InlineQueryRule):
+class InlineQueryText(ABCRule):
     def __init__(self, texts: str | list[str], *, lower_case: bool = False) -> None:
-        self.texts = [
+        self.texts = {
             text.lower() if lower_case else text for text in ([texts] if isinstance(texts, str) else texts)
-        ]
+        }
         self.lower_case = lower_case
 
     def check(self, query: InlineQuery) -> bool:
         return (query.query.lower() if self.lower_case else query.query) in self.texts
 
 
-class InlineQueryMarkup(InlineQueryRule):
+class InlineQueryMarkup(ABCRule):
     def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
         self.patterns = Markup(patterns).patterns
 
@@ -57,6 +46,5 @@ __all__ = (
     "HasLocation",
     "InlineQueryChatType",
     "InlineQueryMarkup",
-    "InlineQueryRule",
     "InlineQueryText",
 )

telegrinder/bot/rules/integer.py

@@ -1,9 +1,8 @@
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.node import NodeRule
 from telegrinder.node.base import as_node
 from telegrinder.node.text import TextInteger
 
-from .abc import ABCRule
-from .node import NodeRule
-
 
 class IsInteger(NodeRule):
     def __init__(self) -> None: