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

telegrinder/node/__init__.py

@@ -1,10 +1,13 @@
 from .attachment import Attachment, Audio, Photo, Video
-from .base import ComposeError, DataNode, Node, ScalarNode, is_node
+from .base import BaseNode, ComposeError, DataNode, Node, ScalarNode, is_node, node_impl
+from .callback_query import CallbackQueryNode
 from .command import CommandInfo
 from .composer import Composition, NodeCollection, NodeSession, compose_node, compose_nodes
 from .container import ContainerNode
+from .event import EventNode
 from .me import Me
 from .message import MessageNode
+from .polymorphic import Polymorphic, impl
 from .rule import RuleChain
 from .scope import GLOBAL, PER_CALL, PER_EVENT, NodeScope, global_node, per_call, per_event
 from .source import ChatSource, Source, UserSource
@@ -15,35 +18,41 @@ from .update import UpdateNode
 __all__ = (
     "Attachment",
     "Audio",
+    "BaseNode",
+    "CallbackQueryNode",
     "ChatSource",
+    "CommandInfo",
     "ComposeError",
+    "Composition",
     "ContainerNode",
     "DataNode",
+    "EventNode",
+    "GLOBAL",
+    "Me",
     "MessageNode",
     "Node",
     "NodeCollection",
+    "NodeScope",
     "NodeSession",
+    "PER_CALL",
+    "PER_EVENT",
     "Photo",
+    "Polymorphic",
     "RuleChain",
     "ScalarNode",
     "Source",
     "Text",
     "TextInteger",
-    "UserSource",
     "UpdateNode",
+    "UserSource",
     "Video",
     "compose_node",
+    "compose_nodes",
     "generate_node",
-    "Composition",
+    "global_node",
+    "impl",
     "is_node",
-    "compose_nodes",
-    "NodeScope",
-    "PER_CALL",
-    "PER_EVENT",
+    "node_impl",
     "per_call",
     "per_event",
-    "CommandInfo",
-    "GLOBAL",
-    "global_node",
-    "Me",
 )

telegrinder/node/attachment.py

@@ -1,30 +1,33 @@
 import dataclasses
 import typing
 
-from fntypes import Option, Some
+from fntypes.co import Option, Some
 from fntypes.option import Nothing
 
 import telegrinder.types
+from telegrinder.node.base import ComposeError, DataNode, ScalarNode
+from telegrinder.node.message import MessageNode
 
-from .base import ComposeError, DataNode, ScalarNode
-from .message import MessageNode
 
-
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class Attachment(DataNode):
     attachment_type: typing.Literal["audio", "document", "photo", "poll", "video"]
     audio: Option[telegrinder.types.Audio] = dataclasses.field(
-        default_factory=lambda: Nothing(), kw_only=True
+        default_factory=lambda: Nothing(),
+        kw_only=True,
     )
     document: Option[telegrinder.types.Document] = dataclasses.field(
-        default_factory=lambda: Nothing(), kw_only=True
+        default_factory=lambda: Nothing(),
+        kw_only=True,
     )
     photo: Option[list[telegrinder.types.PhotoSize]] = dataclasses.field(
-        default_factory=lambda: Nothing(), kw_only=True
+        default_factory=lambda: Nothing(),
+        kw_only=True,
     )
     poll: Option[telegrinder.types.Poll] = dataclasses.field(default_factory=lambda: Nothing(), kw_only=True)
     video: Option[telegrinder.types.Video] = dataclasses.field(
-        default_factory=lambda: Nothing(), kw_only=True
+        default_factory=lambda: Nothing(),
+        kw_only=True,
     )
 
     @classmethod
@@ -33,17 +36,17 @@ class Attachment(DataNode):
             match getattr(message, attachment_type, Nothing()):
                 case Some(attachment):
                     return cls(attachment_type, **{attachment_type: Some(attachment)})
-        return cls.compose_error("No attachment found in message")
+        return cls.compose_error("No attachment found in message.")
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class Photo(DataNode):
     sizes: list[telegrinder.types.PhotoSize]
 
     @classmethod
     async def compose(cls, attachment: Attachment) -> typing.Self:
         if not attachment.photo:
