telegrinder 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

telegrinder/node/composer.py

@@ -1,133 +1,144 @@
-import dataclasses
-import inspect
 import typing
+from collections import defaultdict
+from typing import Any
 
-from fntypes.error import UnwrapError
+from fntypes.option import Some
 from fntypes.result import Error, Ok, Result
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.modules import logger
 from telegrinder.node.base import (
+    AnyNode,
     ComposeError,
     IsNode,
     Name,
-    NodeImpersonation,
+    NodeClass,
     NodeScope,
-    NodeType,
+    as_node,
     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)
+from telegrinder.node.context import get_global_session, set_global_session
+from telegrinder.node.scope import get_scope
+from telegrinder.node.session import NodeSession
+from telegrinder.tools.aio import Generator, maybe_awaitable, next_generator
+from telegrinder.tools.fullname import fullname
+from telegrinder.tools.global_context.builtin_context import TelegrinderContext
+from telegrinder.tools.magic import bundle, get_func_annotations, join_dicts
+
+type ComposeGenerator = Generator[typing.Any, typing.Any, typing.Any]
+type Impls = dict[type[typing.Any], type[typing.Any]]
+
+CONTEXT_STORE_NODES_KEY: typing.Final[str] = "_node_ctx"
+GLOBAL_VALUE_KEY: typing.Final[str] = "_value"
+TELEGRINDER_CONTEXT: typing.Final[TelegrinderContext] = TelegrinderContext()
+
+
+def get_impls(
+    compose_function: typing.Callable[..., typing.Any],
+    impls: Impls,
+    /,
+) -> dict[str, typing.Any]:
+    return {
+        key: impls[tp]
+        for key, annotation in get_func_annotations(compose_function).items()
+        if typing.get_origin(annotation) is type
+        and (typing.get_origin(tp := typing.get_args(annotation)[0]) or tp) in impls
+    }
 
 
 async def compose_node(
-    node: type[NodeType],
+    node: IsNode,
     linked: dict[type[typing.Any], typing.Any],
     data: dict[type[typing.Any], typing.Any] | None = None,
+    impls: Impls | None = None,
 ) -> "NodeSession":
     subnodes = node.get_subnodes()
-    kwargs = magic_bundle(node.compose, join_dicts(subnodes, linked))
+    compose = bundle(node.compose, join_dicts(subnodes, linked), bundle_kwargs=True)
 
-    # Linking data via typebundle
     if data:
-        kwargs.update(magic_bundle(node.compose, data, typebundle=True))
+        compose &= bundle(node.compose, data, typebundle=True)
 
+    if impls:
+        compose &= bundle(node.compose, get_impls(node.compose, impls))
+
+    result = compose()
     if node.is_generator():
-        generator = typing.cast(AsyncGenerator, node.compose(**kwargs))
-        value = await generator.asend(None)
+        generator = typing.cast("ComposeGenerator", result)
+        value = await next_generator(generator)
     else:
         generator = None
-        value = node.compose(**kwargs)
-        if inspect.isawaitable(value):
-            value = await value
+        value = await maybe_awaitable(result)
 
-    return NodeSession(node, value, subnodes={}, generator=generator)
+    return NodeSession(node, value, generator)
 
 
 async def compose_nodes(
-    nodes: typing.Mapping[str, IsNode | NodeImpersonation],
+    nodes: typing.Mapping[str, AnyNode],
     ctx: Context,
     data: dict[type[typing.Any], typing.Any] | None = None,
+    impls: Impls | None = None,
 ) -> Result["NodeCollection", ComposeError]:
-    logger.debug("Composing nodes: ({})...", " ".join(f"{k}={v!r}" for k, v in nodes.items()))
-
+    impls = impls or TELEGRINDER_CONTEXT.composer.unwrap().selected_impls
     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()}
+    unwrapped_nodes = {(key, n := (as_node(node)), node): unwrap_node(n) for key, node in nodes.items()}
+
+    for (parent_node_name, parent_node_t, parent_original_type), linked_nodes in unwrapped_nodes.items():
+        data.update({Name: parent_node_name, NodeClass: parent_original_type})
 
-    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
+        local_nodes = LocalNodeCollection()
+        subnodes = dict[Any, Any]()
 
         for node_t in linked_nodes:
+            node_t = as_node(node_t)
             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), {})
