hgraph 0.3.14__py3-none-any.whl

hgraph/__init__.py

@@ -0,0 +1,7 @@
+from hgraph._builder import *
+from hgraph._operators import *
+from hgraph._runtime import *
+from hgraph._types import *
+from hgraph._wiring import *
+from hgraph._impl import *
+

hgraph/_builder/__init__.py

@@ -0,0 +1,7 @@
+from hgraph._builder._builder import *
+from hgraph._builder._graph_builder import *
+from hgraph._builder._input_builder import *
+from hgraph._builder._node_builder import *
+from hgraph._builder._output_builder import *
+from hgraph._builder._scalar_builder import *
+from hgraph._builder._ts_builder import *

hgraph/_builder/_builder.py

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar, Generic
+
+ITEM = TypeVar("ITEM")
+
+__all__ = ("Builder",)
+
+
+class Builder(ABC, Generic[ITEM]):
+    """
+    The builder is responsible for constructing and initialising the item type it is responsible for.
+    It is also responsible for destroying and cleaning up the resources associated to the item.
+    These can be thought of as life-cycle methods.
+    """
+
+    @abstractmethod
+    def make_instance(self, **kwargs) -> ITEM:
+        """
+        Create a new instance of the item.
+        And additional attributes required for construction are passed in as kwargs.
+        Actual instance of the builder will fix these args for all instances of builder for the type.
+        """
+
+    @abstractmethod
+    def release_instance(self, item: ITEM):
+        """
+        Release the item and it's resources.
+        """

hgraph/_builder/_graph_builder.py

@@ -0,0 +1,92 @@
+import typing
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Iterable
+
+from hgraph._builder._builder import Builder
+
+if typing.TYPE_CHECKING:
+    from hgraph._runtime._graph import Graph
+    from hgraph._runtime._node import Node
+    from hgraph._builder._node_builder import NodeBuilder
+    from hgraph._types._scalar_types import SCALAR
+
+__all__ = ("Edge", "GraphBuilder", "GraphBuilderFactory")
+
+
+@dataclass(frozen=True)
+class Edge:
+    src_node: int
+    output_path: tuple["SCALAR", ...]
+    dst_node: int
+    input_path: tuple["SCALAR", ...]
+
+
+@dataclass(frozen=True)
+class GraphBuilder(Builder["Graph"]):
+    node_builders: tuple["NodeBuilder", ...]
+    edges: tuple[Edge, ...]
+
+    @abstractmethod
+    def make_instance(self, graph_id: tuple[int, ...], parent_node: "Node" = None, label: str = None) -> "Graph":
+        """
+        Construct an instance of a graph. The id provided is the id for the graph instance to be constructed.
+        """
+
+    @abstractmethod
+    def make_and_connect_nodes(self, graph_id: tuple[int, ...], first_node_ndx: int) -> Iterable["Node"]:
+        """
+        Make the nodes described in the node builders and connect the edges as described in the edges.
+        Return the iterable of newly constructed and wired nodes.
+        This can be used to feed into a new graph instance or to extend (or re-initialise) an existing graph.
+        """
+
+    @abstractmethod
+    def release_instance(self, item: "Graph"):
+        """
+        Release resources constructed during the build process, plus the graph.
+        """
+
+
+class GraphBuilderFactory:
+
+    _graph_builder_class: typing.Optional[typing.Type[GraphBuilder]] = None
+
+    @staticmethod
+    def default():
+        from hgraph._impl._builder._graph_builder import PythonGraphBuilder
+
+        return PythonGraphBuilder
+
+    @staticmethod
+    def is_declared() -> bool:
+        return GraphBuilderFactory._graph_builder_class is not None
+
+    @staticmethod
+    def declared() -> typing.Type[GraphBuilder]:
+        if GraphBuilderFactory._graph_builder_class is None:
+            raise RuntimeError("No graph builder type has been declared")
+        return GraphBuilderFactory._graph_builder_class
+
+    @staticmethod
+    def declare(cls: typing.Type[GraphBuilder]):
+        if GraphBuilderFactory._graph_builder_class is not None:
+            raise RuntimeError("A graph builder type has already been declared")
+        GraphBuilderFactory._graph_builder_class = cls
+
+    @staticmethod
+    def un_declare():
+        GraphBuilderFactory._graph_builder_class = None
+
+    @staticmethod
+    def make(node_builders: tuple["NodeBuilder", ...], edges: tuple[Edge, ...]) -> GraphBuilder:
+        """
+        Make a graph builder instance. If no graph builder class is declared, the default builder will be used.
+        :param node_builders: The node builders to use
+        :param edges: The edges to use for binding the node outputs to inputs.
+        :return: The GraphBuilder instance.
+        """
+        if GraphBuilderFactory.is_declared():
+            return GraphBuilderFactory.declared()(node_builders=node_builders, edges=edges)
+        else:
+            return GraphBuilderFactory.default()(node_builders=node_builders, edges=edges)