-            raise ComposeError("Attachment is not an photo")
+            raise ComposeError("Attachment is not a photo.")
         return cls(attachment.photo.unwrap())
 
 
@@ -51,7 +54,7 @@ class Video(ScalarNode, telegrinder.types.Video):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Video:
         if not attachment.video:
-            raise ComposeError("Attachment is not an video")
+            raise ComposeError("Attachment is not a video.")
         return attachment.video.unwrap()
 
 
@@ -59,7 +62,7 @@ class Audio(ScalarNode, telegrinder.types.Audio):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Audio:
         if not attachment.audio:
-            raise ComposeError("Attachment is not an audio")
+            raise ComposeError("Attachment is not an audio.")
         return attachment.audio.unwrap()
 
 
@@ -67,7 +70,7 @@ class Document(ScalarNode, telegrinder.types.Document):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Document:
         if not attachment.document:
-            raise ComposeError("Attachment is not an document")
+            raise ComposeError("Attachment is not a document.")
         return attachment.document.unwrap()
 
 
@@ -75,7 +78,7 @@ class Poll(ScalarNode, telegrinder.types.Poll):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Poll:
         if not attachment.poll:
-            raise ComposeError("Attachment is not an poll")
+            raise ComposeError("Attachment is not a poll.")
         return attachment.poll.unwrap()
 
 

telegrinder/node/base.py

@@ -1,19 +1,70 @@
 import abc
 import inspect
 import typing
+from types import AsyncGeneratorType
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.scope import NodeScope
+from telegrinder.tools.magic import (
+    NODE_IMPL_MARK,
+    cache_magic_value,
+    get_annotations,
+    get_impls_by_key,
+    magic_bundle,
+    node_impl,
+)
 
-from telegrinder.tools.magic import get_annotations
+ComposeResult: typing.TypeAlias = typing.Awaitable[typing.Any] | typing.AsyncGenerator[typing.Any, None]
 
-from .scope import NodeScope
 
-ComposeResult: typing.TypeAlias = (
-    typing.Coroutine[typing.Any, typing.Any, typing.Any]
-    | typing.AsyncGenerator[typing.Any, None]
-    | typing.Any
-)
+def is_node(maybe_node: type[typing.Any]) -> typing.TypeGuard[type["Node"]]:
+    maybe_node = typing.get_origin(maybe_node) or maybe_node
+    return (
+        isinstance(maybe_node, type)
+        and issubclass(maybe_node, Node)
+        or isinstance(maybe_node, Node)
+        or hasattr(maybe_node, "as_node")
+    )
+
+
+@cache_magic_value("__compose_annotations__")
+def get_compose_annotations(function: typing.Callable[..., typing.Any]) -> dict[str, typing.Any]:
+    return {k: v for k, v in get_annotations(function).items() if not is_node(v)}
+
 
+@cache_magic_value("__nodes__")
+def get_nodes(function: typing.Callable[..., typing.Any]) -> dict[str, type["Node"]]:
+    return {k: v for k, v in get_annotations(function).items() if is_node(v)}
 
-class ComposeError(BaseException): ...
+
+@cache_magic_value("__is_generator__")
+def is_generator(function: typing.Callable[..., typing.Any]) -> typing.TypeGuard[AsyncGeneratorType[typing.Any, None]]:
+    return inspect.isasyncgenfunction(function)
+
+
+def get_node_impls(node_cls: type["Node"]) -> dict[str, typing.Any]:
+    if not hasattr(node_cls, "__node_impls__"):
+        impls = get_impls_by_key(node_cls, NODE_IMPL_MARK)
+        if issubclass(node_cls, BaseNode):
+            impls |= get_impls_by_key(BaseNode, NODE_IMPL_MARK)
+        setattr(node_cls, "__node_impls__", impls)
+    return getattr(node_cls, "__node_impls__")
+
+
+def get_node_impl(
+    node: type[typing.Any],
+    node_impls: dict[str, typing.Callable[..., typing.Any]],
+) -> typing.Callable[..., typing.Any] | None:
+    for n_impl in node_impls.values():
+        if "return" in n_impl.__annotations__ and node is n_impl.__annotations__["return"]:
+            return n_impl
+    return None
+
+
+class ComposeError(BaseException):
+    pass
 
 
 class Node(abc.ABC):
