hgraph 0.0.1__py3-none-any.whl

hgraph/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

hgraph/__init__.py

@@ -0,0 +1,6 @@
+from hgraph._builder 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,29 @@
+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,82 @@
+import typing
+from abc import abstractmethod
+from dataclasses import dataclass
+
+from hgraph._builder._builder import Builder
+from hgraph._runtime._graph import Graph
+
+if typing.TYPE_CHECKING:
+    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) -> "Graph":
+        """
+        Construct an instance of a graph. The id provided is the id for the graph instance to be constructed.
+        """
+
+    @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,21 @@
+import typing
+
+from _pytest.nodes import Node
+
+from hgraph._builder._builder import Builder
+
+if typing.TYPE_CHECKING:
+    from hgraph._types._time_series_types import TimeSeriesInput
+
+
+__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."""
+        pass
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        pass

hgraph/_builder/_node_builder.py

@@ -0,0 +1,38 @@
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Optional, Any, Mapping, List, Tuple, 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]):
+    node_ndx: int
+    signature: NodeSignature
+    scalars: Mapping[str, Any]
+    input_builder: Optional[InputBuilder] = None
+    output_builder: Optional[OutputBuilder] = None
+
+    @abstractmethod
+    def make_instance(self, owning_graph_id: tuple[int, ...]) -> 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,21 @@
+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."""
+        pass
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        pass
+

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"""
+        pass
+
+    def release_instance(self, item: "ScalarValue"):
+        pass

hgraph/_builder/_ts_builder.py

@@ -0,0 +1,210 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional, TYPE_CHECKING
+
+from _pytest.nodes import Node
+
+from hgraph._builder._input_builder import InputBuilder
+from hgraph._builder._output_builder import OutputBuilder
+
+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")
+
+
+@dataclass(frozen=True)
+class TSOutputBuilder(OutputBuilder):
+
+    value_tp: "HgScalarTypeMetaData"
+
+    def make_instance(self, owning_node=None, owning_output=None) -> "TimeSeriesOutput":
+        pass
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        pass
+
+
+@dataclass(frozen=True)
+class TSInputBuilder(InputBuilder):
+
+    value_tp: "HgScalarTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        ...
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        ...
+
+
+class TSSignalInputBuilder(InputBuilder):
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        ...
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        ...
+
+
+@dataclass(frozen=True)
+class TSBInputBuilder(InputBuilder):
+
+    schema: "TimeSeriesSchema"
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        ...
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        ...
+
+
+@dataclass(frozen=True)
+class TSBOutputBuilder(OutputBuilder):
+
+    schema: "TimeSeriesSchema"
+
+    def make_instance(self, owning_node: Node = None, owning_output: "TimeSeriesOutput" = None) -> "TimeSeriesOutput":
+        ...
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        ...
+
+
+@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":
+        ...
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        ...
+
+
+@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":
+        ...
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        ...
+
+
+class TSDInputBuilder(InputBuilder):
+
+    key_tp: "HgScalarTypeMetaData"
+    value_tp: "HgTimeSeriesTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        ...
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        ...
+
+
+@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":
+        ...
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        ...
+
+
+@dataclass(frozen=True)
+class TSSOutputBuilder(OutputBuilder):
+
+    value_tp: "HgScalarTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_output: "TimeSeriesOutput" = None) -> "TimeSeriesOutput":
+        ...
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        ...
+
+
+@dataclass(frozen=True)
+class TSSInputBuilder(InputBuilder):
+
+    value_tp: "HgScalarTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        ...
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        ...
+
+
+class REFInputBuilder(InputBuilder):
+    value_tp: "HgTimeSeriesTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_input: "TimeSeriesInput" = None) -> "TimeSeriesInput":
+        ...
+
+    def release_instance(self, item: "TimeSeriesInput"):
+        ...
+
+
+@dataclass(frozen=True)
+class REFOutputBuilder(OutputBuilder):
+    value_tp: "HgTimeSeriesTypeMetaData"
+
+    def make_instance(self, owning_node: Node = None, owning_output: "TimeSeriesOutput" = None) -> "TimeSeriesOutput":
+        ...
+
+    def release_instance(self, item: "TimeSeriesOutput"):
+        ...
+
+
+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"""
+

hgraph/_impl/__init__.py

@@ -0,0 +1,4 @@
+from hgraph._impl._builder 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,5 @@
+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._switch_builder import *
+from hgraph._impl._builder._ts_builder import *

hgraph/_impl/_builder/_graph_builder.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+
+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) -> Graph:
+        nodes = [nb.make_instance(graph_id) for nb in 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
+            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)
+            # The nodes are initialised within the context of the graph
+        return PythonGraph(graph_id=graph_id, nodes=tuple(nodes), parent_node=parent_node)
+
+    def release_instance(self, item: Graph):
+        for node, node_builder in zip(item.nodes, self.node_builders):
+            node_builder.release_instance(node)
+        item.dispose()
+
+
+
+    

