telegrinder 0.1.dev170__py3-none-any.whl → 0.2.0__py3-none-any.whl

telegrinder/node/composer.py

@@ -1,101 +1,108 @@
+import dataclasses
 import typing
 
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types import UpdateCute
+from fntypes import Error, Ok, Result
+from fntypes.error import UnwrapError
+
+from telegrinder.api import API
+from telegrinder.bot.cute_types.update import Update, 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 (
+    ComposeError,
+    Node,
+    NodeScope,
+    get_node_calc_lst,
+    get_nodes,
+)
+from telegrinder.tools.magic import magic_bundle
 
-CONTEXT_STORE_NODES_KEY = "node_ctx"
+CONTEXT_STORE_NODES_KEY = "_node_ctx"
+GLOBAL_VALUE_KEY = "_value"
 
 
 async def compose_node(
     _node: type[Node],
-    update: UpdateCute,
-    ctx: Context,
+    linked: dict[type, typing.Any],
 ) -> "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
+    kwargs = magic_bundle(node.compose, linked, typebundle=True)
 
     if node.is_generator():
-        generator = typing.cast(typing.AsyncGenerator, node.compose(**context.values()))
+        generator = typing.cast(typing.AsyncGenerator[typing.Any, None], node.compose(**kwargs))
         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(**kwargs))
 
-    return NodeSession(_node, value, context.sessions, generator)
+    return NodeSession(_node, value, {}, generator)
 
 
 async def compose_nodes(
-    node_types: dict[str, type[Node]],
-    update: UpdateCute,
+    nodes: dict[str, type[Node]],
     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]
+    data: dict[type, typing.Any] | None = None,
+) -> Result["NodeCollection", ComposeError]:
+    logger.debug("Composing nodes: {!r}...", nodes)
+
+    parent_nodes: dict[type[Node], NodeSession] = {}
+    event_nodes: dict[type[Node], "NodeSession"] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+    data = {Context: ctx} | (data or {})
+
+    # Create flattened list of ordered nodes to be calculated
+    # TODO: optimize flattened list calculation via caching key = tuple of node types
+    calculation_nodes: list[list[type[Node]]] = []
+    for node_t in nodes.values():
+        calculation_nodes.append(get_node_calc_lst(node_t))
+
+    for linked_nodes in calculation_nodes:
+        local_nodes: dict[type[Node], "NodeSession"] = {}
+        for node_t in linked_nodes:
+            scope = getattr(node_t, "scope", None)
+
+            if scope is NodeScope.PER_EVENT and node_t in event_nodes:
+                local_nodes[node_t] = event_nodes[node_t]
                 continue
-            elif scope is NodeScope.GLOBAL and hasattr(node_t, "_value"):
-                nodes[name] = getattr(node_t, "_value")
+            elif scope is NodeScope.GLOBAL and hasattr(node_t, GLOBAL_VALUE_KEY):
+                local_nodes[node_t] = getattr(node_t, GLOBAL_VALUE_KEY)
                 continue
 
-            nodes[name] = await compose_node(
-                node_t,
-                update,
-                ctx,
-            )
+            subnodes = {
+                k: session.value
+                for k, session in
+                (local_nodes | event_nodes).items()
+            }
+
+            try:
+                local_nodes[node_t] = await compose_node(node_t, subnodes | data)
+            except (ComposeError, UnwrapError) as exc:
+                for t, local_node in local_nodes.items():
+                    if t.scope is NodeScope.PER_CALL:
+                        await local_node.close()
+                return Error(ComposeError(f"Cannot compose {node_t}. Error: {exc}"))
 
             if scope is NodeScope.PER_EVENT:
-                node_ctx[node_t] = nodes[name]
+                event_nodes[node_t] = local_nodes[node_t]
             elif scope is NodeScope.GLOBAL:
-                setattr(node_t, "_value", nodes[name])
+                setattr(node_t, GLOBAL_VALUE_KEY, local_nodes[node_t])
 
-        except ComposeError:
-            await NodeCollection(nodes).close_all()
-            return None
-    return NodeCollection(nodes)
+        # Last node is the parent node
+        parent_node_t = linked_nodes[-1]
+        parent_nodes[parent_node_t] = local_nodes[parent_node_t]
 
