telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/bot/rules/magic.py

@@ -0,0 +1,60 @@
+import typing
+from contextlib import suppress
+
+import kungfu
+
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node import EventNode
+from telegrinder.node.utils import is_node
+from telegrinder.tools.member_descriptor_proxy import MemberDescriptorProxy, evaluate_operations
+
+
+class Magic[R, **P = [R]](kungfu.F[R, P], ABCRule):
+    def __init__(
+        self,
+        field: R,
+        parent: typing.Any = None,
+    ) -> None:
+        if isinstance(field, MemberDescriptorProxy):
+            owner_cls, member_name, operations = field._objclass, field._member_name, field._operations
+            node = EventNode[owner_cls]
+            super().__init__(lambda obj: evaluate_operations(obj, member_name, operations))  # type: ignore
+
+        elif is_node(field):
+            node = field
+            super().__init__()  # type: ignore
+
+        else:
+            node = parent
+            super().__init__(field)  # type: ignore
+
+        self.node = node
+        self.required_nodes = dict(magic_value=node)
+
+    def check(self, magic_value: typing.Any) -> bool:
+        with suppress(kungfu.UnwrapError):
+            self(magic_value)  # type: ignore
+            return True
+
+        return False
+
+    def new(self, f: typing.Any, /) -> typing.Any:
+        return Magic(f, parent=self.node)
+
+    if typing.TYPE_CHECKING:
+
+        def then[T](self, g: typing.Callable[[R], T], /) -> "Magic[T, P]": ...
+
+        def ensure(
+            self,
+            chk: typing.Callable[[R], bool],
+            error: typing.Callable[[R], BaseException] | BaseException | str | None = None,
+        ) -> "Magic[R, P]": ...
+
+        def expect[T, Err](
+            self: kungfu.F[kungfu.Result[T, Err], P],
+            error: typing.Callable[[kungfu.Result[T, Err]], BaseException] | BaseException | str | None = None,
+        ) -> "Magic[T, P]": ...
+
+
+__all__ = ("Magic",)

telegrinder/bot/rules/markup.py

@@ -0,0 +1,51 @@
+import re
+import typing
+
+import vbml
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.nodes.text import Caption, Text
+from telegrinder.tools.global_context.builtin_context import TelegrinderContext
+
+type PatternLike = str | vbml.Pattern
+
+TELEGRINDER_CONTEXT: typing.Final = TelegrinderContext()
+
+
+def check_string(patterns: typing.Iterable[vbml.Pattern], s: str, ctx: Context) -> bool:
+    for pattern in patterns:
+        match TELEGRINDER_CONTEXT.vbml_patcher.check(pattern, s):
+            case {**response}:
+                ctx |= response
+                return True
+            case True:
+                return True
+            case _:
+                continue
+
+    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],
+        /,
+        *,
+        flags: re.RegexFlag | None = None,
+    ) -> None:
+        self.patterns = [
+            vbml.Pattern(text=pattern, flags=flags or TELEGRINDER_CONTEXT.vbml_pattern_flags)
+            if isinstance(pattern, str)
+            else pattern
+            for pattern in ([patterns] if not isinstance(patterns, list) else patterns)
+        ]
+
+    def check(self, text: Text | Caption, ctx: Context) -> bool:
+        return check_string(self.patterns, text, ctx)
+
+
+__all__ = ("Markup", "check_string")

telegrinder/bot/rules/media.py

@@ -0,0 +1,13 @@
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.cute_types.utils import MEDIA_TYPES
+from telegrinder.bot.rules.abc import ABCRule
+
+
+class IsMediaGroup(ABCRule):
+    def check(self, message: MessageCute) -> bool:
+        if not message.media_group_id:
+            return False
+        return message.content_type in MEDIA_TYPES
+
+
+__all__ = ("IsMediaGroup",)

telegrinder/bot/rules/mention.py

@@ -0,0 +1,15 @@
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.text import HasText
+from telegrinder.types.enums import MessageEntityType
+
+
+class HasMention(ABCRule, requires=[HasText()]):
+    def check(self, message: MessageCute) -> bool:
+        entities = message.entities.unwrap_or_none()
+        if not entities:
+            return False
+        return any(entity.type == MessageEntityType.MENTION for entity in entities)
+
+
+__all__ = ("HasMention",)

telegrinder/bot/rules/message_entities.py