hgraph/_impl/_builder/_map_builder.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Mapping, cast
+
+from hgraph._builder._node_builder import NodeBuilder
+from hgraph._impl._runtime._map_node import PythonMapNodeImpl
+from hgraph._types._time_series_types import TimeSeriesOutput
+from hgraph._types._tsb_type import TimeSeriesBundleInput
+
+if TYPE_CHECKING:
+    from hgraph._builder._graph_builder import GraphBuilder
+
+
+@dataclass(frozen=True)
+class PythonMapNodeBuilder(NodeBuilder):
+    nested_graph: "GraphBuilder" = None  # This is the generator function
+    input_node_ids: Mapping[str, int] = None  # The nodes representing the stub inputs in the nested graph.
+    output_node_id: int = None  # The node representing the stub output in the nested graph.
+    multiplexed_args: frozenset[str] =None  # The inputs that need to be de-multiplexed.
+
+    def make_instance(self, owning_graph_id: tuple[int, ...]) -> PythonMapNodeImpl:
+        node = PythonMapNodeImpl(
+            node_ndx=self.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
+        )
+
+        if self.input_builder:
+            ts_input: TimeSeriesBundleInput = cast(TimeSeriesBundleInput,
+                                                   self.input_builder.make_instance(owning_node=node))
+            node.input = ts_input
+
+        if self.output_builder:
+            ts_output: TimeSeriesOutput = self.output_builder.make_instance(owning_node=node)
+            node.output = ts_output
+
+        return node
+
+    def release_instance(self, item: PythonMapNodeImpl):
+        pass

hgraph/_impl/_builder/_node_builder.py

@@ -0,0 +1,87 @@
+from dataclasses import dataclass
+from typing import Callable
+
+from hgraph._builder._node_builder import NodeBuilder
+from hgraph._impl._runtime._node import NodeImpl, GeneratorNodeImpl, PythonPushQueueNodeImpl
+from hgraph._types._time_series_types import TimeSeriesOutput
+from hgraph._types._tsb_type import TimeSeriesBundleInput
+
+
+__all__ = ("PythonNodeBuilder", "PythonGeneratorNodeBuilder", "PythonPushQueueNodeBuilder")
+
+
+@dataclass(frozen=True)
+class PythonNodeBuilder(NodeBuilder):
+    eval_fn: Callable = None  # The eval fn must be supplied.
+    start_fn: Callable = None
+    stop_fn: Callable = None
+
+    def make_instance(self, owning_graph_id: tuple[int, ...]) -> NodeImpl:
+        node = NodeImpl(
+            node_ndx=self.node_ndx,
+            owning_graph_id=owning_graph_id,
+            signature=self.signature,
+            scalars=self.scalars,
+            eval_fn=self.eval_fn,
+            start_fn=self.start_fn,
+            stop_fn=self.stop_fn
+        )
+
+        if self.input_builder:
+            ts_input: TimeSeriesBundleInput = self.input_builder.make_instance(owning_node=node)
+            node.input = ts_input
+
+        if self.output_builder:
+            ts_output: TimeSeriesOutput = self.output_builder.make_instance(owning_node=node)
+            node.output = ts_output
+
+        return node
+
+    def release_instance(self, item: NodeImpl):
+        pass
+
+
+@dataclass(frozen=True)
+class PythonGeneratorNodeBuilder(NodeBuilder):
+    eval_fn: Callable = None  # This is the generator function
+
+    def make_instance(self, owning_graph_id: tuple[int, ...]) -> GeneratorNodeImpl:
+        node = GeneratorNodeImpl(
+            node_ndx=self.node_ndx,
+            owning_graph_id=owning_graph_id,
+            signature=self.signature,
+            scalars=self.scalars,
+            eval_fn=self.eval_fn
+        )
+
+        if self.output_builder:
+            ts_output: TimeSeriesOutput = self.output_builder.make_instance(owning_node=node)
+            node.output = ts_output
+
+        return node
+
+    def release_instance(self, item: GeneratorNodeImpl):
+        pass
+
+
+@dataclass(frozen=True)
+class PythonPushQueueNodeBuilder(NodeBuilder):
+    eval_fn: Callable = None  # This is the generator function
+
+    def make_instance(self, owning_graph_id: tuple[int, ...]) -> PythonPushQueueNodeImpl:
+        node = PythonPushQueueNodeImpl(
+            node_ndx=self.node_ndx,
+            owning_graph_id=owning_graph_id,
+            signature=self.signature,
+            scalars=self.scalars,
+            eval_fn=self.eval_fn
+        )
+
+        if self.output_builder:
+            ts_output: TimeSeriesOutput = self.output_builder.make_instance(owning_node=node)
+            node.output = ts_output
+
+        return node
+
+    def release_instance(self, item: PythonPushQueueNodeImpl):
+        pass