+    node_sessions = {k: parent_nodes[t] for k, t in nodes.items()}
+    return Ok(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, 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,
@@ -111,18 +118,22 @@ class NodeSession:
         if self.generator is None:
             return
         try:
+            logger.debug("Closing session for node {!r}...", self.node_type)
             await self.generator.asend(with_value)
         except StopAsyncIteration:
             self.generator = None
 
 
 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)
 
+    @property
     def values(self) -> dict[str, typing.Any]:
         return {name: session.value for name, session in self.sessions.items()}
 
@@ -135,26 +146,40 @@ 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
+    nodes: dict[str, type[Node]] = 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)
 
     def __repr__(self) -> str:
-        return "<{}: for function={!r} with nodes={}>".format(
+        return "<{}: for function={!r} with nodes={!r}>".format(
             ("blocking " if self.is_blocking else "") + self.__class__.__name__,
-            self.func.__name__,
+            self.func.__qualname__,
             self.nodes,
         )
 
-    async def compose_nodes(self, update: UpdateCute, context: Context) -> NodeCollection | None:
-        return await compose_nodes(self.nodes, update, context)
+    async def compose_nodes(
+        self,
+        update: UpdateCute,
+        context: Context,
+    ) -> NodeCollection | None:
+        match await compose_nodes(
+            nodes=self.nodes,
+            ctx=context,
+            data={Update: update, API: update.api},
+        ):
+            case Ok(col):
+                return col
+            case Error(err):
+                logger.debug(f"Composition failed with error: {err}")
+                return None
 
     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 Node
 
 
 class ContainerNode(Node):
     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_subnodes(cls) -> dict[str, type[Node]]:
         return {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
 
     @classmethod

telegrinder/node/event.py

@@ -0,0 +1,68 @@
+import typing
+
+import msgspec
+
+from telegrinder.api import API
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.msgspec_utils import DataclassInstance
+from telegrinder.node.base import ComposeError, DataNode, Node
+from telegrinder.node.update import UpdateNode
+
+if typing.TYPE_CHECKING:
+    Dataclass = typing.TypeVar("Dataclass", bound="DataclassType")
+
+    DataclassType: typing.TypeAlias = DataclassInstance | DataNode | msgspec.Struct | dict[str, typing.Any]
+
+EVENT_NODE_KEY = "_event_node"
+
+
+from telegrinder.msgspec_utils import decoder
+
+
+class _EventNode(Node):
+    dataclass: type["DataclassType"]
+
+    def __new__(cls, dataclass: type["DataclassType"], /) -> type[typing.Self]:
+        namespace = dict(**cls.__dict__)
+        namespace.pop("__new__", None)
+        new_cls = type("EventNode", (cls,), {"dataclass": dataclass, **namespace})
+        return new_cls  # type: ignore
+
+    def __class_getitem__(cls, dataclass: type["DataclassType"], /) -> typing.Self:
+        return cls(dataclass)
+
+    @classmethod
+    async def compose(cls, raw_update: UpdateNode, ctx: Context, api: API) -> "DataclassType":
+        dataclass_type = typing.get_origin(cls.dataclass) or cls.dataclass
+
+        try:
+            if issubclass(dataclass_type, dict):
+                dataclass = cls.dataclass(**raw_update.incoming_update.to_full_dict())
+
+            elif issubclass(dataclass_type, BaseCute):
+                dataclass = dataclass_type.from_update(raw_update.incoming_update, bound_api=api)
+
+            elif issubclass(dataclass_type, (msgspec.Struct, DataclassInstance)): # type: ignore
+                # FIXME: must be used with encode_name
+                dataclass = decoder.convert(
+                    raw_update.incoming_update.to_full_dict(),
+                    type=cls.dataclass,
+                )
+
+            else:
+                dataclass = cls.dataclass(**raw_update.incoming_update.to_dict())
+
+            ctx[EVENT_NODE_KEY] = cls
+            return dataclass
+        except Exception as exc:
+            raise ComposeError(f"Cannot parse update into {cls.dataclass.__name__!r}, error: {exc}")
+
+
+if typing.TYPE_CHECKING:
+    EventNode: typing.TypeAlias = typing.Annotated["Dataclass", ...]
+else:
+    class EventNode(_EventNode):
+        pass
+
+__all__ = ("EventNode",)

telegrinder/node/me.py

@@ -12,3 +12,6 @@ class Me(ScalarNode, User):
     async def compose(cls, api: API) -> User:
         me = await api.get_me()
         return me.expect(ComposeError("Can't complete get_me request"))
+
+
+__all__ = ("Me",)

telegrinder/node/message.py

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

telegrinder/node/polymorphic.py

@@ -2,40 +2,45 @@ import inspect
 import typing
 
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.modules import logger
+from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, Composition, NodeSession
+from telegrinder.node.scope import NodeScope
+from telegrinder.node.update import UpdateNode
 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:
+class Polymorphic(Node):
     @classmethod
     async def compose(cls, update: UpdateNode, context: Context) -> typing.Any:
+        logger.debug(f"Composing polimorphic node {cls.__name__}")
         scope = getattr(cls, "scope", None)
         node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
 
         for i, impl in enumerate(get_impls(cls)):
+            logger.debug("Checking impl {}", impl.__name__)
             composition = Composition(impl, True)
             node_collection = await composition.compose_nodes(update, context)
             if node_collection is None:
+                logger.debug("Impl {} composition failed", impl.__name__)
                 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)]