@@ -25,13 +76,46 @@ class Node(abc.ABC):
     def compose(cls, *args, **kwargs) -> ComposeResult:
         pass
 
+    @classmethod
+    async def compose_annotation(
+        cls,
+        annotation: typing.Any,
+        update: UpdateCute,
+        ctx: Context,
+    ) -> typing.Any:
+        orig_annotation: type[typing.Any] = typing.get_origin(annotation) or annotation
+        n_impl = get_node_impl(orig_annotation, cls.get_node_impls())
+        if n_impl is None:
+            raise ComposeError(f"Node implementation for {orig_annotation!r} not found.")
+
+        result = n_impl(
+            cls,
+            **magic_bundle(
+                n_impl,
+                {"update": update, "context": ctx},
+                start_idx=0,
+                bundle_ctx=False,
+            ),
+        )
+        if inspect.isawaitable(result):
+            return await result
+        return result
+
     @classmethod
     def compose_error(cls, error: str | None = None) -> typing.NoReturn:
         raise ComposeError(error)
 
     @classmethod
-    def get_sub_nodes(cls) -> dict[str, type[typing.Self]]:
-        return get_annotations(cls.compose)
+    def get_sub_nodes(cls) -> dict[str, type["Node"]]:
+        return get_nodes(cls.compose)
+
+    @classmethod
+    def get_compose_annotations(cls) -> dict[str, typing.Any]:
+        return get_compose_annotations(cls.compose)
+
+    @classmethod
+    def get_node_impls(cls) -> dict[str, typing.Callable[..., typing.Any]]:
+        return get_node_impls(cls)
 
     @classmethod
     def as_node(cls) -> type[typing.Self]:
@@ -39,10 +123,29 @@ class Node(abc.ABC):
 
     @classmethod
     def is_generator(cls) -> bool:
-        return inspect.isasyncgenfunction(cls.compose)
+        return is_generator(cls.compose)
+
+
+class BaseNode(Node, abc.ABC):
+    @classmethod
+    @abc.abstractmethod
+    def compose(cls, *args, **kwargs) -> ComposeResult:
+        pass
+
+    @node_impl
+    def compose_api(cls, update: UpdateCute) -> API:
+        return update.ctx_api
+
+    @node_impl
+    def compose_context(cls, context: Context) -> Context:
+        return context
 
+    @node_impl
+    def compose_update(cls, update: UpdateCute) -> UpdateCute:
+        return update
 
-class DataNode(Node, abc.ABC):
+
+class DataNode(BaseNode, abc.ABC):
     node = "data"
 
     @typing.dataclass_transform()
@@ -52,7 +155,7 @@ class DataNode(Node, abc.ABC):
         pass
 
 
-class ScalarNodeProto(Node, abc.ABC):
+class ScalarNodeProto(BaseNode, abc.ABC):
     @classmethod
     @abc.abstractmethod
     async def compose(cls, *args, **kwargs) -> ComposeResult:
@@ -68,7 +171,6 @@ if typing.TYPE_CHECKING:
         pass
 
 else:
-
     def create_node(cls, bases, dct):
         dct.update(cls.__dict__)
         return type(cls.__name__, bases, dct)
@@ -87,21 +189,15 @@ else:
         pass
 
 
-def is_node(maybe_node: type[typing.Any]) -> typing.TypeGuard[type[Node]]:
-    maybe_node = typing.get_origin(maybe_node) or maybe_node
-    return (
-        isinstance(maybe_node, type)
-        and issubclass(maybe_node, Node)
-        or isinstance(maybe_node, Node)
-        or hasattr(maybe_node, "as_node")
-    )
-
-
 __all__ = (
+    "BaseNode",
     "ComposeError",
     "DataNode",
     "Node",
     "SCALAR_NODE",
     "ScalarNode",
+    "ScalarNodeProto",
+    "get_compose_annotations",
+    "get_nodes",
     "is_node",
 )

telegrinder/node/callback_query.py

