telegrinder 0.1.dev168__py3-none-any.whl → 0.1.dev170__py3-none-any.whl

telegrinder/node/command.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass, field
+
+from fntypes import Nothing, Option, Some
+
+from .base import DataNode
+from .text import Text
+
+
+def single_split(s: str, separator: str) -> tuple[str, str]:
+    left, *right = s.split(separator, 1)
+    return left, (right[0] if right else "")
+
+
+def cut_mention(text: str) -> tuple[str, Option[str]]:
+    left, right = single_split(text, "@")
+    return left, Some(right) if right else Nothing()
+
+
+@dataclass
+class CommandInfo(DataNode):
+    name: str
+    arguments: str
+    mention: Option[str] = field(default_factory=Nothing)
+
+    @classmethod
+    async def compose(cls, text: Text):
+        name, arguments = single_split(text, separator=" ")
+        name, mention = cut_mention(name)
+        return cls(name, arguments, mention)

telegrinder/node/composer.py

@@ -1,23 +1,112 @@
 import typing
 
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types import UpdateCute
-from telegrinder.node import Node
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.scope import NodeScope
+from telegrinder.tools.magic import get_annotations, magic_bundle
+
+CONTEXT_STORE_NODES_KEY = "node_ctx"
+
+
+async def compose_node(
+    _node: type[Node],
+    update: UpdateCute,
+    ctx: Context,
+) -> "NodeSession":
+    node = _node.as_node()
+    context = NodeCollection({})
+    node_ctx: dict[type[Node], "NodeSession"] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+
+    for name, subnode in node.get_sub_nodes().items():
+        if subnode in node_ctx:
+            context.sessions[name] = node_ctx[subnode]
+        elif subnode is UpdateCute:
+            context.sessions[name] = NodeSession(None, update, {})
+        elif subnode is API:
+            context.sessions[name] = NodeSession(None, update.ctx_api, {})
+        elif subnode is Context:
+            context.sessions[name] = NodeSession(None, ctx, {})
+        else:
+            context.sessions[name] = await compose_node(subnode, update, ctx)
+
+            if getattr(subnode, "scope", None) is NodeScope.PER_EVENT:
+                node_ctx[subnode] = context.sessions[name]
+
+    generator: typing.AsyncGenerator | None
+
+    if node.is_generator():
+        generator = typing.cast(typing.AsyncGenerator, node.compose(**context.values()))
+        value = await generator.asend(None)
+    else:
+        generator = None
+        value = await node.compose(**context.values())  # type: ignore
+
+    return NodeSession(_node, value, context.sessions, generator)
+
+
+async def compose_nodes(
+    node_types: dict[str, type[Node]],
+    update: UpdateCute,
+    ctx: Context,
+) -> typing.Optional["NodeCollection"]:
+    nodes: dict[str, NodeSession] = {}
+    node_ctx: dict[type[Node], "NodeSession"] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+
+    for name, node_t in node_types.items():
+        scope = getattr(node_t, "scope", None)
+        try:
+            if scope is NodeScope.PER_EVENT and node_t in node_ctx:
+                nodes[name] = node_ctx[node_t]
+                continue
+            elif scope is NodeScope.GLOBAL and hasattr(node_t, "_value"):
+                nodes[name] = getattr(node_t, "_value")
+                continue
+
+            nodes[name] = await compose_node(
+                node_t,
+                update,
+                ctx,
+            )
+
+            if scope is NodeScope.PER_EVENT:
+                node_ctx[node_t] = nodes[name]
+            elif scope is NodeScope.GLOBAL:
+                setattr(node_t, "_value", nodes[name])
+
+        except ComposeError:
+            await NodeCollection(nodes).close_all()
+            return None
+    return NodeCollection(nodes)
 
 
 class NodeSession:
     def __init__(
         self,
+        node_type: type[Node] | None,
         value: typing.Any,
         subnodes: dict[str, typing.Self],
         generator: typing.AsyncGenerator[typing.Any, None] | None = None,
     ):
+        self.node_type = node_type
         self.value = value
         self.subnodes = subnodes
         self.generator = generator
 
-    async def close(self, with_value: typing.Any | None = None) -> None:
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}: {self.value}" + ("ACTIVE>" if self.generator else ">")
+
+    async def close(
+        self,
+        with_value: typing.Any | None = None,
+        scopes: tuple[NodeScope, ...] = (NodeScope.PER_CALL,),
+    ) -> None:
+        if self.node_type and getattr(self.node_type, "scope", None) not in scopes:
+            return
+
         for subnode in self.subnodes.values():