+                logger.debug("Morph is already cached as per_event node, using its value. Impl {} succeeded", impl.__name__)
+                res: NodeSession = node_ctx[(cls, i)]
                 await node_collection.close_all()
-                return result.value
+                return res.value
 
-            result = composition.func(cls, **node_collection.values())
+            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
+                node_ctx[(cls, i)] = NodeSession(cls, result, {})
 
             await node_collection.close_all(with_value=result)
+            logger.debug("Impl {} succeeded with value {}", impl.__name__, result)
             return result
 
         raise ComposeError("No implementation found.")

telegrinder/node/rule.py

@@ -1,4 +1,5 @@
 import dataclasses
+import importlib
 import typing
 
 from telegrinder.bot.dispatch.context import Context
@@ -6,6 +7,7 @@ from telegrinder.node.base import ComposeError, Node
 from telegrinder.node.update import UpdateNode
 
 if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.process import check_rule
     from telegrinder.bot.rules.abc import ABCRule
 
 
@@ -13,7 +15,9 @@ class RuleChain(dict[str, typing.Any]):
     dataclass = dict
     rules: tuple["ABCRule", ...] = ()
 
-    def __init_subclass__(cls) -> None:
+    def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
+        super().__init_subclass__(*args, **kwargs)
+
         if cls.__name__ == "_RuleNode":
             return
         cls.dataclass = cls.generate_node_dataclass(cls)
@@ -21,7 +25,7 @@ class RuleChain(dict[str, typing.Any]):
     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:
+    def __class_getitem__(cls, items: "ABCRule | tuple[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'."
@@ -32,13 +36,23 @@ class RuleChain(dict[str, typing.Any]):
         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
+    async def compose(cls, update: UpdateNode) -> typing.Any:
+        globalns = globals()
+        if "check_rule" not in globalns:
+            globalns.update(
+                {
+                    "check_rule": getattr(
+                        importlib.import_module("telegrinder.bot.dispatch.process"),
+                        "check_rule",
+                    ),
+                },
+            )
 
         ctx = Context()
         for rule in cls.rules:
             if not await check_rule(update.api, rule, update, ctx):
-                raise ComposeError
+                raise ComposeError(f"Rule {rule!r} failed!")
+
         try:
             return cls.dataclass(**ctx)  # type: ignore
         except Exception as exc:
@@ -49,7 +63,7 @@ class RuleChain(dict[str, typing.Any]):
         return cls
 
     @classmethod
-    def get_sub_nodes(cls) -> dict:
+    def get_subnodes(cls) -> dict:
         return {"update": UpdateNode}
 
     @classmethod

telegrinder/node/scope.py

@@ -33,4 +33,12 @@ def global_node(node: T) -> T:
     return node
 
 
-__all__ = ("NodeScope", "PER_EVENT", "PER_CALL", "per_call", "per_event", "global_node", "GLOBAL")
+__all__ = (
+    "NodeScope",
+    "PER_EVENT",
+    "PER_CALL",
+    "per_call",
+    "per_event",
+    "global_node",
+    "GLOBAL",
+)

telegrinder/node/source.py

@@ -1,18 +1,19 @@
 import dataclasses
 import typing
 
-from fntypes import Nothing, Option
+from fntypes.option import Nothing, Option
 
-from telegrinder.api import API
-from telegrinder.types import Chat, Message, User
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types import ChatJoinRequestCute
+from telegrinder.node.base import ComposeError, DataNode, ScalarNode
+from telegrinder.node.callback_query import CallbackQueryNode
+from telegrinder.node.event import EventNode
+from telegrinder.node.message import MessageNode
+from telegrinder.node.polymorphic import Polymorphic, impl
+from telegrinder.types.objects import Chat, Message, User
 
-from .base import ComposeError, DataNode, ScalarNode
-from .callback_query import CallbackQueryNode
-from .message import MessageNode
-from .polymorphic import Polymorphic, impl
 
-
-@dataclasses.dataclass(kw_only=True)
+@dataclasses.dataclass(kw_only=True, slots=True)
 class Source(Polymorphic, DataNode):
     api: API
     chat: Chat
@@ -24,7 +25,7 @@ class Source(Polymorphic, DataNode):
         return cls(
             api=message.ctx_api,
             chat=message.chat,
-            from_user=message.from_user,
+            from_user=message.from_.expect(ComposeError("MessageNode has no from_user")),
             thread_id=message.message_thread_id,
         )
 
@@ -32,11 +33,20 @@ class Source(Polymorphic, DataNode):
     async def compose_callback_query(cls, callback_query: CallbackQueryNode) -> typing.Self:
         return cls(
             api=callback_query.ctx_api,
-            chat=callback_query.chat.expect(ComposeError),
+            chat=callback_query.chat.expect(ComposeError("CallbackQueryNode has no chat")),
             from_user=callback_query.from_user,
             thread_id=callback_query.message_thread_id,
         )
 
+    @impl
+    async def compose_chat_join_request(cls, chat_join_request: EventNode[ChatJoinRequestCute]) -> typing.Self:
+        return cls(
+            api=chat_join_request.ctx_api,
+            chat=chat_join_request.chat,
+            from_user=chat_join_request.from_user,
+            thread_id=Nothing(),
+        )
+
     async def send(self, text: str) -> Message:
         result = await self.api.send_message(
             chat_id=self.chat.id,

telegrinder/node/text.py

@@ -1,12 +1,12 @@
-from .base import ComposeError, ScalarNode
-from .message import MessageNode
+from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.node.message import MessageNode
 
 
 class Text(ScalarNode, str):
     @classmethod
     async def compose(cls, message: MessageNode) -> str:
         if not message.text:
-            raise ComposeError("Message has no text")
+            raise ComposeError("Message has no text.")
         return message.text.unwrap()
 
 
@@ -14,7 +14,7 @@ class TextInteger(ScalarNode, int):
     @classmethod
     async def compose(cls, text: Text) -> int:
         if not text.isdigit():
-            raise ComposeError("Text is not digit")
+            raise ComposeError("Text is not digit.")
         return int(text)
 
 

telegrinder/node/update.py

@@ -1,12 +1,15 @@
+from telegrinder.api import API
 from telegrinder.bot.cute_types import UpdateCute
-
-from .base import ScalarNode
+from telegrinder.node.base import ScalarNode
+from telegrinder.types import Update
 
 
 class UpdateNode(ScalarNode, UpdateCute):
     @classmethod
-    async def compose(cls, update: UpdateCute) -> UpdateCute:
-        return update
+    async def compose(cls, update: Update, api: API) -> UpdateCute:
+        if isinstance(update, UpdateCute):
+            return update
+        return UpdateCute.from_update(update, api)
 
 
 __all__ = ("UpdateNode",)