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

telegrinder/bot/rules/markup.py

@@ -1,43 +1,42 @@
-import typing
-
-import vbml
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.text import Text
-from telegrinder.tools.global_context.telegrinder_ctx import TelegrinderContext
-
-from .abc import ABCRule
-
-PatternLike: typing.TypeAlias = str | vbml.Pattern
-global_ctx: typing.Final[TelegrinderContext] = TelegrinderContext()
-
-
-def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
-    for pattern in patterns:
-        match global_ctx.vbml_patcher.check(pattern, s):
-            case None | False:
-                continue
-            case {**response}:
-                ctx |= response
-        return True
-    return False
-
-
-class Markup(ABCRule):
-    """Markup Language. See the [vbml documentation](https://github.com/tesseradecade/vbml/blob/master/docs/index.md)."""
-
-    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
-        if not isinstance(patterns, list):
-            patterns = [patterns]
-        self.patterns = [
-            vbml.Pattern(pattern, flags=global_ctx.vbml_pattern_flags)
-            if isinstance(pattern, str)
-            else pattern
-            for pattern in patterns
-        ]
-
-    def check(self, text: Text, ctx: Context) -> bool:
-        return check_string(self.patterns, text, ctx)
-
-
-__all__ = ("Markup", "check_string")
+import typing
+
+import vbml
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.either import Either
+from telegrinder.node.text import Caption, Text
+from telegrinder.tools.global_context.telegrinder_ctx import TelegrinderContext
+
+from .abc import ABCRule
+
+type PatternLike = str | vbml.Pattern
+global_ctx: typing.Final[TelegrinderContext] = TelegrinderContext()
+
+
+def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
+    for pattern in patterns:
+        match global_ctx.vbml_patcher.check(pattern, s):
+            case None | False:
+                continue
+            case {**response}:
+                ctx |= response
+        return True
+    return False
+
+
+class Markup(ABCRule):
+    """Markup Language. See the [vbml documentation](https://github.com/tesseradecade/vbml/blob/master/docs/index.md)."""
+
+    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
+        if not isinstance(patterns, list):
+            patterns = [patterns]
+        self.patterns = [
+            vbml.Pattern(pattern, flags=global_ctx.vbml_pattern_flags) if isinstance(pattern, str) else pattern
+            for pattern in patterns
+        ]
+
+    def check(self, text: Either[Text, Caption], ctx: Context) -> bool:
+        return check_string(self.patterns, text, ctx)
+
+
+__all__ = ("Markup", "check_string")

telegrinder/bot/rules/mention.py

@@ -1,14 +1,14 @@
-from telegrinder.types.enums import MessageEntityType
-
-from .message import Message, MessageRule
-from .text import HasText
-
-
-class HasMention(MessageRule, requires=[HasText()]):
-    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())
-
-
-__all__ = ("HasMention",)
+from telegrinder.types.enums import MessageEntityType
+
+from .message import Message, MessageRule
+from .text import HasText
+
+
+class HasMention(MessageRule, requires=[HasText()]):
+    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())
+
+
+__all__ = ("HasMention",)

telegrinder/bot/rules/message.py

@@ -1,17 +1,15 @@
-import abc
-import typing
-
-from telegrinder.types.objects import Message as MessageEvent
-
-from .abc import ABCRule, CheckResult, Message
-from .adapter import EventAdapter
-
-
-class MessageRule(ABCRule[Message], abc.ABC):
-    adapter: EventAdapter[Message] = EventAdapter(MessageEvent, Message)
-
-    @abc.abstractmethod
-    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
-
-
-__all__ = ("MessageRule",)
+import abc
+import typing
+
+from telegrinder.tools.adapter.event import EventAdapter
+from telegrinder.types.objects import Message as MessageEvent
+
+from .abc import ABCRule, CheckResult, Message
+
+
+class MessageRule(ABCRule[Message], abc.ABC, adapter=EventAdapter(MessageEvent, Message)):
+    @abc.abstractmethod
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
+
+
+__all__ = ("MessageRule",)

telegrinder/bot/rules/message_entities.py