-            await subnode.close()
+            await subnode.close(scopes=scopes)
 
         if self.generator is None:
             return
@@ -26,46 +115,46 @@ class NodeSession:
         except StopAsyncIteration:
             self.generator = None
 
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}: {self.value}" + ("ACTIVE>" if self.generator else ">")
-
 
 class NodeCollection:
     def __init__(self, sessions: dict[str, NodeSession]) -> None:
         self.sessions = sessions
 
+    def __repr__(self) -> str:
+        return "<{}: sessions={}>".format(self.__class__.__name__, self.sessions)
+
     def values(self) -> dict[str, typing.Any]:
         return {name: session.value for name, session in self.sessions.items()}
 
-    async def close_all(self, with_value: typing.Any | None = None) -> None:
+    async def close_all(
+        self,
+        with_value: typing.Any | None = None,
+        scopes: tuple[NodeScope, ...] = (NodeScope.PER_CALL,),
+    ) -> None:
         for session in self.sessions.values():
-            await session.close(with_value)
+            await session.close(with_value, scopes=scopes)
 
 
-async def compose_node(
-    node: type[Node],
-    update: UpdateCute,
-    ready_context: dict[str, NodeSession] | None = None,
-) -> NodeSession:
-    _node = node.as_node()
-    context = NodeCollection(ready_context.copy() if ready_context else {})
-
-    for name, subnode in _node.get_sub_nodes().items():
-        if subnode is UpdateCute:
-            context.sessions[name] = NodeSession(update, {})
-        else:
-            context.sessions[name] = await compose_node(subnode, update)
+class Composition:
+    nodes: dict[str, type[Node]]
 
-    generator: typing.AsyncGenerator | None
+    def __init__(self, func: typing.Callable[..., typing.Any], is_blocking: bool) -> None:
+        self.func = func
+        self.nodes = get_annotations(func)
+        self.is_blocking = is_blocking
 
-    if _node.is_generator():
-        generator = typing.cast(typing.AsyncGenerator, _node.compose(**context.values()))
-        value = await generator.asend(None)
-    else:
-        generator = None
-        value = await _node.compose(**context.values())  # type: ignore
+    def __repr__(self) -> str:
+        return "<{}: for function={!r} with nodes={}>".format(
+            ("blocking " if self.is_blocking else "") + self.__class__.__name__,
+            self.func.__name__,
+            self.nodes,
+        )
+
+    async def compose_nodes(self, update: UpdateCute, context: Context) -> NodeCollection | None:
+        return await compose_nodes(self.nodes, update, context)
 
-    return NodeSession(value, context.sessions, generator)
+    async def __call__(self, **kwargs: typing.Any) -> typing.Any:
+        return await self.func(**magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))  # type: ignore
 
 
-__all__ = ("NodeCollection", "NodeSession", "compose_node")
+__all__ = ("NodeCollection", "NodeSession", "Composition", "compose_node", "compose_nodes")

telegrinder/node/me.py

@@ -0,0 +1,14 @@
+from telegrinder.api.api import API
+from telegrinder.types import User
+
+from .base import ComposeError, ScalarNode
+from .scope import GLOBAL
+
+
+class Me(ScalarNode, User):
+    scope = GLOBAL
+
+    @classmethod
+    async def compose(cls, api: API) -> User:
+        me = await api.get_me()
+        return me.expect(ComposeError("Can't complete get_me request"))

telegrinder/node/message.py

@@ -1,5 +1,3 @@
-import typing
-
 from telegrinder.bot.cute_types import MessageCute
 
 from .base import ComposeError, ScalarNode
@@ -8,10 +6,10 @@ from .update import UpdateNode
 
 class MessageNode(ScalarNode, MessageCute):
     @classmethod
-    async def compose(cls, update: UpdateNode) -> typing.Self:
+    async def compose(cls, update: UpdateNode) -> "MessageNode":
         if not update.message:
             raise ComposeError
