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

telegrinder/node/composer.py

@@ -1,198 +1,163 @@
-import dataclasses
-import inspect
-import typing
-
-from fntypes.error import UnwrapError
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.update import Update, UpdateCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.modules import logger
-from telegrinder.node.base import (
-    ComposeError,
-    Name,
-    Node,
-    NodeScope,
-    get_node_calc_lst,
-    get_nodes,
-)
-from telegrinder.tools.magic import magic_bundle
-
-CONTEXT_STORE_NODES_KEY = "_node_ctx"
-GLOBAL_VALUE_KEY = "_value"
-
-
-async def compose_node(
-    _node: type[Node],
-    linked: dict[type, typing.Any],
-) -> "NodeSession":
-    node = _node.as_node()
-    kwargs = magic_bundle(node.compose, linked, typebundle=True)
-
-    if node.is_generator():
-        generator = typing.cast(typing.AsyncGenerator[typing.Any, None], node.compose(**kwargs))
-        value = await generator.asend(None)
-    else:
-        generator = None
-        value = typing.cast(typing.Awaitable[typing.Any] | typing.Any, node.compose(**kwargs))
-        if inspect.isawaitable(value):
-            value = await value
-
-    return NodeSession(_node, value, {}, generator)
-
-
-async def compose_nodes(
-    nodes: dict[str, type[Node]],
-    ctx: Context,
-    data: dict[type[typing.Any], typing.Any] | None = None,
-) -> Result["NodeCollection", ComposeError]:
-    logger.debug("Composing nodes: {!r}...", nodes)
-
-    local_nodes: dict[type[Node], NodeSession]
-    data = {Context: ctx} | (data or {})
-    parent_nodes: dict[type[Node], NodeSession] = {}
-    event_nodes: dict[type[Node], NodeSession] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
-    # TODO: optimize flattened list calculation via caching key = tuple of node types
-    calculation_nodes: dict[tuple[str, type[Node]], tuple[type[Node], ...]] = {
-        (node_name, node_t): tuple(get_node_calc_lst(node_t)) for node_name, node_t in nodes.items()
-    }
-
-    for (parent_node_name, parent_node_t), linked_nodes in calculation_nodes.items():
-        local_nodes = {}
-        subnodes = {}
-        data[Name] = parent_node_name
-
-        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, GLOBAL_VALUE_KEY):
-                local_nodes[node_t] = getattr(node_t, GLOBAL_VALUE_KEY)
-                continue
-
-            subnodes |= {
-                k: session.value for k, session in (local_nodes | event_nodes).items() if k not in subnodes
-            }
-
-            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:
-                event_nodes[node_t] = local_nodes[node_t]
-            elif scope is NodeScope.GLOBAL:
-                setattr(node_t, GLOBAL_VALUE_KEY, local_nodes[node_t])
-
-        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:
-    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!r}" + (" (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(scopes=scopes)
-
-        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", "_values")
-
-    def __init__(self, sessions: dict[str, NodeSession]) -> None:
-        self.sessions = sessions
-        self._values: dict[str, typing.Any] = {}
-
-    def __repr__(self) -> str:
-        return "<{}: sessions={!r}>".format(self.__class__.__name__, self.sessions)
-
-    @property
-    def values(self) -> dict[str, typing.Any]:
-        if self._values.keys() == self.sessions.keys():
-            return self._values
-
-        for name, session in self.sessions.items():
-            if name not in self._values:
-                self._values[name] = session.value
-
-        return self._values
-
-    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, scopes=scopes)
-
-
-@dataclasses.dataclass(slots=True, repr=False)
-class Composition:
-    func: typing.Callable[..., typing.Any]
-    is_blocking: bool
-    nodes: dict[str, type[Node]] = dataclasses.field(init=False)
-
-    def __post_init__(self) -> None:
-        self.nodes = get_nodes(self.func)
-
-    def __repr__(self) -> str:
-        return "<{}: for function={!r} with nodes={!r}>".format(
-            ("blocking " if self.is_blocking else "") + self.__class__.__name__,
-            self.func.__qualname__,
-            self.nodes,
-        )
-
-    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!r}")
-                return None
-
-    async def __call__(self, node_cls: type[Node], **kwargs: typing.Any) -> typing.Any:
-        result = self.func(node_cls, **magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))
-        if inspect.isawaitable(result):
-            result = await result
-        return result
-
-
-__all__ = ("Composition", "NodeCollection", "NodeSession", "compose_node", "compose_nodes")
+import dataclasses
+import inspect
+import typing
+
+from fntypes.error import UnwrapError
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.modules import logger
+from telegrinder.node.base import (
+    ComposeError,
+    IsNode,
+    Name,
+    NodeImpersonation,
+    NodeScope,
+    NodeType,
+    unwrap_node,
+)
+from telegrinder.tools.magic import join_dicts, magic_bundle
+
+type AsyncGenerator = typing.AsyncGenerator[typing.Any, None]
+
+CONTEXT_STORE_NODES_KEY = "_node_ctx"
+GLOBAL_VALUE_KEY = "_value"
+
+
+def get_scope(node: type[NodeType], /) -> NodeScope | None:
+    return getattr(node, "scope", None)
+
+
+async def compose_node(
+    node: type[NodeType],
+    linked: dict[type[typing.Any], typing.Any],
+    data: dict[type[typing.Any], typing.Any] | None = None,
+) -> "NodeSession":
+    subnodes = node.get_subnodes()
+    kwargs = magic_bundle(node.compose, join_dicts(subnodes, linked))
+
+    # Linking data via typebundle
+    if data:
+        kwargs.update(magic_bundle(node.compose, data, typebundle=True))
+
+    if node.is_generator():
+        generator = typing.cast(AsyncGenerator, node.compose(**kwargs))
+        value = await generator.asend(None)
+    else:
+        generator = None
+        value = node.compose(**kwargs)
+        if inspect.isawaitable(value):
+            value = await value
+
+    return NodeSession(node, value, subnodes={}, generator=generator)
+
+
+async def compose_nodes(
+    nodes: typing.Mapping[str, IsNode | NodeImpersonation],
+    ctx: Context,
+    data: dict[type[typing.Any], typing.Any] | None = None,
+) -> Result["NodeCollection", ComposeError]:
+    logger.debug("Composing nodes: ({})...", " ".join(f"{k}={v!r}" for k, v in nodes.items()))
+
+    data = {Context: ctx} | (data or {})
+    parent_nodes = dict[IsNode, NodeSession]()
+    event_nodes: dict[IsNode, NodeSession] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+    unwrapped_nodes = {(key, n := node.as_node()): unwrap_node(n) for key, node in nodes.items()}
+
+    for (parent_node_name, parent_node_t), linked_nodes in unwrapped_nodes.items():
+        local_nodes = dict[type[NodeType], NodeSession]()
+        subnodes = {}
+        data[Name] = parent_node_name
+
+        for node_t in linked_nodes:
+            scope = get_scope(node_t)
+
+            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, GLOBAL_VALUE_KEY):
+                local_nodes[node_t] = NodeSession(node_t, getattr(node_t, GLOBAL_VALUE_KEY), {})
+                continue
+
+            subnodes |= {
+                k: session.value for k, session in (local_nodes | event_nodes).items() if k not in subnodes
+            }
+            try:
+                local_nodes[node_t] = await compose_node(node_t, linked=subnodes, data=data)
+            except (ComposeError, UnwrapError) as exc:
+                for t, local_node in local_nodes.items():
+                    if get_scope(t) is NodeScope.PER_CALL:
+                        await local_node.close()
+                return Error(ComposeError(f"Cannot compose {node_t!r}, error: {str(exc)}"))
+
+            if scope is NodeScope.PER_EVENT:
+                event_nodes[node_t] = local_nodes[node_t]
+            elif scope is NodeScope.GLOBAL:
+                setattr(node_t, GLOBAL_VALUE_KEY, local_nodes[node_t].value)
+
+        parent_nodes[parent_node_t] = local_nodes[parent_node_t]
+
+    return Ok(NodeCollection({k: parent_nodes[t] for k, t in unwrapped_nodes}))
+
+
+@dataclasses.dataclass(slots=True, repr=False)
+class NodeSession:
+    node_type: type[NodeType] | 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!r}" + (" (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(scopes=scopes)
+
+        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", "_values")
+
+    def __init__(self, sessions: dict[str, NodeSession]) -> None:
+        self.sessions = sessions
+        self._values: dict[str, typing.Any] = {}
+
+    def __repr__(self) -> str:
+        return "<{}: sessions={!r}>".format(self.__class__.__name__, self.sessions)
+
+    @property
+    def values(self) -> dict[str, typing.Any]:
+        if self._values.keys() == self.sessions.keys():
+            return self._values
+
+        for name, session in self.sessions.items():
+            if name not in self._values:
+                self._values[name] = session.value
+
+        return self._values
+
+    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, scopes=scopes)
+
+
+__all__ = ("NodeCollection", "NodeSession", "compose_node", "compose_nodes")