+
+            if scope is NodeScope.GLOBAL and (global_session := get_global_session(node_t)) is not None:
+                local_nodes[node_t] = global_session
                 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)}"))
+                session = await compose_node(node_t, linked=subnodes, data=data, impls=impls)
+            except ComposeError as error:
+                await local_nodes.close_local_sessions()
+                return Error(ComposeError(f"Cannot compose node `{fullname(node_t)}`, error: {error.message!r}"))
+
+            if scope is NodeScope.PER_CALL:
+                await local_nodes.set_local_session(node_t, session)
+            else:
+                local_nodes[node_t] = session
 
             if scope is NodeScope.PER_EVENT:
-                event_nodes[node_t] = local_nodes[node_t]
+                event_nodes[node_t] = session
             elif scope is NodeScope.GLOBAL:
-                setattr(node_t, GLOBAL_VALUE_KEY, local_nodes[node_t].value)
+                set_global_session(node_t, session)
 
         parent_nodes[parent_node_t] = local_nodes[parent_node_t]
 
-    return Ok(NodeCollection({k: parent_nodes[t] for k, t in unwrapped_nodes}))
+    return Ok(NodeCollection(sessions={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 ">")
+class LocalNodeCollection(dict[IsNode, NodeSession]):
+    def __init__(self) -> None:
+        super().__init__()
 
-    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
+    async def set_local_session(self, node: IsNode, session: NodeSession, /) -> NodeSession:
+        if node in self:
+            await self[node].close()
 
-        for subnode in self.subnodes.values():
-            await subnode.close(scopes=scopes)
+        self[node] = session
+        return session
 
-        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
+    async def close_local_sessions(self) -> None:
+        for session in self.values():
+            await session.close(scopes=(NodeScope.PER_CALL,))
 
 
 class NodeCollection:
@@ -138,7 +149,7 @@ class NodeCollection:
         self._values: dict[str, typing.Any] = {}
 
     def __repr__(self) -> str:
-        return "<{}: sessions={!r}>".format(self.__class__.__name__, self.sessions)
+        return "<{}: sessions={!r}>".format(type(self).__name__, self.sessions)
 
     @property
     def values(self) -> dict[str, typing.Any]:
@@ -160,4 +171,42 @@ class NodeCollection:
             await session.close(with_value, scopes=scopes)
 
 
-__all__ = ("NodeCollection", "NodeSession", "compose_node", "compose_nodes")
+class Composer:
+    impls: dict[type[typing.Any], set[typing.Any]]
+    selected_impls: Impls
+
+    def __init__(self) -> None:
+        self.impls = defaultdict(set)
+        self.selected_impls = dict()
+
+    def __setitem__(self, for_type: typing.Any, impl: type[typing.Any], /) -> None:
+        for_type = typing.get_origin(for_type) or for_type
+
+        if for_type not in self.impls:
+            raise LookupError(f"No impls defined for type of `{fullname(for_type)}`.")
+
+        if (typing.get_origin(impl) or impl) not in self.impls[for_type]:
+            raise LookupError(f"Impl `{fullname(impl)}` is not defined for type of `{fullname(for_type)}`.")
+
+        self.selected_impls[for_type] = impl
+
+    def impl[T](self, for_type: typing.Any, /) -> typing.Callable[[type[T]], type[T]]:
+        def decorator(impl: type[T], /) -> type[T]:
+            self.impls[typing.get_origin(for_type) or for_type].add(impl)
+            return impl
+
+        return decorator
+
+    async def compose_nodes(
+        self,
+        nodes: typing.Mapping[str, AnyNode],
+        ctx: Context,
+        data: dict[type[typing.Any], typing.Any] | None = None,
+    ) -> Result[NodeCollection, ComposeError]:
+        return await compose_nodes(nodes, ctx, data, self.selected_impls)
+
+
+TELEGRINDER_CONTEXT.composer = Some(Composer())
+
+
+__all__ = ("Composer", "NodeCollection", "compose_node", "compose_nodes")

telegrinder/node/container.py

@@ -7,6 +7,8 @@ class ContainerNode(Node):
     linked_nodes: typing.ClassVar[list[IsNode]]
     composer: typing.Callable[..., typing.Awaitable[typing.Any]]
 
+    __subnodes__: typing.ClassVar[dict[str, IsNode] | None] = None
+
     @classmethod
     async def compose(cls, **kw: typing.Any) -> typing.Any:
         subnodes = cls.get_subnodes().keys()
@@ -14,20 +16,21 @@ class ContainerNode(Node):
 
     @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
+        if cls.__subnodes__ is None:
+            cls.__subnodes__ = {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes, start=1)}
+        return cls.__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)})
+    ) -> type[typing.Self]:
+        return type(
+            cls.__name__,
+            (cls,),
+            {"linked_nodes": linked_nodes, "composer": classmethod(composer), "__module__": __name__},
+        )  # type: ignore
 
 
 __all__ = ("ContainerNode",)