@@ -1,18 +1,14 @@
-from telegrinder.bot.cute_types import CallbackQueryCute
-
-from .base import ComposeError, ScalarNode
-from .update import UpdateNode
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.node.update import UpdateNode
 
 
 class CallbackQueryNode(ScalarNode, CallbackQueryCute):
     @classmethod
     async def compose(cls, update: UpdateNode) -> CallbackQueryCute:
         if not update.callback_query:
-            raise ComposeError
-        return CallbackQueryCute(
-            **update.callback_query.unwrap().to_dict(),
-            api=update.api,
-        )
+            raise ComposeError("Update is not a callback_query.")
+        return update.callback_query.unwrap()
 
 
 __all__ = ("CallbackQueryNode",)

telegrinder/node/command.py

@@ -1,3 +1,4 @@
+import typing
 from dataclasses import dataclass, field
 
 from fntypes import Nothing, Option, Some
@@ -16,14 +17,17 @@ def cut_mention(text: str) -> tuple[str, Option[str]]:
     return left, Some(right) if right else Nothing()
 
 
-@dataclass
+@dataclass(slots=True)
 class CommandInfo(DataNode):
     name: str
     arguments: str
     mention: Option[str] = field(default_factory=Nothing)
 
     @classmethod
-    async def compose(cls, text: Text):
+    async def compose(cls, text: Text) -> typing.Self:
         name, arguments = single_split(text, separator=" ")
         name, mention = cut_mention(name)
         return cls(name, arguments, mention)
+
+
+__all__ = ("CommandInfo", "cut_mention", "single_split")

telegrinder/node/composer.py

@@ -1,11 +1,20 @@
+import dataclasses
 import typing
 
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types import UpdateCute
+from fntypes.error import UnwrapError
+
+from telegrinder.bot.cute_types.update import UpdateCute
 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
+from telegrinder.modules import logger
+from telegrinder.node.base import (
+    BaseNode,
+    ComposeError,
+    Node,
+    NodeScope,
+    get_compose_annotations,
+    get_nodes,
+)
+from telegrinder.tools.magic import magic_bundle
 
 CONTEXT_STORE_NODES_KEY = "node_ctx"
 
@@ -22,80 +31,86 @@ async def compose_node(
     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
+    for name, annotation in node.get_compose_annotations().items():
+        context.sessions[name] = NodeSession(
+            None,
+            await node.compose_annotation(annotation, update, ctx),
+            {},
+        )
 
     if node.is_generator():
-        generator = typing.cast(typing.AsyncGenerator, node.compose(**context.values()))
+        generator = typing.cast(typing.AsyncGenerator[typing.Any, None], node.compose(**context.values()))
         value = await generator.asend(None)
     else:
         generator = None
-        value = await node.compose(**context.values())  # type: ignore
+        value = await typing.cast(typing.Awaitable[typing.Any], node.compose(**context.values()))
 
     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] = {}
+    nodes: dict[str, type[Node]],
+    node_class: type[Node] | None = None,
+    context_annotations: dict[str, typing.Any] | None = None,
+) -> "NodeCollection | None":
+    node_sessions: 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:
+    try:
+        for name, node_t in nodes.items():
+            scope = getattr(node_t, "scope", None)
+
             if scope is NodeScope.PER_EVENT and node_t in node_ctx:
-                nodes[name] = node_ctx[node_t]
+                node_sessions[name] = node_ctx[node_t]
                 continue
             elif scope is NodeScope.GLOBAL and hasattr(node_t, "_value"):
-                nodes[name] = getattr(node_t, "_value")
+                node_sessions[name] = getattr(node_t, "_value")
                 continue
 
-            nodes[name] = await compose_node(
-                node_t,
-                update,
-                ctx,
-            )
+            node_sessions[name] = await compose_node(node_t, update, ctx)
 
             if scope is NodeScope.PER_EVENT:
-                node_ctx[node_t] = nodes[name]
+                node_ctx[node_t] = node_sessions[name]
             elif scope is NodeScope.GLOBAL:
-                setattr(node_t, "_value", nodes[name])
+                setattr(node_t, "_value", node_sessions[name])
+    except (ComposeError, UnwrapError) as exc:
+        logger.debug(f"Composing node (name={name!r}, node_class={node_t!r}) failed with error: {str(exc)!r}")
+        await NodeCollection(node_sessions).close_all()
+        return None
+
+    if context_annotations:
+        node_class = node_class or BaseNode
 