@@ -1,35 +1,33 @@
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.types.enums import MessageEntityType
-from telegrinder.types.objects import MessageEntity
-
-from .message import Message, MessageRule
-
-Entity: typing.TypeAlias = str | MessageEntityType
-
-
-class HasEntities(MessageRule):
-    def check(self, message: Message) -> bool:
-        return bool(message.entities)
-
-
-class MessageEntities(MessageRule, requires=[HasEntities()]):
-    def __init__(self, entities: Entity | list[Entity], /) -> None:
-        self.entities = [entities] if not isinstance(entities, list) else entities
-
-    def check(self, message: Message, ctx: Context) -> bool:
-        message_entities: list[MessageEntity] = []
-        for entity in message.entities.unwrap():
-            for entity_type in self.entities:
-                if entity_type == entity.type:
-                    message_entities.append(entity)
-
-        if not message_entities:
-            return False
-
-        ctx.message_entities = message_entities
-        return True
-
-
-__all__ = ("HasEntities", "MessageEntities")
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.types.enums import MessageEntityType
+from telegrinder.types.objects import MessageEntity
+
+from .message import Message, MessageRule
+
+type Entity = str | MessageEntityType
+
+
+class HasEntities(MessageRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.entities)
+
+
+class MessageEntities(MessageRule, requires=[HasEntities()]):
+    def __init__(self, entities: Entity | list[Entity], /) -> None:
+        self.entities = [entities] if not isinstance(entities, list) else entities
+
+    def check(self, message: Message, ctx: Context) -> bool:
+        message_entities: list[MessageEntity] = []
+        for entity in message.entities.unwrap():
+            for entity_type in self.entities:
+                if entity_type == entity.type:
+                    message_entities.append(entity)
+
+        if not message_entities:
+            return False
+
+        ctx.message_entities = message_entities
+        return True
+
+
+__all__ = ("HasEntities", "MessageEntities")

telegrinder/bot/rules/node.py