telegrinder/node/container.py

@@ -1,27 +1,33 @@
-import typing
-
-from telegrinder.node.base import Node
-
-
-class ContainerNode(Node):
-    linked_nodes: typing.ClassVar[list[type[Node]]]
-
-    @classmethod
-    def compose(cls, **kw) -> tuple[Node, ...]:
-        return tuple(t[1] for t in sorted(kw.items(), key=lambda t: t[0]))
-
-    @classmethod
-    def get_subnodes(cls) -> dict[str, type[Node]]:
-        subnodes = getattr(cls, "subnodes", None)
-        if subnodes is None:
-            subnodes_dct = {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
-            setattr(cls, "subnodes", subnodes_dct)
-            return subnodes_dct
-        return subnodes
-
-    @classmethod
-    def link_nodes(cls, linked_nodes: list[type[Node]]) -> type["ContainerNode"]:
-        return type("_ContainerNode", (cls,), {"linked_nodes": linked_nodes})
-
-
-__all__ = ("ContainerNode",)
+import typing
+
+from telegrinder.node.base import IsNode, Node
+
+
+class ContainerNode(Node):
+    linked_nodes: typing.ClassVar[list[IsNode]]
+    composer: typing.Callable[..., typing.Awaitable[typing.Any]]
+
+    @classmethod
+    async def compose(cls, **kw: typing.Any) -> typing.Any:
+        subnodes = cls.get_subnodes().keys()
+        return await cls.composer(*tuple(t[1] for t in sorted(kw.items(), key=lambda t: t[0]) if t[0] in subnodes))
+
+    @classmethod
+    def get_subnodes(cls) -> dict[str, IsNode]:
+        subnodes = getattr(cls, "subnodes", None)
+        if subnodes is None:
+            subnodes_dct = {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
+            setattr(cls, "subnodes", subnodes_dct)
+            return subnodes_dct
+        return subnodes
+
+    @classmethod
+    def link_nodes(
+        cls,
+        linked_nodes: list[IsNode],
+        composer: typing.Callable[..., typing.Awaitable[typing.Any]],
+    ) -> type["ContainerNode"]:
+        return type(cls.__name__, (cls,), {"linked_nodes": linked_nodes, "composer": classmethod(composer)})
+
+
+__all__ = ("ContainerNode",)

telegrinder/node/either.py

@@ -0,0 +1,82 @@
+import typing
+
+from fntypes.result import Ok
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.base import ComposeError, FactoryNode, Node
+from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, GLOBAL_VALUE_KEY, compose_node, compose_nodes
+from telegrinder.node.scope import NodeScope, per_call
+from telegrinder.types.objects import Update
+
+
+@per_call
+class _Either(FactoryNode):
+    """Represents a node that either to compose `left` or `right` nodes.
+
+    For example:
+    ```python
+    # ScalarNode `Integer` -> int
+    # ScalarNode `Float` -> float
+
+    Number = Either[Integer, Float]  # using a type alias just as an example
+
+    def number_to_int(number: Number) -> int:
+        return int(number)
+    ```
+    """
+
+    nodes: tuple[type[Node], type[Node] | None]
+
+    def __class_getitem__(cls, node: type[Node] | tuple[type[Node], type[Node]], /):
+        nodes = (node, None) if not isinstance(node, tuple) else node
+        assert len(nodes) == 2, "Node `Either` must have at least two nodes."
+        return cls(nodes=nodes)
+
+    @classmethod
+    async def compose(cls, api: API, update: Update, context: Context) -> typing.Any | None:
+        data = {API: api, Update: update, Context: context}
+        node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+
+        for node in cls.nodes:
+            if node is None:
+                return None
+
+            if node.scope is NodeScope.PER_EVENT and node in node_ctx:
+                return node_ctx[node].value
+            elif node.scope is NodeScope.GLOBAL and hasattr(node, GLOBAL_VALUE_KEY):
+                return getattr(node, GLOBAL_VALUE_KEY)
+
+            subnodes = node.as_node().get_subnodes()
+            match await compose_nodes(subnodes, context, data):
+                case Ok(col):
+                    try:
+                        session = await compose_node(
+                            node=node,
+                            linked={
+                                typing.cast(type, n): col.sessions[name].value for name, n in subnodes.items()
+                            },
+                            data=data,
+                        )
+                    except ComposeError:
+                        continue
+
+                    if node.scope is NodeScope.PER_EVENT:
+                        node_ctx[node] = session
+                    elif node.scope is NodeScope.GLOBAL:
+                        setattr(node, GLOBAL_VALUE_KEY, session.value)
+
+                    return session.value
+
+        raise ComposeError("Cannot compose either nodes: {}.".format(", ".join(repr(n) for n in cls.nodes)))
+
+
+if typing.TYPE_CHECKING:
+    type Either[Left, Right: typing.Any | None] = Left | Right
+    type Optional[Left] = Either[Left, None]
+else:
+    Either = _Either
+    Optional = type("Optional", (Either,), {})
+
+
+__all__ = ("Either", "Optional")

telegrinder/node/event.py

@@ -1,65 +1,54 @@
-import dataclasses
-import typing
-
-import msgspec
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types import BaseCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.msgspec_utils import DataclassInstance, decoder
-from telegrinder.node.base import ComposeError, FactoryNode
-from telegrinder.node.update import UpdateNode
-
-if typing.TYPE_CHECKING:
-    Dataclass = typing.TypeVar("Dataclass", bound="DataclassType")
-
-    DataclassType: typing.TypeAlias = DataclassInstance | msgspec.Struct | dict[str, typing.Any]
-
-EVENT_NODE_KEY = "_event_node"
-
-
-class _EventNode(FactoryNode):
-    dataclass: type["DataclassType"]
-
-    def __class_getitem__(cls, dataclass: type["DataclassType"], /) -> typing.Self:
-        return cls(dataclass=dataclass)
-
-    @classmethod
-    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, BaseCute):
-                if isinstance(raw_update.incoming_update, dataclass_type):
-                    dataclass = raw_update.incoming_update
-                else:
-                    dataclass = dataclass_type.from_update(raw_update.incoming_update, bound_api=api)
-
-            elif issubclass(dataclass_type, msgspec.Struct | dict) or dataclasses.is_dataclass(
-                dataclass_type
-            ):
-                dataclass = decoder.convert(
-                    raw_update.incoming_update.to_full_dict(),
-                    type=cls.dataclass,
-                    str_keys=True,
-                )
-
-            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: {str(exc)!r}")
-
-
-if typing.TYPE_CHECKING:
-    EventNode: typing.TypeAlias = typing.Annotated["Dataclass", ...]
-
-else:
-
-    class EventNode(_EventNode):
-        pass
-
-
-__all__ = ("EventNode",)
+import dataclasses
+import typing
+
+import msgspec
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.msgspec_utils import decoder
+from telegrinder.node.base import ComposeError, FactoryNode
+from telegrinder.types.objects import Update
+
+if typing.TYPE_CHECKING:
+    from _typeshed import DataclassInstance
+
+type DataclassType = DataclassInstance | msgspec.Struct | dict[str, typing.Any]
+
+
+class _EventNode(FactoryNode):
+    dataclass: type[DataclassType]
+    orig_dataclass: type[DataclassType]
+
+    def __class_getitem__(cls, dataclass: type[DataclassType], /) -> typing.Self:
+        return cls(dataclass=dataclass, orig_dataclass=typing.get_origin(dataclass) or dataclass)
+
+    @classmethod
+    def compose(cls, raw_update: Update, api: API) -> DataclassType:
+        try:
+            if issubclass(cls.orig_dataclass, BaseCute):
+                update = raw_update if issubclass(cls.orig_dataclass, Update) else raw_update.incoming_update
+                dataclass = cls.orig_dataclass.from_update(update=update, bound_api=api)
+
+            elif issubclass(cls.orig_dataclass, msgspec.Struct) or dataclasses.is_dataclass(
+                cls.orig_dataclass,
+            ):
+                dataclass = decoder.convert(
+                    obj=raw_update.incoming_update,
+                    type=cls.dataclass,
+                    from_attributes=True,
+                )
+            else:
+                dataclass = cls.dataclass(**raw_update.incoming_update.to_full_dict())
+
+            return dataclass
+        except Exception as exc:
+            raise ComposeError(f"Cannot parse an update object into {cls.dataclass!r}, error: {str(exc)}")
+
+
+if typing.TYPE_CHECKING:
+    type EventNode[Dataclass: DataclassType] = Dataclass
+else:
+    EventNode = _EventNode
+
+
+__all__ = ("EventNode",)