@@ -0,0 +1,37 @@
+import typing
+
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.enums import MessageEntityType
+from telegrinder.types.objects import MessageEntity
+
+type Entity = str | MessageEntityType
+
+Message: typing.TypeAlias = MessageCute
+
+
+class HasEntities(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.entities)
+
+
+class MessageEntities(ABCRule, 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

@@ -0,0 +1,43 @@
+import typing
+
+from kungfu.library.monad.result import Ok
+from nodnod.agent.event_loop.agent import EventLoopAgent
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.compose import run_agent
+from telegrinder.node.utils import as_node
+
+if typing.TYPE_CHECKING:
+    from nodnod.agent.base import Agent
+
+type Node = typing.Any
+
+
+class NodeRule(ABCRule):
+    nodes: tuple[tuple[str | None, Node], ...]
+
+    def __init__(
+        self,
+        *nodes: Node | tuple[str, Node],
+        agent: type[Agent] | None = None,
+        roots: dict[type[typing.Any], typing.Any] | None = None,
+    ) -> None:
+        self.agent = (agent or EventLoopAgent).build(nodes=set(map(as_node, nodes)))
+        self.nodes = tuple((x if isinstance(x, tuple) else (None, x)) for x in nodes)
+        self.roots = roots
+
+    async def check(self, context: Context) -> bool:
+        async with run_agent(self.agent, context, roots=self.roots) as result:
+            match result:
+                case Ok(scope):
+                    for key, node in self.nodes:
+                        if key is not None and node in scope:
+                            context[key] = scope[node].value
+
+                    return True
+                case _:
+                    return False
+
+
+__all__ = ("NodeRule",)

telegrinder/bot/rules/payload.py

@@ -0,0 +1,89 @@
+import typing
+from contextlib import suppress
+
+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_utils.json import loads
+from telegrinder.node.nodes.payload import Payload, PayloadData
+from telegrinder.tools.serialization.abc import ABCDataSerializer, ModelType
+from telegrinder.tools.serialization.json_ser import JSONSerializer
+from telegrinder.tools.serialization.utils import get_model_serializer
+
+_ANY: typing.Final = object()
+
+
+class PayloadRule[Data](ABCRule):
+    def __init__(
+        self,
+        data_type: type[Data],
+        serializer: type[ABCDataSerializer[Data]] | None = None,
+        *,
+        alias: str | None = None,
+    ) -> None:
+        self.data_type = data_type
+        self.serializer = serializer or get_model_serializer(data_type) or JSONSerializer[typing.Any]
+        self.alias = alias or "data"
+        self.required_nodes = dict(payload=PayloadData[self.data_type, self.serializer])
+
+    def check(self, payload: PayloadData, context: Context) -> typing.Literal[True]:
+        context.set(self.alias, payload)
+        return True
+
+
+class PayloadModelRule[Model: ModelType](PayloadRule):
+    def __init__(
+        self,
+        model_t: type[Model],
+        /,
+        *,
+        payload: typing.Any = _ANY,
+        serializer: type[ABCDataSerializer[Model]] | None = None,
+        alias: str | None = None,
+    ) -> None:
+        super().__init__(model_t, serializer, alias=alias or "model")
+        self.payload = payload
+
+    def check(self, payload: PayloadData, context: Context) -> bool:
+        if self.payload is not _ANY and payload != self.payload:
+            return False
+
+        context.set(self.alias, payload)
+        return True
+
+
+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,14 @@
+from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.enums import Currency
+
+
+class PaymentInvoiceCurrency(ABCRule):
+    def __init__(self, currency: Currency, /) -> None:
+        self.currency = currency
+
+    def check(self, query: PreCheckoutQueryCute) -> bool:
+        return self.currency == query.currency
+
+
+__all__ = ("PaymentInvoiceCurrency",)

telegrinder/bot/rules/regex.py

@@ -0,0 +1,34 @@
+import re
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.nodes.text import Caption, Text
+
+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: 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

@@ -0,0 +1,71 @@
+import dataclasses
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule, check_rule
+from telegrinder.bot.rules.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 |= {cls.__name__ + "_state": enum}
+
+    @classmethod
+    def check_state(cls, ctx: Context) -> RuleEnumState | None:
+        return ctx.get(cls.__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, ctx: Context) -> bool:
+        if self.check_state(ctx):
+            return True
+
+        for enum in self.__enum__:
+            ctx_copy = ctx.copy()
+            if await check_rule(enum.rule, ctx_copy):
+                ctx |= ctx_copy
+                self.save_state(ctx, enum)
+                return True
+
+        return False
+
+
+__all__ = ("RuleEnum", "RuleEnumState")

telegrinder/bot/rules/start.py

@@ -0,0 +1,73 @@
+import base64
+import typing
+
+import kungfu
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.is_from import IsPrivate
+from telegrinder.bot.rules.markup import Markup
+from telegrinder.node.nodes.me import BotUsername
+from telegrinder.node.nodes.message_entities import MessageEntities
+from telegrinder.types.enums import MessageEntityType
+
+
+class StartCommand(
+    ABCRule,
+    requires=[
+        IsPrivate(),
+        Markup(
+            [
+                "/start <param>",
+                "/start",
+                "tg://resolve?domain=<bot_username>&start=<param>",
+            ]
+        ),
+    ],
+):
+    def __init__(
+        self,
+        validator: typing.Callable[[str], typing.Any | None] | None = None,
+        *,
+        deep_link: bool | None = None,
+        decode_deep_link_param: bool = False,
+        param_required: bool = False,
+        alias: str | None = None,
+    ) -> None:
+        self.param_required = param_required
+        self.validator = validator
+        self.alias = alias
+        self.deep_link = deep_link
+        self.decode_deep_link_param = decode_deep_link_param
+
+    def check(
+        self,
+        bot_username: BotUsername,
+        message_entities: kungfu.Option[MessageEntities],
+        ctx: Context,
+    ) -> bool:
+        if self.deep_link is not None and all(
+            (
+                message_entities.map(
+                    lambda entities: entities and entities[0].type == MessageEntityType.BOT_COMMAND,
+                ).unwrap_or(False),
+                self.deep_link and bot_username == ctx.get("bot_username"),
+            ),
+        ):
+            return False
+
+        param: str | None = ctx.pop("param", None)
+
+        if param is not None and self.decode_deep_link_param:
+            param = base64.urlsafe_b64decode(param.encode()).decode()
+
+        validated_param = self.validator(param) if self.validator and param is not None else param
+
+        if self.param_required and validated_param is None:
+            return False
+
+        ctx.set(self.alias or "param", validated_param)
+        return True
+
+
+__all__ = ("StartCommand",)

telegrinder/bot/rules/state.py

@@ -0,0 +1,35 @@
+import dataclasses
+import enum
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.nodes.source import Source
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.state_storage.abc import ABCStateStorage
+
+
+class StateMeta(enum.Enum):
+    NO_STATE = enum.auto()
+    ANY = enum.auto()
+
+
+@dataclasses.dataclass(frozen=True, slots=True, repr=False)
+class State[Payload](ABCRule):
+    storage: "ABCStateStorage[Payload]"
+    key: str | StateMeta | enum.Enum
+
+    async def check(self, source: Source, ctx: Context) -> bool:
+        state = await self.storage.get(source.from_user.id)
+        if not state:
+            return self.key == StateMeta.NO_STATE
+
+        if self.key != StateMeta.ANY and self.key != state.unwrap().key:
+            return False
+
+        ctx.state = state.unwrap()
+        return True
+
+
+__all__ = ("State", "StateMeta")

telegrinder/bot/rules/text.py

@@ -0,0 +1,27 @@
+from telegrinder import node
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.node import NodeRule
+
+
+class HasText(NodeRule):
+    def __init__(self) -> None:
+        super().__init__(node.as_node(node.Text))
+
+
+class HasCaption(NodeRule):
+    def __init__(self) -> None:
+        super().__init__(node.as_node(node.Caption))
+
+
+class Text(ABCRule):
+    def __init__(self, texts: str | list[str], /, *, ignore_case: bool = False) -> None:
+        if not isinstance(texts, list):
+            texts = [texts]
+        self.texts = set(texts) if not ignore_case else set(map(str.lower, texts))
+        self.ignore_case = ignore_case
+
+    def check(self, text: node.Text | node.Caption) -> bool:
+        return (text if not self.ignore_case else text.lower()) in self.texts
+
+
+__all__ = ("HasCaption", "HasText", "Text")

telegrinder/bot/rules/update.py

@@ -0,0 +1,14 @@
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
+
+
+class IsUpdateType(ABCRule):
+    def __init__(self, update_type: UpdateType, /) -> None:
+        self.update_type = update_type
+
+    def check(self, update: Update) -> bool:
+        return update.update_type == self.update_type
+
+
+__all__ = ("IsUpdateType",)

telegrinder/bot/scenario/__init__.py

@@ -0,0 +1,5 @@
+from .abc import ABCScenario
+from .checkbox import Checkbox
+from .choice import Choice
+
+__all__ = ("ABCScenario", "Checkbox", "Choice")

telegrinder/bot/scenario/abc.py

@@ -0,0 +1,16 @@
+import typing
+from abc import ABC, abstractmethod
+
+if typing.TYPE_CHECKING:
+    from telegrinder.api.api import API
+    from telegrinder.bot.dispatch.view.abc import ABCView
+    from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
+
+
+class ABCScenario(ABC):
+    @abstractmethod
+    def wait(self, hasher: Hasher, view: ABCView, api: API) -> typing.Any:
+        pass
+
+
+__all__ = ("ABCScenario",)