@@ -1,27 +1,33 @@
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.base 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)  # type: ignore
-
-    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",)
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.base import IsNode, NodeType, is_node
+from telegrinder.tools.adapter.node import NodeAdapter
+
+from .abc import ABCRule
+
+
+class NodeRule(ABCRule):
+    def __init__(self, *nodes: IsNode | tuple[str, IsNode]) -> None:
+        self.nodes: list[IsNode] = []
+        self.node_keys: list[str | None] = []
+
+        for binding in nodes:
+            node_key, node_t = binding if isinstance(binding, tuple) else (None, binding)
+            if not is_node(node_t):
+                continue
+            self.nodes.append(node_t)
+            self.node_keys.append(node_key)
+
+    @property
+    def adapter(self) -> NodeAdapter:
+        return NodeAdapter(*self.nodes)
+
+    def check(self, resolved_nodes: tuple[NodeType, ...], 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/payload.py

@@ -0,0 +1,81 @@
+import typing
+from contextlib import suppress
+from functools import cached_property
+
+import msgspec
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.markup import Markup, PatternLike, check_string
+from telegrinder.msgspec_json import loads
+from telegrinder.node.base import Node
+from telegrinder.node.payload import Payload, PayloadData
+from telegrinder.tools.callback_data_serilization.abc import ABCDataSerializer, ModelType
+from telegrinder.tools.callback_data_serilization.json_ser import JSONSerializer
+
+
+class PayloadRule[Data](ABCRule):
+    def __init__(
+        self,
+        data_type: type[Data],
+        serializer: type[ABCDataSerializer[Data]],
+        *,
+        alias: str | None = None,
+    ) -> None:
+        self.data_type = data_type
+        self.serializer = serializer
+        self.alias = alias or "data"
+
+    @cached_property
+    def required_nodes(self) -> dict[str, type[Node]]:
+        return {"payload": PayloadData[self.data_type, self.serializer]}  # type: ignore
+
+    def check(self, payload: PayloadData[Data], context: Context) -> typing.Literal[True]:
+        context.set(self.alias, payload)
+        return True
+
+
+class PayloadModelRule[Model: ModelType](PayloadRule[Model]):
+    def __init__(
+        self,
+        model_t: type[Model],
+        *,
+        serializer: type[ABCDataSerializer[Model]] | None = None,
+        alias: str | None = None,
+    ) -> None:
+        super().__init__(model_t, serializer or JSONSerializer, alias=alias or "model")
+
+
+class PayloadEqRule(ABCRule):
+    def __init__(self, payloads: str | list[str], /) -> None:
+        self.payloads = [payloads] if isinstance(payloads, str) else payloads
+
+    def check(self, payload: Payload) -> bool:
+        return any(p == payload for p in self.payloads)
+
+
+class PayloadMarkupRule(ABCRule):
+    def __init__(self, pattern: PatternLike | list[PatternLike], /) -> None:
+        self.patterns = Markup(pattern).patterns
+
+    def check(self, payload: Payload, context: Context) -> bool:
+        return check_string(self.patterns, payload, context)
+
+
+class PayloadJsonEqRule(ABCRule):
+    def __init__(self, payload: dict[str, typing.Any], /) -> None:
+        self.payload = payload
+
+    def check(self, payload: Payload) -> bool:
+        with suppress(msgspec.DecodeError, msgspec.ValidationError):
+            return self.payload == loads(payload)
+        return False
+
+
+__all__ = (
+    "PayloadEqRule",
+    "PayloadJsonEqRule",
+    "PayloadMarkupRule",
+    "PayloadModelRule",
+    "PayloadRule",
+)

telegrinder/bot/rules/payment_invoice.py

@@ -0,0 +1,29 @@
+import abc
+import typing
+
+from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
+from telegrinder.bot.rules.abc import ABCRule, CheckResult
+from telegrinder.tools.adapter.event import EventAdapter
+from telegrinder.types.enums import Currency, UpdateType
+
+PreCheckoutQuery: typing.TypeAlias = PreCheckoutQueryCute
+
+
+class PaymentInvoiceRule(
+    ABCRule[PreCheckoutQuery],
+    abc.ABC,
+    adapter=EventAdapter(UpdateType.PRE_CHECKOUT_QUERY, PreCheckoutQuery),
+):
+    @abc.abstractmethod
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
+
+
+class PaymentInvoiceCurrency(PaymentInvoiceRule):
+    def __init__(self, currency: str | Currency, /) -> None:
+        self.currency = currency
+
+    def check(self, query: PreCheckoutQuery) -> bool:
+        return self.currency == query.currency
+
+
+__all__ = ("PaymentInvoiceCurrency", "PaymentInvoiceRule")

telegrinder/bot/rules/regex.py

@@ -1,37 +1,36 @@
-import re
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.text import Text
-
-from .abc import ABCRule
-
-PatternLike: typing.TypeAlias = str | typing.Pattern[str]
-
-
-class Regex(ABCRule):
-    def __init__(self, regexp: PatternLike | list[PatternLike]) -> None:
-        self.regexp: list[re.Pattern[str]] = []
-        match regexp:
-            case re.Pattern() as pattern:
-                self.regexp.append(pattern)
-            case str(regex):
-                self.regexp.append(re.compile(regex))
-            case _:
-                self.regexp.extend(
-                    re.compile(regexp) if isinstance(regexp, str) else regexp for regexp in regexp
-                )
-
-    def check(self, text: Text, ctx: Context) -> bool:
-        for regexp in self.regexp:
-            response = re.match(regexp, text)
-            if response is not None:
-                if matches := response.groupdict():
-                    ctx |= matches
-                else:
-                    ctx |= {"matches": response.groups() or (response.group(),)}
-                return True
-        return False
-
-
-__all__ = ("Regex",)
+import re
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.either import Either
+from telegrinder.node.text import Caption, Text
+
+from .abc import ABCRule
+
+type PatternLike = str | typing.Pattern[str]
+
+
+class Regex(ABCRule):
+    def __init__(self, regexp: PatternLike | list[PatternLike]) -> None:
+        self.regexp: list[re.Pattern[str]] = []
+        match regexp:
+            case re.Pattern() as pattern:
+                self.regexp.append(pattern)
+            case str(regex):
+                self.regexp.append(re.compile(regex))
+            case _:
+                self.regexp.extend(re.compile(regexp) if isinstance(regexp, str) else regexp for regexp in regexp)
+
+    def check(self, text: Either[Text, Caption], ctx: Context) -> bool:
+        for regexp in self.regexp:
+            response = re.match(regexp, text)
+            if response is not None:
+                if matches := response.groupdict():
+                    ctx |= matches
+                else:
+                    ctx |= {"matches": response.groups() or (response.group(),)}
+                return True
+        return False
+
+
+__all__ = ("Regex",)

telegrinder/bot/rules/rule_enum.py

@@ -1,72 +1,72 @@
-import dataclasses
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-
-from .abc import ABCRule, Update, check_rule
-from .func import FuncRule
-
-
-@dataclasses.dataclass(slots=True)
-class RuleEnumState:
-    name: str
-    rule: ABCRule
-    cls: type["RuleEnum"]
-
-    def __eq__(self, other: typing.Self) -> bool:
-        return self.cls == other.cls and self.name == other.name
-
-
-class RuleEnum(ABCRule):
-    __enum__: list[RuleEnumState]
-
-    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] = []
-
-        self = cls.__new__(cls)
-        self.__init__()
-
-        for attribute_name in new_attributes:
-            rules = getattr(cls, attribute_name)
-            attribute = RuleEnumState(attribute_name, rules, cls)
-
-            setattr(
-                self,
-                attribute.name,
-                self & FuncRule(lambda _, ctx: self.must_be_state(ctx, attribute)),  # type: ignore
-            )
-            enum_lst.append(attribute)
-
-        setattr(cls, "__enum__", enum_lst)
-
-    @classmethod
-    def save_state(cls, ctx: Context, enum: RuleEnumState) -> None:
-        ctx.update({cls.__class__.__name__ + "_state": enum})
-
-    @classmethod
-    def check_state(cls, ctx: Context) -> RuleEnumState | None:
-        return ctx.get(cls.__class__.__name__ + "_state")
-
-    @classmethod
-    def must_be_state(cls, ctx: Context, state: RuleEnumState) -> bool:
-        real_state = cls.check_state(ctx)
-        if not real_state:
-            return False
-        return real_state == state
-
-    async def check(self, event: Update, ctx: Context) -> bool:
-        if self.check_state(ctx):
-            return True
-
-        for enum in self.__enum__:
-            ctx_copy = ctx.copy()
-            if await check_rule(event.ctx_api, enum.rule, event, ctx_copy):
-                ctx.update(ctx_copy)
-                self.save_state(ctx, enum)
-                return True
-
-        return False
-
-
-__all__ = ("RuleEnum", "RuleEnumState")
+import dataclasses
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+
+from .abc import ABCRule, Update, check_rule
+from .func import FuncRule
+
+
+@dataclasses.dataclass(slots=True)
+class RuleEnumState:
+    name: str
+    rule: ABCRule
+    cls: type["RuleEnum"]
+
+    def __eq__(self, other: typing.Self) -> bool:
+        return self.cls == other.cls and self.name == other.name
+
+
+class RuleEnum(ABCRule):
+    __enum__: list[RuleEnumState]
+
+    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] = []
+
+        self = cls.__new__(cls)
+        self.__init__()
+
+        for attribute_name in new_attributes:
+            rules = getattr(cls, attribute_name)
+            attribute = RuleEnumState(attribute_name, rules, cls)
+
+            setattr(
+                self,
+                attribute.name,
+                self & FuncRule(lambda _, ctx: self.must_be_state(ctx, attribute)),  # type: ignore
+            )
+            enum_lst.append(attribute)
+
+        setattr(cls, "__enum__", enum_lst)
+
+    @classmethod
+    def save_state(cls, ctx: Context, enum: RuleEnumState) -> None:
+        ctx.update({cls.__class__.__name__ + "_state": enum})
+
+    @classmethod
+    def check_state(cls, ctx: Context) -> RuleEnumState | None:
+        return ctx.get(cls.__class__.__name__ + "_state")
+
+    @classmethod
+    def must_be_state(cls, ctx: Context, state: RuleEnumState) -> bool:
+        real_state = cls.check_state(ctx)
+        if not real_state:
+            return False
+        return real_state == state
+
+    async def check(self, event: Update, ctx: Context) -> bool:
+        if self.check_state(ctx):
+            return True
+
+        for enum in self.__enum__:
+            ctx_copy = ctx.copy()
+            if await check_rule(event.ctx_api, enum.rule, event, ctx_copy):
+                ctx.update(ctx_copy)
+                self.save_state(ctx, enum)
+                return True
+
+        return False
+
+
+__all__ = ("RuleEnum", "RuleEnumState")