-        except ComposeError:
-            await NodeCollection(nodes).close_all()
+        try:
+            for name, annotation in context_annotations.items():
+                node_sessions[name] = await node_class.compose_annotation(annotation, update, ctx)
+        except (ComposeError, UnwrapError) as exc:
+            logger.debug(
+                f"Composing context annotation (name={name!r}, annotation={annotation!r}) failed with error: {str(exc)!r}",
+            )
+            await NodeCollection(node_sessions).close_all()
             return None
-    return NodeCollection(nodes)
+
+    return NodeCollection(node_sessions)
 
 
+@dataclasses.dataclass(slots=True, repr=False)
 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
+    node_type: type[Node] | None
+    value: typing.Any
+    subnodes: dict[str, typing.Self]
+    generator: typing.AsyncGenerator[typing.Any, None] | None = None
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}: {self.value}" + ("ACTIVE>" if self.generator else ">")
+        return f"<{self.__class__.__name__}: {self.value!r}" + (" ACTIVE>" if self.generator else ">")
 
     async def close(
         self,
@@ -117,11 +132,13 @@ class NodeSession:
 
 
 class NodeCollection:
+    __slots__ = ("sessions",)
+
     def __init__(self, sessions: dict[str, NodeSession]) -> None:
         self.sessions = sessions
 
     def __repr__(self) -> str:
-        return "<{}: sessions={}>".format(self.__class__.__name__, self.sessions)
+        return "<{}: sessions={!r}>".format(self.__class__.__name__, self.sessions)
 
     def values(self) -> dict[str, typing.Any]:
         return {name: session.value for name, session in self.sessions.items()}
@@ -135,26 +152,37 @@ class NodeCollection:
             await session.close(with_value, scopes=scopes)
 
 
+@dataclasses.dataclass(slots=True, repr=False)
 class Composition:
-    nodes: dict[str, type[Node]]
+    func: typing.Callable[..., typing.Any]
+    is_blocking: bool
+    node_class: type[Node] = dataclasses.field(default_factory=lambda: BaseNode)
+    nodes: dict[str, type[Node]] = dataclasses.field(init=False)
+    context_annotations: dict[str, typing.Any] = dataclasses.field(init=False)
 
-    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
+    def __post_init__(self) -> None:
+        self.nodes = get_nodes(self.func)
+        self.context_annotations = get_compose_annotations(self.func)
 
     def __repr__(self) -> str:
-        return "<{}: for function={!r} with nodes={}>".format(
+        return "<{}: for function={!r} with nodes={!r}, context_annotations={!r}>".format(
             ("blocking " if self.is_blocking else "") + self.__class__.__name__,
-            self.func.__name__,
+            self.func.__qualname__,
             self.nodes,
+            self.context_annotations,
         )
 
     async def compose_nodes(self, update: UpdateCute, context: Context) -> NodeCollection | None:
-        return await compose_nodes(self.nodes, update, context)
+        return await compose_nodes(
+            update=update,
+            ctx=context,
+            nodes=self.nodes,
+            node_class=self.node_class,
+            context_annotations=self.context_annotations,
+        )
 
     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", "Composition", "compose_node", "compose_nodes")
+__all__ = ("Composition", "NodeCollection", "NodeSession", "compose_node", "compose_nodes")

telegrinder/node/container.py

@@ -1,17 +1,17 @@
 import typing
 
-from .base import Node
+from telegrinder.node.base import BaseNode, Node
 
 
-class ContainerNode(Node):
+class ContainerNode(BaseNode):
     linked_nodes: typing.ClassVar[list[type[Node]]]
 
     @classmethod
-    async def compose(cls, **kw) -> tuple["Node", ...]:
+    async def compose(cls, **kw) -> tuple[Node, ...]:
         return tuple(t[1] for t in sorted(kw.items(), key=lambda t: t[0]))
 
     @classmethod
-    def get_sub_nodes(cls) -> dict[str, type["Node"]]:
+    def get_sub_nodes(cls) -> dict[str, type[Node]]:
         return {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
 
     @classmethod