telegrinder/node/context.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import typing
+
+from telegrinder.node.scope import NodeScope
+from telegrinder.tools.global_context import GlobalContext, ctx_var
+from telegrinder.tools.global_context.builtin_context import TelegrinderContext
+
+if typing.TYPE_CHECKING:
+    from telegrinder.node.base import IsNode
+    from telegrinder.node.composer import NodeSession
+
+TELEGRINDER_CONTEXT: typing.Final[TelegrinderContext] = TelegrinderContext()
+
+
+class NodeGlobalContext(GlobalContext):
+    __ctx_name__ = "node_context"
+
+    global_sessions: dict[IsNode, NodeSession] = ctx_var(
+        const=True,
+        init=False,
+        default_factory=dict,
+    )
+
+    async def close_global_scopes(self) -> None:
+        for session in self.global_sessions.values():
+            await session.close(scopes=(NodeScope.GLOBAL,))
+
+        self.global_sessions.clear()
+
+
+def get_global_session(node: IsNode, /) -> NodeSession | None:
+    return NODE_CONTEXT.global_sessions.get(node)
+
+
+def set_global_session(node: IsNode, session: NodeSession, /) -> None:
+    NODE_CONTEXT.global_sessions[node] = session
+
+
+@TELEGRINDER_CONTEXT.loop_wrapper.lifespan.on_shutdown
+async def close_nodes_global_scopes() -> None:
+    await NODE_CONTEXT.close_global_scopes()
+
+
+NODE_CONTEXT: typing.Final[NodeGlobalContext] = NodeGlobalContext()
+
+
+__all__ = ("NODE_CONTEXT", "NodeGlobalContext", "get_global_session", "set_global_session")

telegrinder/node/either.py

@@ -4,9 +4,10 @@ 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.node.base import ComposeError, FactoryNode, IsNode
+from telegrinder.node.composer import compose_nodes
+from telegrinder.node.scope import per_call
+from telegrinder.tools.fullname import fullname
 from telegrinder.types.objects import Update
 
 