hgraph/_builder/_input_builder.py

@@ -0,0 +1,19 @@
+import typing
+
+from hgraph._builder._builder import Builder
+
+if typing.TYPE_CHECKING:
+    from hgraph._types._time_series_types import TimeSeriesInput
+    from hgraph._runtime._node import Node
+
+__all__ = ("InputBuilder",)
+
+
+class InputBuilder(Builder["TimeSeriesInput"]):
+
+    def make_instance(self, owning_node: "Node" = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        """One of owning_node or owning_input must be defined."""
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        raise NotImplementedError()

hgraph/_builder/_node_builder.py

@@ -0,0 +1,38 @@
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Optional, Any, Mapping, TypeVar
+
+from hgraph._builder._builder import Builder
+from hgraph._builder._input_builder import InputBuilder
+from hgraph._builder._output_builder import OutputBuilder
+from hgraph._runtime._node import NodeSignature, Node
+
+__all__ = ("NodeBuilder",)
+
+
+NODE = TypeVar("NODE", bound=Node)
+
+
+@dataclass(frozen=True)
+class NodeBuilder(Builder[NODE]):
+    signature: NodeSignature
+    scalars: Mapping[str, Any]
+    input_builder: Optional[InputBuilder] = None
+    output_builder: Optional[OutputBuilder] = None
+    error_builder: Optional[OutputBuilder] = None
+
+    @abstractmethod
+    def make_instance(self, owning_graph_id: tuple[int, ...], node_ndx) -> NODE:
+        """
+        Construct an instance of a node. The id provided is the id for the node instance to be constructed.
+        """
+
+    @abstractmethod
+    def release_instance(self, item: NODE):
+        """
+        Release any resources constructed during the build process, plus the node.
+        """
+
+
+# TODO: Need to ensure that each type of NodeBuilder is described in the abstract and a factory is provided
+#       to provide instances of the builder to allow us to support multiple engines.

hgraph/_builder/_output_builder.py

@@ -0,0 +1,20 @@
+from typing import TYPE_CHECKING
+
+from hgraph._builder._builder import Builder
+
+if TYPE_CHECKING:
+    from hgraph._runtime._node import Node
+    from hgraph._types._time_series_types import TimeSeriesOutput
+
+
+__all__ = ("OutputBuilder",)
+
+
+class OutputBuilder(Builder["TimeSeriesOutput"]):
+
+    def make_instance(self, owning_node: "Node" = None, owning_output: "TimeSeriesOutput" = None) -> "TimeSeriesOutput":
+        """One of owning_node or owning_output must be defined."""
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        raise NotImplementedError()

hgraph/_builder/_scalar_builder.py

@@ -0,0 +1,19 @@
+from typing import TYPE_CHECKING
+
+from hgraph._builder._builder import Builder
+
+if TYPE_CHECKING:
+    from hgraph._types._scalar_value import ScalarValue
+
+
+__all__ = ("ScalarValueBuilder",)
+
+
+class ScalarValueBuilder(Builder["ScalarValue"]):
+
+    def make_instance(self) -> "ScalarValue":
+        """A scalar value is a basic type"""
+        raise NotImplementedError()
+
+    def release_instance(self, item: "ScalarValue"):
+        raise NotImplementedError()

hgraph/_builder/_ts_builder.py

@@ -0,0 +1,244 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional, TYPE_CHECKING
+
+from _pytest.nodes import Node
+
+from hgraph._types._tsl_meta_data import HgTSLTypeMetaData
+from hgraph._builder._input_builder import InputBuilder
+from hgraph._builder._output_builder import OutputBuilder
+from hgraph._types._tsd_meta_data import HgTSDTypeMetaData
+
+if TYPE_CHECKING:
+    from hgraph._types._scalar_type_meta_data import HgScalarTypeMetaData
+    from hgraph._types._time_series_meta_data import HgTimeSeriesTypeMetaData
+    from hgraph._types._time_series_types import TimeSeriesInput, TimeSeriesOutput
+    from hgraph._types._tsb_type import TimeSeriesSchema
+
+__all__ = (
+    "TSOutputBuilder",
+    "TSInputBuilder",
+    "TimeSeriesBuilderFactory",
+    "TSSInputBuilder",
+    "TSLOutputBuilder",
+    "TSLInputBuilder",
+    "TSBOutputBuilder",
+    "TSBInputBuilder",
+    "TSSOutputBuilder",
+    "TSSInputBuilder",
+    "TSSignalInputBuilder",
+    "TSDOutputBuilder",
+    "TSDInputBuilder",
+)
+
+"""
+This file contains the base signatures for the time-series builders. The implementation needs to provide
+valid instances of each of these signatures and the factory should be provided to resolved an instance of the
+template to the appropriate builder instance.
+
+This is here to allow us to write generic wiring logic that will allow for multiple implementations of the engine.
+"""
+
+
+@dataclass(frozen=True)
+class TSOutputBuilder(OutputBuilder):
+
+    value_tp: "HgScalarTypeMetaData"
+
+    def make_instance(self, owning_node=None, owning_output=None) -> "TimeSeriesOutput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        raise NotImplementedError()
+
+
+@dataclass(frozen=True)
+class TSInputBuilder(InputBuilder):
+
+    value_tp: "HgScalarTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        raise NotImplementedError()
+
+
+class TSSignalInputBuilder(InputBuilder):
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        raise NotImplementedError()
+
+
+@dataclass(frozen=True)
+class TSBInputBuilder(InputBuilder):
+
+    schema: "TimeSeriesSchema"
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        raise NotImplementedError()
+
+
+@dataclass(frozen=True)
+class TSBOutputBuilder(OutputBuilder):
+
+    schema: "TimeSeriesSchema"
+
+    def make_instance(self, owning_node: Node = None, owning_output: "TimeSeriesOutput" = None) -> "TimeSeriesOutput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        raise NotImplementedError()
+
+
+@dataclass(frozen=True)
+class TSLInputBuilder(InputBuilder):
+
+    value_tp: "HgTimeSeriesTypeMetaData"
+    size_tp: "HgScalarTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        raise NotImplementedError()
+
+
+@dataclass(frozen=True)
+class TSLOutputBuilder(OutputBuilder):
+
+    value_tp: "HgTimeSeriesTypeMetaData"
+    size_tp: "HgScalarTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_output: "TimeSeriesOutput" = None) -> "TimeSeriesOutput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        raise NotImplementedError()
+
+
+class TSDInputBuilder(InputBuilder):
+
+    key_tp: "HgScalarTypeMetaData"
+    value_tp: "HgTimeSeriesTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        raise NotImplementedError()
+
+
+@dataclass(frozen=True)
+class TSDOutputBuilder(OutputBuilder):
+
+    key_tp: "HgScalarTypeMetaData"
+    value_tp: "HgTimeSeriesTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_output: "TimeSeriesOutput" = None) -> "TimeSeriesOutput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        raise NotImplementedError()
+
+
+@dataclass(frozen=True)
+class TSSOutputBuilder(OutputBuilder):
+
+    value_tp: "HgScalarTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_output: "TimeSeriesOutput" = None) -> "TimeSeriesOutput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        raise NotImplementedError()
+
+
+@dataclass(frozen=True)
+class TSSInputBuilder(InputBuilder):
+
+    value_tp: "HgScalarTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        raise NotImplementedError()
+
+
+class REFInputBuilder(InputBuilder):
+    value_tp: "HgTimeSeriesTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        raise NotImplementedError()
+
+
+@dataclass(frozen=True)
+class REFOutputBuilder(OutputBuilder):
+    value_tp: "HgTimeSeriesTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_output: "TimeSeriesOutput" = None) -> "TimeSeriesOutput":
+        raise NotImplementedError()
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        raise NotImplementedError()
+
+
+class TimeSeriesBuilderFactory:
+
+    _instance: Optional["TimeSeriesBuilderFactory"] = None
+
+    @staticmethod
+    def declare_default_factory():
+        from hgraph._impl._builder._ts_builder import PythonTimeSeriesBuilderFactory
+
+        TimeSeriesBuilderFactory.declare(PythonTimeSeriesBuilderFactory())
+
+    @staticmethod
+    def has_instance() -> bool:
+        return TimeSeriesBuilderFactory._instance is not None
+
+    @staticmethod
+    def instance() -> "TimeSeriesBuilderFactory":
+        if TimeSeriesBuilderFactory._instance is None:
+            raise RuntimeError("No time-series builder factory has been declared")
+        return TimeSeriesBuilderFactory._instance
+
+    @staticmethod
+    def declare(factory: "TimeSeriesBuilderFactory"):
+        if TimeSeriesBuilderFactory._instance is not None:
+            raise RuntimeError("A time-series builder factory has already been declared")
+        TimeSeriesBuilderFactory._instance = factory
+
+    @staticmethod
+    def un_declare():
+        TimeSeriesBuilderFactory._instance = None
+
+    @abstractmethod
+    def make_input_builder(self, value_tp: "HgTimeSeriesTypeMetaData") -> TSInputBuilder:
+        """Return an instance of an input builder for the given type"""
+
+    @abstractmethod
+    def make_output_builder(self, value_tp: "HgTimeSeriesTypeMetaData") -> TSOutputBuilder:
+        """Return an instance of an output builder for the given type"""
+
+    def make_error_builder(self, error_tp: "HgTimeSeriesTypeMetaData") -> TSOutputBuilder:
+        """
+        Return an instance of an output builder for the error type.
+        Since the error type is fixed, this does not require a type.
+        Additionally, since this is defined in terms of an abstract method,
+        we can implement directly.
+
+        The node may require a collection type output. The is_tsd and scalar_tp arguments should be provided
+        if the node requires a tsd or is_tsl and size_tp arguments are required if the node requires a list type.
+        """
+        return self.make_output_builder(error_tp)

hgraph/_impl/__init__.py

@@ -0,0 +1,5 @@
+from hgraph._impl._builder import *
+from hgraph._impl._operators import *
+from hgraph._impl._runtime import *
+from hgraph._impl._types import *
+from hgraph._impl._impl_configuration import *

hgraph/_impl/_builder/__init__.py

@@ -0,0 +1,7 @@
+from hgraph._impl._builder._graph_builder import *
+from hgraph._impl._builder._map_builder import *
+from hgraph._impl._builder._node_builder import *
+from hgraph._impl._builder._node_impl_builder import *
+from hgraph._impl._builder._reduce_builder import *
+from hgraph._impl._builder._switch_builder import *
+from hgraph._impl._builder._ts_builder import *

hgraph/_impl/_builder/_component_builder.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Optional, Mapping
+
+from hgraph._impl._builder._node_builder import PythonBaseNodeBuilder
+
+
+@dataclass(frozen=True)
+class PythonComponentNodeBuilder(PythonBaseNodeBuilder):
+    nested_graph: Optional["GraphBuilder"] = None  # This is the generator function
+    # The nodes representing the stub inputs in the nested graph.
+    input_node_ids: Mapping[str, int] | None = None
+    output_node_id: int | None = None  # The node representing the stub output in the nested graph.
+
+    def make_instance(self, owning_graph_id: tuple[int, ...], node_ndx: int) -> "PythonTryExceptNodeImpl":
+        from hgraph._impl._runtime._component_node import PythonComponentNodeImpl
+
+        node = PythonComponentNodeImpl(
+            node_ndx=node_ndx,
+            owning_graph_id=owning_graph_id,
+            signature=self.signature,
+            scalars=self.scalars,
+            nested_graph_builder=self.nested_graph,
+            input_node_ids=self.input_node_ids,
+            output_node_id=self.output_node_id,
+        )
+
+        return self._build_inputs_and_outputs(node)
+
+    def release_instance(self, item: "PythonTryExceptNodeImpl"):
+        """Nothing to be done here"""

hgraph/_impl/_builder/_graph_builder.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass
+from typing import Iterable
+
+from hgraph._builder._graph_builder import GraphBuilder
+from hgraph._impl._runtime._graph import PythonGraph
+from hgraph._runtime._graph import Graph
+from hgraph._runtime._node import Node
+
+__all__ = ("PythonGraphBuilder",)
+
+
+@dataclass(frozen=True)
+class PythonGraphBuilder(GraphBuilder):
+    """
+    Builds a graph (set of nodes with edges)
+    """
+
+    @staticmethod
+    def _extract_output(node: Node, path: [int]):
+        if not path:
+            raise RuntimeError("No path to find an output for")
+        output = node.output
+        for item in path:
+            output = output[item]
+        return output
+
+    @staticmethod
+    def _extract_input(node: Node, path: [int]):
+        if not path:
+            raise RuntimeError("No path to find an input for")
+        input_ = node.input
+        for item in path:
+            input_ = input_[item]
+        return input_
+
+    def make_instance(self, graph_id: tuple[int, ...], parent_node: Node = None, label: str = "") -> Graph:
+        nodes = self.make_and_connect_nodes(graph_id, 0)
+        # The nodes are initialised within the context of the graph
+        return PythonGraph(graph_id=graph_id, nodes=nodes, parent_node=parent_node, label=label)
+
+    def make_and_connect_nodes(self, graph_id: tuple[int, ...], first_node_ndx: int) -> Iterable[Node]:
+        nodes = [nb.make_instance(graph_id, ndx + first_node_ndx) for ndx, nb in enumerate(self.node_builders)]
+        for edge in self.edges:
+            src_node: Node = nodes[edge.src_node]
+            dst_node: Node = nodes[edge.dst_node]
+            # TODO: Should we normalise outputs to always be an UnnamedBundleOutput? For now if the path is tuple() assume
+            #  the output is the node output [This would be useful dealing with special outputs like error.
+            if edge.output_path == (-1,):
+                # This is an error handler
+                output = src_node.error_output
+            else:
+                output = (
+                    src_node.output if edge.output_path == tuple() else self._extract_output(src_node, edge.output_path)
+                )
+            input_ = self._extract_input(dst_node, edge.input_path)
+            input_.bind_output(output)
+        return nodes
+
+    def release_instance(self, item: Graph):
+        for node, node_builder in zip(item.nodes, self.node_builders):
+            node_builder.release_instance(node)
+        item.dispose()
+
+    def __hash__(self):
+        return hash(id(self))

hgraph/_impl/_builder/_map_builder.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Mapping, Optional
+
+from hgraph._impl._builder._node_builder import PythonBaseNodeBuilder
+from hgraph._impl._runtime._map_node import PythonTsdMapNodeImpl
+
+if TYPE_CHECKING:
+    from hgraph._builder._graph_builder import GraphBuilder
+
+
+@dataclass(frozen=True)
+class PythonTsdMapNodeBuilder(PythonBaseNodeBuilder):
+    nested_graph: Optional["GraphBuilder"] = None  # This is the generator function
+    input_node_ids: Mapping[str, int] | None = None  # The nodes representing the stub inputs in the nested graph.
+    output_node_id: int | None = None  # The node representing the stub output in the nested graph.
+    multiplexed_args: frozenset[str] | None = None  # The inputs that need to be de-multiplexed.
+    key_arg: str | None = None  # The key arg to use, None if no key exists
+
+    def make_instance(self, owning_graph_id: tuple[int, ...], node_ndx: int) -> PythonTsdMapNodeImpl:
+        node = PythonTsdMapNodeImpl(
+            node_ndx=node_ndx,
+            owning_graph_id=owning_graph_id,
+            signature=self.signature,
+            scalars=self.scalars,
+            nested_graph_builder=self.nested_graph,
+            input_node_ids=self.input_node_ids,
+            output_node_id=self.output_node_id,
+            multiplexed_args=self.multiplexed_args,
+            key_arg=self.key_arg,
+        )
+        return self._build_inputs_and_outputs(node)
+
+    def release_instance(self, item: PythonTsdMapNodeImpl):
+        """Nothing to do"""

hgraph/_impl/_builder/_mesh_builder.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Mapping, Optional
+
+from hgraph._impl._builder._node_builder import PythonBaseNodeBuilder
+from hgraph._impl._runtime._mesh_node import PythonMeshNodeImpl
+
+if TYPE_CHECKING:
+    from hgraph._builder._graph_builder import GraphBuilder
+
+
+@dataclass(frozen=True)
+class PythonMeshNodeBuilder(PythonBaseNodeBuilder):
+    nested_graph: Optional["GraphBuilder"] = None  # This is the generator function
+    input_node_ids: Mapping[str, int] | None = None  # The nodes representing the stub inputs in the nested graph.
+    output_node_id: int | None = None  # The node representing the stub output in the nested graph.
+    multiplexed_args: frozenset[str] | None = None  # The inputs that need to be de-multiplexed.
+    key_arg: str | None = None  # The key arg to use, None if no key exists
+    context_path: str | None = None  # The context path to use
+
+    def make_instance(self, owning_graph_id: tuple[int, ...], node_ndx: int) -> PythonMeshNodeImpl:
+        node = PythonMeshNodeImpl(
+            node_ndx=node_ndx,
+            owning_graph_id=owning_graph_id,
+            signature=self.signature,
+            scalars=self.scalars,
+            nested_graph_builder=self.nested_graph,
+            input_node_ids=self.input_node_ids,
+            output_node_id=self.output_node_id,
+            multiplexed_args=self.multiplexed_args,
+            key_arg=self.key_arg,
+            context_path=self.context_path,
+        )
+        return self._build_inputs_and_outputs(node)
+
+    def release_instance(self, item: PythonMeshNodeImpl):
+        """Nothing to do"""