telegrinder 0.3.0.post2__py3-none-any.whl → 0.3.2__py3-none-any.whl

telegrinder/node/composer.py

@@ -1,184 +1,196 @@
-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,
-    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)
-
-    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, 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()}
-
-            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])
-
-        # 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:
-    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",)
-
-    def __init__(self, sessions: dict[str, NodeSession]) -> None:
-        self.sessions = sessions
-
-    def __repr__(self) -> str:
-        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()}
-
-    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, **kwargs: typing.Any) -> typing.Any:
-        return await self.func(**magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))
-
-
-__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.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,
+    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[type[Node], tuple[type[Node], ...]] = {
+        node_t: tuple(get_node_calc_lst(node_t)) for node_t in nodes.values()
+    }
+
+    for parent_node, linked_nodes in calculation_nodes.items():
+        local_nodes = {}
+        subnodes = {}
+
+        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] = local_nodes[parent_node]
+
+    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")

telegrinder/node/container.py

@@ -1,27 +1,27 @@
-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 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",)

telegrinder/node/event.py

@@ -1,73 +1,71 @@
-import dataclasses
-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, decoder
-from telegrinder.node.base import ComposeError, Node
-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(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
-    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):
-                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) or dataclasses.is_dataclass(dataclass_type):
-                # FIXME: must be used with rename_field
-                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: {exc}")
-
-
-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.bot.dispatch.context import Context
+from telegrinder.msgspec_utils import DataclassInstance, decoder
+from telegrinder.node.base import ComposeError, Node
+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(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
+    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",)

telegrinder/node/me.py

@@ -1,16 +1,16 @@
-from telegrinder.api.api import API
-from telegrinder.node.base import ComposeError, ScalarNode
-from telegrinder.node.scope import GLOBAL
-from telegrinder.types.objects import User
-
-
-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"))
-
-
-__all__ = ("Me",)
+from telegrinder.api.api import API
+from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.node.scope import GLOBAL
+from telegrinder.types.objects import User
+
+
+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"))
+
+
+__all__ = ("Me",)

telegrinder/node/message.py

@@ -1,14 +1,14 @@
-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
-    def compose(cls, update: UpdateNode) -> MessageCute:
-        if not update.message:
-            raise ComposeError("Update is not a message.")
-        return update.message.unwrap()
-
-
-__all__ = ("MessageNode",)
+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
+    def compose(cls, update: UpdateNode) -> MessageCute:
+        if not update.message:
+            raise ComposeError("Update is not a message.")
+        return update.message.unwrap()
+
+
+__all__ = ("MessageNode",)