@@ -26,57 +27,43 @@ class _Either(FactoryNode):
     ```
     """
 
-    nodes: tuple[type[Node], type[Node] | None]
+    nodes: tuple[IsNode, IsNode | None]
 
-    def __class_getitem__(cls, node: type[Node] | tuple[type[Node], type[Node]], /):
+    def __class_getitem__(cls, node: IsNode | tuple[IsNode, IsNode], /) -> typing.Any:
         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, {})
+    async def compose(cls, api: API, update: Update, context: Context) -> typing.Any:
+        composed = True
 
         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 node is not None:
+                match await compose_nodes(dict(node_result=node), context, {API: api, Update: update}):
+                    case Ok(col):
+                        value = col.values["node_result"]
+                        yield value
+                        await col.close_all(with_value=value)
+                        break
+                    case _:
+                        composed = False
+            else:
+                yield None
+                break
+
+        if not composed:
+            raise ComposeError(
+                "Cannot compose either nodes: {}.".format(", ".join(fullname(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,), {})
+    Either = type("Either", (_Either,), {"__module__": __name__})
+    Optional = type("Optional", (_Either,), {"__module__": __name__})
 
 
 __all__ = ("Either", "Optional")

telegrinder/node/error.py

@@ -0,0 +1,41 @@
+import dataclasses
+
+import typing_extensions as typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.base import ComposeError, DataNode
+from telegrinder.node.utility import TypeArgs
+
+type ExceptionType = type[BaseException]
+
+ExceptionT = typing.TypeVar("ExceptionT", bound=BaseException, default=BaseException)
+ExceptionTs = typing.TypeVarTuple("ExceptionTs", default=typing.Unpack[tuple[BaseException, ...]])
+
+
+def can_catch[ExceptionT: BaseException](
+    exc: BaseException | ExceptionType,
+    exc_types: type[ExceptionT] | tuple[type[ExceptionT], ...],
+) -> typing.TypeGuard[ExceptionT]:
+    return issubclass(exc, exc_types) if isinstance(exc, type) else isinstance(exc, exc_types)
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class Error(DataNode, typing.Generic[*ExceptionTs]):
+    exception_update: BaseException
+
+    @property
+    def exception(self: "Error[*tuple[ExceptionT, ...]]") -> ExceptionT:
+        return self.exception_update  # type: ignore
+
+    @classmethod
+    def compose(cls, ctx: Context, type_args: TypeArgs) -> typing.Self:
+        exception = ctx.exception_update.expect(ComposeError("No exception."))
+        exception_types: tuple[ExceptionType, ...] | None = type_args.get(ExceptionTs)
+
+        if exception_types is None or can_catch(exception, exception_types):
+            return cls(exception_update=exception)
+
+        raise ComposeError("Foreign exception.")
+
+
+__all__ = ("Error",)

telegrinder/node/event.py

@@ -2,12 +2,16 @@ import dataclasses
 import typing
 
 import msgspec
+from fntypes.option import Some
 
 from telegrinder.api.api import API
-from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.context import Context
 from telegrinder.msgspec_utils import decoder
-from telegrinder.node.base import ComposeError, FactoryNode
-from telegrinder.types.objects import Update
+from telegrinder.node.base import ComposeError, FactoryNode, scalar_node
+from telegrinder.tools.fullname import fullname
+from telegrinder.types.objects import Model, Update
 
 if typing.TYPE_CHECKING:
     from _typeshed import DataclassInstance
@@ -15,6 +19,17 @@ if typing.TYPE_CHECKING:
 type DataclassType = DataclassInstance | msgspec.Struct | dict[str, typing.Any]
 
 
+@scalar_node
+class UpdateNode:
+    @classmethod
+    def compose(cls, update: Update, api: API, context: Context) -> UpdateCute:
+        match context.update_cute:
+            case Some(update_cute):
+                return update_cute
+            case _:
+                return context.add_update_cute(update, api).update_cute.unwrap()
+
+
 class _EventNode(FactoryNode):
     dataclass: type[DataclassType]
     orig_dataclass: type[DataclassType]
@@ -23,13 +38,24 @@ class _EventNode(FactoryNode):
         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)
+    def compose(cls, update_cute: UpdateNode, raw_update: Update, api: API) -> DataclassType:
+        if cls.orig_dataclass is UpdateCute:
+            return update_cute
 
-            elif issubclass(cls.orig_dataclass, msgspec.Struct) or dataclasses.is_dataclass(
+        if issubclass(cls.orig_dataclass, BaseCute | Model):
+            incoming_update = (
+                update_cute.incoming_update
+                if issubclass(cls.orig_dataclass, BaseCute)
+                else raw_update.incoming_update
+            )
+
+            if type(incoming_update) is not cls.orig_dataclass:
+                raise ComposeError(f"Incoming update is not `{fullname(cls.orig_dataclass)}`.")
+
+            return incoming_update
+
+        try:
+            if issubclass(cls.orig_dataclass, msgspec.Struct) or dataclasses.is_dataclass(
                 cls.orig_dataclass,
             ):
                 dataclass = decoder.convert(
@@ -42,13 +68,13 @@ class _EventNode(FactoryNode):
 
             return dataclass
         except Exception as exc:
-            raise ComposeError(f"Cannot parse an update object into {cls.dataclass!r}, error: {str(exc)}")
+            raise ComposeError(f"Cannot parse an update object into `{fullname(cls.dataclass)}`, error: {exc}")
 
 
 if typing.TYPE_CHECKING:
     type EventNode[Dataclass: DataclassType] = Dataclass
 else:
-    EventNode = _EventNode
+    EventNode = type("EventNode", (_EventNode,), {"__module__": __name__})
 
 
 __all__ = ("EventNode",)

telegrinder/node/exceptions.py

@@ -0,0 +1,7 @@
+class ComposeError(BaseException):
+    def __init__(self, message: str = "<no error description>", /) -> None:
+        self.message = message
+        super().__init__(message)
+
+
+__all__ = ("ComposeError",)