-        return cls(
+        return MessageNode(
             **update.message.unwrap().to_dict(),
             api=update.api,
         )

telegrinder/node/polymorphic.py

@@ -0,0 +1,44 @@
+import inspect
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.tools.magic import get_impls, impl
+
+from .base import ComposeError
+from .composer import CONTEXT_STORE_NODES_KEY, Composition, NodeSession
+from .scope import NodeScope
+from .update import UpdateNode
+
+
+class Polymorphic:
+    @classmethod
+    async def compose(cls, update: UpdateNode, context: Context) -> typing.Any:
+        scope = getattr(cls, "scope", None)
+        node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+
+        for i, impl in enumerate(get_impls(cls)):
+            composition = Composition(impl, True)
+            node_collection = await composition.compose_nodes(update, context)
+            if node_collection is None:
+                continue
+
+            # To determine whether this is a right morph, all subnodes must be resolved
+            if scope is NodeScope.PER_EVENT and (cls, i) in node_ctx:
+                result: NodeSession = node_ctx[(cls, i)]
+                await node_collection.close_all()
+                return result.value
+
+            result = composition.func(cls, **node_collection.values())
+            if inspect.isawaitable(result):
+                result = await result
+
+            if scope is NodeScope.PER_EVENT:
+                node_ctx[(cls, i)] = NodeSession(cls, result, {})  # type: ignore
+
+            await node_collection.close_all(with_value=result)
+            return result
+
+        raise ComposeError("No implementation found.")
+
+
+__all__ = ("Polymorphic", "impl")

telegrinder/node/rule.py

@@ -2,18 +2,39 @@ import dataclasses
 import typing
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.process import check_rule
-from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.node.base import ComposeError, Node
 from telegrinder.node.update import UpdateNode
 
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.abc import ABCRule
 
-class RuleContext(dict):
+
+class RuleChain(dict[str, typing.Any]):
     dataclass = dict
-    rules: tuple[ABCRule, ...] = ()
+    rules: tuple["ABCRule", ...] = ()
+
+    def __init_subclass__(cls) -> None:
+        if cls.__name__ == "_RuleNode":
+            return
+        cls.dataclass = cls.generate_node_dataclass(cls)
+
+    def __new__(cls, *rules: "ABCRule") -> type[Node]:
+        return type("_RuleNode", (cls,), {"dataclass": dict, "rules": rules})  # type: ignore
+
+    def __class_getitem__(cls, items: typing.Union[tuple["ABCRule", ...], "ABCRule"]) -> typing.Self:
+        if not isinstance(items, tuple):
+            items = (items,)
+        assert all(isinstance(rule, "ABCRule") for rule in items), "All items must be instances of 'ABCRule'."
+        return cls(*items)
+
+    @staticmethod
+    def generate_node_dataclass(cls_: type["RuleChain"]):  # noqa: ANN205
+        return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
 
     @classmethod
     async def compose(cls, update: UpdateNode):
+        from telegrinder.bot.dispatch.process import check_rule
+
         ctx = Context()
         for rule in cls.rules:
             if not await check_rule(update.api, rule, update, ctx):
@@ -35,22 +56,5 @@ class RuleContext(dict):
     def is_generator(cls) -> typing.Literal[False]:
         return False
 
-    def __new__(cls, *rules: ABCRule) -> type[Node]:
-        return type("_RuleNode", (cls,), {"dataclass": dict, "rules": rules})  # type: ignore
-
-    def __class_getitem__(cls, item: tuple[ABCRule, ...]) -> typing.Self:
-        if not isinstance(item, tuple):
-            item = (item,)
-        return cls(*item)
-
-    @staticmethod
-    def generate_dataclass(cls_: type["RuleContext"]):  # noqa: ANN205
-        return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
-
-    def __init_subclass__(cls) -> None:
-        if cls.__name__ == "_RuleNode":
-            return
-        cls.dataclass = cls.generate_dataclass(cls)
-
 
-__all__ = ("RuleContext",)
+__all__ = ("RuleChain",)

telegrinder/node/scope.py

@@ -0,0 +1,36 @@
+import enum
+import typing
+
+if typing.TYPE_CHECKING:
+    from .base import Node
+
+T = typing.TypeVar("T", bound=type["Node"])
+
+
+class NodeScope(enum.Enum):
+    GLOBAL = enum.auto()
+    PER_EVENT = enum.auto()
+    PER_CALL = enum.auto()
+
+
+PER_EVENT = NodeScope.PER_EVENT
+PER_CALL = NodeScope.PER_CALL
+GLOBAL = NodeScope.GLOBAL
+
+
+def per_call(node: T) -> T:
+    setattr(node, "scope", PER_CALL)
+    return node
+
+
+def per_event(node: T) -> T:
+    setattr(node, "scope", PER_EVENT)
+    return node
+
+
+def global_node(node: T) -> T:
+    setattr(node, "scope", GLOBAL)
+    return node
+
+
+__all__ = ("NodeScope", "PER_EVENT", "PER_CALL", "per_call", "per_event", "global_node", "GLOBAL")

telegrinder/node/source.py

@@ -1,34 +1,61 @@
 import dataclasses
 import typing
 
+from fntypes import Nothing, Option
+
 from telegrinder.api import API
-from telegrinder.types import Chat, Message
+from telegrinder.types import Chat, Message, User
 
-from .base import DataNode
+from .base import ComposeError, DataNode, ScalarNode
+from .callback_query import CallbackQueryNode
 from .message import MessageNode
+from .polymorphic import Polymorphic, impl
 
 
-@dataclasses.dataclass
-class Source(DataNode):
+@dataclasses.dataclass(kw_only=True)
+class Source(Polymorphic, DataNode):
     api: API
     chat: Chat
-    thread_id: int | None = None
+    from_user: User
+    thread_id: Option[int] = dataclasses.field(default_factory=lambda: Nothing())
 
-    @classmethod
-    async def compose(cls, message: MessageNode) -> typing.Self:
+    @impl
+    async def compose_message(cls, message: MessageNode) -> typing.Self:
         return cls(
             api=message.ctx_api,
             chat=message.chat,
-            thread_id=message.message_thread_id.unwrap_or_none(),
+            from_user=message.from_user,
+            thread_id=message.message_thread_id,
+        )
+
+    @impl
+    async def compose_callback_query(cls, callback_query: CallbackQueryNode) -> typing.Self:
+        return cls(
+            api=callback_query.ctx_api,
+            chat=callback_query.chat.expect(ComposeError),
+            from_user=callback_query.from_user,
+            thread_id=callback_query.message_thread_id,
         )
 
     async def send(self, text: str) -> Message:
         result = await self.api.send_message(
             chat_id=self.chat.id,
-            message_thread_id=self.thread_id,
+            message_thread_id=self.thread_id.unwrap_or_none(),
             text=text,
         )
         return result.unwrap()
 
 
-__all__ = ("Source",)
+class ChatSource(ScalarNode, Chat):
+    @classmethod
+    async def compose(cls, source: Source) -> Chat:
+        return source.chat
+
+
+class UserSource(ScalarNode, User):
+    @classmethod
+    async def compose(cls, source: Source) -> User:
+        return source.from_user
+
+
+__all__ = ("Source", "ChatSource", "UserSource")

telegrinder/node/text.py

@@ -1,15 +1,21 @@
-import typing
-
 from .base import ComposeError, ScalarNode
 from .message import MessageNode
 
 
 class Text(ScalarNode, str):
     @classmethod
-    async def compose(cls, message: MessageNode) -> typing.Self:
+    async def compose(cls, message: MessageNode) -> str:
         if not message.text:
             raise ComposeError("Message has no text")
-        return cls(message.text.unwrap())
+        return message.text.unwrap()
+
+
+class TextInteger(ScalarNode, int):
+    @classmethod
+    async def compose(cls, text: Text) -> int:
+        if not text.isdigit():
+            raise ComposeError("Text is not digit")
+        return int(text)
 
 
-__all__ = ("Text",)
+__all__ = ("Text", "TextInteger")

telegrinder/node/tools/__init__.py

@@ -1,3 +1,3 @@
-from .generator import generate
+from .generator import generate_node
 
-__all__ = ("generate",)
+__all__ = ("generate_node",)

telegrinder/node/tools/generator.py

@@ -19,11 +19,11 @@ def error_on_none(value: T | None) -> T:
     return value
 
 
-def generate(
-    subnodes: tuple[type[Node], ...],
-    func: typing.Callable[..., typing.Any],
-    casts: tuple[typing.Callable, ...] = (cast_false_to_none, error_on_none),
-) -> type[ContainerNode]:
+def generate_node(
+    subnodes: tuple[type["Node"], ...],
+    func: typing.Callable[..., T],
+    casts: tuple[typing.Callable[[typing.Any], typing.Any], ...] = (cast_false_to_none, error_on_none),
+) -> type["Node"]:
     async def compose(**kw: typing.Any) -> typing.Any:
         args = await ContainerNode.compose(**kw)
         result = func(*args)
@@ -37,4 +37,4 @@ def generate(
     return type("_ContainerNode", (container,), {"compose": compose})
 
 
-__all__ = ("generate",)
+__all__ = ("generate_node",)

telegrinder/tools/__init__.py

@@ -14,7 +14,6 @@ from .formatting import (
     StartBotLink,
     StartGroupLink,
     TgEmoji,
-    UserOpenMessage,
     block_quote,
     bold,
     channel_boost_link,
@@ -38,8 +37,6 @@ from .formatting import (
     strike,
     tg_emoji,
     underline,
-    user_open_message,
-    user_open_message_link,
 )
 from .global_context import (
     ABCGlobalContext,
@@ -68,7 +65,7 @@ from .keyboard import (
 )
 from .limited_dict import LimitedDict
 from .loop_wrapper import ABCLoopWrapper, DelayedTask, Lifespan, LoopWrapper
-from .magic import magic_bundle, resolve_arg_names
+from .magic import impl, magic_bundle, resolve_arg_names
 from .parse_mode import ParseMode
 
 __all__ = (
@@ -115,12 +112,6 @@ __all__ = (
     "StartGroupLink",
     "TelegrinderCtx",
     "TgEmoji",
-    "UserOpenMessage",
-    "block_quote",
-    "bold",
-    "channel_boost_link",
-    "code_inline",
-    "ctx_var",
     "escape",
     "get_channel_boost_link",
     "get_invite_chat_link",
@@ -134,7 +125,6 @@ __all__ = (
     "magic_bundle",
     "mention",
     "pre_code",
-    "resolve_arg_names",
     "resolve_domain",
     "spoiler",
     "start_bot_link",
@@ -142,6 +132,11 @@ __all__ = (
     "strike",
     "tg_emoji",
     "underline",
-    "user_open_message",
-    "user_open_message_link",
+    "bold",
+    "channel_boost_link",
+    "code_inline",
+    "ctx_var",
+    "block_quote",
+    "impl",
+    "resolve_arg_names",
 )

telegrinder/tools/buttons.py

@@ -47,30 +47,36 @@ class RowButtons(typing.Generic[ButtonT]):
 @dataclasses.dataclass
 class Button(BaseButton):
     text: str
-    _: dataclasses.KW_ONLY
-    request_contact: bool = False
-    request_location: bool = False
-    request_chat: dict[str, typing.Any] | KeyboardButtonRequestChat | None = None
-    request_user: dict[str, typing.Any] | KeyboardButtonRequestUsers | None = None
-    request_poll: dict[str, typing.Any] | KeyboardButtonPollType | None = None
-    web_app: dict[str, typing.Any] | WebAppInfo | None = None
+    request_contact: bool = dataclasses.field(default=False, kw_only=True)
+    request_location: bool = dataclasses.field(default=False, kw_only=True)
+    request_chat: dict[str, typing.Any] | KeyboardButtonRequestChat | None = dataclasses.field(
+        default=None, kw_only=True
+    )
+    request_user: dict[str, typing.Any] | KeyboardButtonRequestUsers | None = dataclasses.field(
+        default=None, kw_only=True
+    )
+    request_poll: dict[str, typing.Any] | KeyboardButtonPollType | None = dataclasses.field(
+        default=None, kw_only=True
+    )
+    web_app: dict[str, typing.Any] | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
 
 
 @dataclasses.dataclass
 class InlineButton(BaseButton):
     text: str
-    _: dataclasses.KW_ONLY
-    url: str | None = None
-    login_url: dict[str, typing.Any] | LoginUrl | None = None
-    pay: bool | None = None
-    callback_data: str | dict[str, typing.Any] | DataclassInstance | msgspec.Struct | None = None
-    callback_game: dict[str, typing.Any] | CallbackGame | None = None
-    switch_inline_query: str | None = None
-    switch_inline_query_current_chat: str | None = None
+    url: str | None = dataclasses.field(default=None, kw_only=True)
+    login_url: dict[str, typing.Any] | LoginUrl | None = dataclasses.field(default=None, kw_only=True)
+    pay: bool | None = dataclasses.field(default=None, kw_only=True)
+    callback_data: str | dict[str, typing.Any] | DataclassInstance | msgspec.Struct | None = (
+        dataclasses.field(default=None, kw_only=True)
+    )
+    callback_game: dict[str, typing.Any] | CallbackGame | None = dataclasses.field(default=None, kw_only=True)
+    switch_inline_query: str | None = dataclasses.field(default=None, kw_only=True)
+    switch_inline_query_current_chat: str | None = dataclasses.field(default=None, kw_only=True)
     switch_inline_query_chosen_chat: dict[str, typing.Any] | SwitchInlineQueryChosenChat | None = (
-        None
+        dataclasses.field(default=None, kw_only=True)
     )
-    web_app: dict[str, typing.Any] | WebAppInfo | None = None
+    web_app: dict[str, typing.Any] | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
 
 
 __all__ = (