computation-graph 53__tar.gz → 54__tar.gz

{computation-graph-53 → computation-graph-54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: computation-graph
-Version: 53
+Version: 54
 Requires-Python: >=3
 Description-Content-Type: text/markdown
 License-File: LICENSE.md

{computation-graph-53 → computation-graph-54}/computation_graph/base_types.py

@@ -98,8 +98,6 @@ class ComputationNode:
     is_terminal: bool
 
     def __hash__(self):
-        if self.is_terminal:
-            return hash(self.name)
         return hash(self.func)
 
     def __repr__(self):

{computation-graph-53 → computation-graph-54}/computation_graph/composers/__init__.py

@@ -48,14 +48,14 @@ def make_and(
 
     merge_node = graph.make_computation_node(args_to_tuple)
 
-    return gamla.pipe(
+    return gamla.sync.pipe(
         funcs,
-        gamla.map(_callable_or_graph_type_to_node_or_graph_type),
+        gamla.sync.map(_callable_or_graph_type_to_node_or_graph_type),
         tuple,
-        gamla.juxtcat(
-            gamla.map(_get_edges_from_node_or_graph),
-            gamla.compose_left(
-                gamla.map(_infer_sink),
+        gamla.sync.juxtcat(
+            gamla.sync.map(_get_edges_from_node_or_graph),
+            gamla.sync.compose_left(
+                gamla.sync.map(_infer_sink),
                 tuple,
                 lambda nodes: (
                     (
@@ -72,7 +72,7 @@ def make_and(
                 ),
             ),
         ),
-        gamla.star(base_types.merge_graphs),
+        gamla.sync.star(base_types.merge_graphs),
     )
 
 
@@ -92,13 +92,13 @@ def make_or(
 
     filter_node = graph.make_computation_node(filter_computation_errors)
 
-    return gamla.pipe(
+    return gamla.sync.pipe(
         funcs,
-        gamla.map(make_optional(default_value=_ComputationError())),
+        gamla.sync.map(make_optional(default_value=_ComputationError())),
         tuple,
-        gamla.pair_with(
-            gamla.compose_left(
-                gamla.map(_infer_sink),
+        gamla.sync.pair_right(
+            gamla.sync.compose_left(
+                gamla.sync.map(_infer_sink),
                 tuple,
                 lambda sinks: (
                     (
@@ -116,7 +116,7 @@ def make_or(
             )
         ),
         gamla.concat,
-        gamla.star(base_types.merge_graphs),
+        gamla.sync.star(base_types.merge_graphs),
     )
 
 
@@ -126,18 +126,16 @@ _destinations = gamla.compose(set, gamla.map(base_types.edge_destination))
 def _infer_sink(graph_or_node: base_types.NodeOrGraph) -> base_types.ComputationNode:
     if isinstance(graph_or_node, base_types.ComputationNode):
         return graph_or_node
-    graph_without_future_edges = gamla.pipe(graph_or_node, graph.remove_future_edges)
+    graph_without_future_edges = graph.remove_future_edges(graph_or_node)
     if graph_without_future_edges:
         try:
-            return gamla.pipe(
-                graph_without_future_edges, graph.sink_excluding_terminals
-            )
+            return graph.sink_excluding_terminals(graph_without_future_edges)
         except AssertionError:
             # If we reached here we can try again without sources of future edges.
-            sources_of_future_edges = gamla.pipe(
+            sources_of_future_edges = gamla.sync.pipe(
                 graph_or_node,
-                gamla.filter(base_types.edge_is_future),
-                gamla.map(base_types.edge_source),
+                gamla.sync.filter(base_types.edge_is_future),
+                gamla.sync.map(base_types.edge_source),
                 frozenset,
             )
             result = (
@@ -234,30 +232,30 @@ def _infer_composition_edges(
         graph.get_incoming_edges_for_node(destination)
     )
     return base_types.merge_graphs(
-        gamla.pipe(
+        gamla.sync.pipe(
             destination,
-            gamla.mapcat(graph.get_edge_nodes),
+            gamla.sync.mapcat(graph.get_edge_nodes),
             gamla.unique,
-            gamla.filter(
-                gamla.compose_left(
+            gamla.sync.filter(
+                gamla.sync.compose_left(
                     unbound_signature,
                     lambda sig: key in sig.kwargs
                     or (key is None and signature.is_unary(sig)),
                 )
             ),
             # Do not add edges to nodes from source that are already present in destination (cycle).
-            gamla.filter(
+            gamla.sync.filter(
                 lambda node: isinstance(source, base_types.ComputationNode)
                 or node not in graph.get_all_nodes(source)
             ),
-            gamla.map(
+            gamla.sync.map(
                 lambda destination: try_connect(
                     destination=destination,
                     unbound_destination_signature=unbound_signature(destination),
                 )
             ),
             tuple,
-            gamla.check(
+            gamla.sync.check(
                 gamla.identity,
                 AssertionError(
                     f"Cannot compose, destination signature does not contain key '{key}'"
@@ -278,13 +276,13 @@ def _make_compose_inner(
     assert (
         len(funcs) > 1
     ), f"Only {len(funcs)} function passed to compose, need at least 2, funcs={funcs}"
-    return gamla.pipe(
+    return gamla.sync.pipe(
         funcs,
         reversed,
-        gamla.map(_callable_or_graph_type_to_node_or_graph_type),
+        gamla.sync.map(_callable_or_graph_type_to_node_or_graph_type),
         gamla.sliding_window(2),
-        gamla.map(gamla.star(_infer_composition_edges(priority, key, is_future))),
-        gamla.star(base_types.merge_graphs),
+        gamla.sync.map(gamla.star(_infer_composition_edges(priority, key, is_future))),
+        gamla.sync.star(base_types.merge_graphs),
     )
 
 
@@ -389,8 +387,8 @@ def compose_dict(
     return gamla.pipe(
         d,
         dict.items,
-        gamla.map(gamla.star(lambda key, fn: make_compose(f, fn, key=key))),
-        gamla.star(base_types.merge_graphs),
+        gamla.sync.map(gamla.star(lambda key, fn: make_compose(f, fn, key=key))),
+        gamla.sync.star(base_types.merge_graphs),
     ) or compose_left_unary(f, lambda x: x)
 
 

{computation-graph-53 → computation-graph-54}/computation_graph/graph.py

@@ -6,16 +6,16 @@ from gamla.optimized import sync as opt_gamla
 
 from computation_graph import base_types, signature
 
-get_edge_nodes = gamla.ternary(
+get_edge_nodes = opt_gamla.ternary(
     base_types.edge_args,
     lambda edge: edge.args + (edge.destination,),
     lambda edge: (edge.source, edge.destination),
 )
 
-get_all_nodes = gamla.compose_left(gamla.mapcat(get_edge_nodes), frozenset)
+get_all_nodes = opt_gamla.compose_left(opt_gamla.mapcat(get_edge_nodes), frozenset)
 
 
-edges_to_node_id_map = gamla.compose_left(
+edges_to_node_id_map = opt_gamla.compose_left(
     gamla.mapcat(get_edge_nodes), gamla.unique, enumerate, gamla.map(reversed), dict
 )
 
@@ -41,13 +41,13 @@ def make_computation_node(
 
 
 def get_leaves(edges: base_types.GraphType) -> FrozenSet[base_types.ComputationNode]:
-    return gamla.pipe(
+    return opt_gamla.pipe(
         edges,
         get_all_nodes,
-        gamla.remove(
-            gamla.pipe(
+        opt_gamla.remove(
+            opt_gamla.pipe(
                 edges,
-                gamla.mapcat(lambda edge: (edge.source, *edge.args)),
+                opt_gamla.mapcat(lambda edge: (edge.source, *edge.args)),
                 frozenset,
                 gamla.contains,
             )
@@ -56,27 +56,29 @@ def get_leaves(edges: base_types.GraphType) -> FrozenSet[base_types.ComputationN
     )
 
 
-sink_excluding_terminals = gamla.compose_left(
+sink_excluding_terminals = opt_gamla.compose_left(
     get_leaves,
-    gamla.remove(base_types.node_is_terminal),
+    opt_gamla.remove(base_types.node_is_terminal),
     tuple,
     gamla.assert_that(gamla.len_equals(1)),
     gamla.head,
 )
 
-get_incoming_edges_for_node = gamla.compose_left(
-    gamla.groupby(base_types.edge_destination),
-    gamla.valmap(frozenset),
+get_incoming_edges_for_node = opt_gamla.compose_left(
+    opt_gamla.groupby(base_types.edge_destination),
+    opt_gamla.valmap(frozenset),
     gamla.dict_to_getter_with_default(frozenset()),
 )
 
 
-get_terminals = gamla.compose_left(
-    get_all_nodes, gamla.filter(base_types.node_is_terminal), tuple
+get_terminals = opt_gamla.compose_left(
+    get_all_nodes, opt_gamla.filter(base_types.node_is_terminal), tuple
 )
 
 
-remove_future_edges = gamla.compose(tuple, opt_gamla.remove(base_types.edge_is_future))
+remove_future_edges = opt_gamla.compose(
+    tuple, opt_gamla.remove(base_types.edge_is_future)
+)
 
 
 def make_source():
@@ -98,7 +100,7 @@ def make_terminal(name: str, func: Callable) -> base_types.ComputationNode:
     )
 
 
-_keep_not_in_bound_kwargs = gamla.compose_left(
+_keep_not_in_bound_kwargs = opt_gamla.compose_left(
     opt_gamla.map(base_types.edge_key),
     gamla.filter(gamla.identity),
     frozenset,
@@ -151,15 +153,15 @@ def _replace_source_in_edges(
 traverse_forward: Callable[
     [base_types.GraphType],
     Callable[[base_types.CallableOrNode], Tuple[base_types.ComputationNode, ...]],
-] = gamla.compose_left(
+] = opt_gamla.compose_left(
     gamla.mapcat(
-        gamla.compose_left(
+        opt_gamla.compose_left(
             gamla.juxt(base_types.edge_sources, base_types.edge_destination),
             gamla.explode(0),
         )
     ),
     gamla.groupby_many_reduce(
-        gamla.compose_left(gamla.head, gamla.wrap_tuple),
+        opt_gamla.compose_left(gamla.head, gamla.wrap_tuple),
         lambda destinations, e: (*(destinations if destinations else ()), e[1]),
     ),
     gamla.dict_to_getter_with_default(()),
@@ -212,7 +214,8 @@ def transform_edges(
     edge_mapper: Callable[[base_types.ComputationEdge], base_types.ComputationEdge],
 ):
     return _operate_on_subgraph(
-        _split_by_condition(query), gamla.compose_left(gamla.map(edge_mapper), tuple)
+        _split_by_condition(query),
+        opt_gamla.compose_left(gamla.map(edge_mapper), tuple),
     )
 
 
@@ -283,7 +286,7 @@ def _operate_on_subgraph(selector, transformation):
 
 
 def _split_by_condition(condition):
-    return gamla.compose_left(
+    return opt_gamla.compose_left(
         gamla.bifurcate(gamla.filter(condition), gamla.remove(condition)),
         gamla.map(tuple),
         tuple,

{computation-graph-53 → computation-graph-54}/computation_graph/graph_test.py

@@ -376,7 +376,7 @@ def test_or_with_sink_that_raises():
 
 
 def test_unambiguous_composition_using_terminal():
-    terminal = graph.make_terminal("1", lambda x: x)
+    terminal = graph.make_terminal("1", lambda x: x[0])
 
     def source():
         return 1
@@ -403,8 +403,8 @@ def test_unambiguous_composition_using_terminal():
 
 
 def test_two_terminals():
-    terminal1 = graph.make_terminal("1", gamla.wrap_tuple)
-    terminal2 = graph.make_terminal("2", gamla.wrap_tuple)
+    terminal1 = graph.make_terminal("1", lambda x: x)
+    terminal2 = graph.make_terminal("2", lambda x: x)
     result = graph_runners.unary_bare(
         base_types.merge_graphs(
             composers.compose_unary(terminal1, composers.make_compose(_node2, _node1)),
@@ -418,8 +418,8 @@ def test_two_terminals():
 
 def test_two_paths_succeed():
     source = graph.make_source()
-    terminal1 = graph.make_terminal("1", gamla.wrap_tuple)
-    terminal2 = graph.make_terminal("2", gamla.wrap_tuple)
+    terminal1 = graph.make_terminal("1", lambda x: x)
+    terminal2 = graph.make_terminal("2", lambda x: x)
     result = graph_runners.variadic_bare(
         base_types.merge_graphs(
             composers.make_first(

{computation-graph-53 → computation-graph-54}/computation_graph/legacy.py

@@ -18,6 +18,9 @@ def handle_state(
 ) -> base_types.GraphType:
     @graph.make_terminal("retrieve_state")
     def retrieve_state(x):
+        if x == ():
+            raise base_types.SkipComputationError
+        x = x[0]
         assert isinstance(x, ComputationResult), x
         return x.state
 

{computation-graph-53 → computation-graph-54}/computation_graph/run.py

@@ -16,7 +16,7 @@ import typeguard
 from gamla.optimized import async_functions as opt_async_gamla
 from gamla.optimized import sync as opt_gamla
 
-from computation_graph import base_types, graph, signature
+from computation_graph import base_types, composers, graph, signature
 from computation_graph.composers import debug
 
 
@@ -28,7 +28,7 @@ _NodeToResults = Dict[base_types.ComputationNode, base_types.Result]
 _ComputationInput = Tuple[Tuple[base_types.Result, ...], Dict[str, base_types.Result]]
 _SingleNodeSideEffect = Callable[[base_types.ComputationNode, Any], None]
 _NodeToComputationInput = Callable[[base_types.ComputationNode], _ComputationInput]
-_ComputaionInputSpec = Tuple[
+_ComputationInputSpec = Tuple[
     Tuple[base_types.ComputationNode, ...], Dict[str, base_types.ComputationNode]
 ]
 
@@ -143,12 +143,41 @@ _graph_to_future_sources = opt_gamla.compose_left(
 )
 
 
+"""Replace multiple edges pointing to a terminal with one edge that has multiple args"""
+
+
+def _merge_edges_pointing_to_terminals(g: base_types.GraphType) -> base_types.GraphType:
+    return gamla.compose_left(
+        gamla.groupby(gamla.attrgetter("destination")),
+        gamla.itemmap(
+            gamla.star(
+                lambda dest, edges_for_dest: (
+                    dest,
+                    base_types.merge_graphs(
+                        composers.make_or(
+                            opt_gamla.maptuple(base_types.edge_source)(edges_for_dest),
+                            merge_fn=(aggregate := lambda args: args),
+                        ),
+                        composers.compose_left_unary(aggregate, dest),
+                    )
+                    if dest.is_terminal
+                    else edges_for_dest,
+                )
+            )
+        ),
+        dict.values,
+        gamla.concat,
+        tuple,
+    )(g)
+
+
 def _to_callable_with_side_effect_for_single_and_multiple(
     single_node_side_effect: _SingleNodeSideEffect,
     all_nodes_side_effect: Callable,
     edges: base_types.GraphType,
     handled_exceptions: Tuple[Type[Exception], ...],
 ) -> Callable[[_NodeToResults, _NodeToResults], _NodeToResults]:
+    edges = _merge_edges_pointing_to_terminals(edges)
     single_node_side_effect = (
         (lambda node, result: result)
         if os.getenv(base_types.COMPUTATION_GRAPH_DEBUG_ENV_KEY) is None
@@ -238,7 +267,7 @@ _get_kwargs_nodes = opt_gamla.compose_left(
 
 def _node_incoming_edges_to_input_spec(
     node_incoming_edges: Tuple[base_types.ComputationEdge],
-) -> _ComputaionInputSpec:
+) -> _ComputationInputSpec:
     if not len(node_incoming_edges):
         return (), {}
     first_incoming_edge = gamla.head(node_incoming_edges)
@@ -256,7 +285,7 @@ def _edges_to_accumulated_results_to_node_to_first_possible_input(
 ) -> Callable[[_NodeToResults], _NodeToComputationInput]:
     node_to_incoming_edges = graph.get_incoming_edges_for_node(edges)
     node_to_computation_input_spec_options: Callable[
-        [base_types.ComputationNode], Tuple[_ComputaionInputSpec]
+        [base_types.ComputationNode], Tuple[_ComputationInputSpec]
     ] = functools.cache(
         gamla.compose_left(
             node_to_incoming_edges,
@@ -304,7 +333,7 @@ def _make_reduce_layers(
     get_node_input_and_apply = _make_get_node_input_and_apply(
         is_async, single_node_side_effect
     )
-    accumlated_results_to_node_to_input = (
+    accumulated_results_to_node_to_input = (
         _edges_to_accumulated_results_to_node_to_first_possible_input(edges)
     )
     single_layer_reducer = debug.name_callable(
@@ -314,7 +343,7 @@ def _make_reduce_layers(
                 gamla.head,
                 gamla.compose_left(
                     opt_gamla.packstack(
-                        accumlated_results_to_node_to_input, gamla.identity
+                        accumulated_results_to_node_to_input, gamla.identity
                     ),
                     gamla.explode(1),
                     gamla.map_filter_empty(

{computation-graph-53 → computation-graph-54}/computation_graph/signature.py

@@ -1,7 +1,7 @@
 import functools
 import inspect
 from types import MappingProxyType
-from typing import Callable, FrozenSet, Tuple
+from typing import Callable, FrozenSet
 
 import gamla
 
@@ -34,16 +34,13 @@ def _is_default(parameter):
 
 _parameter_name = gamla.attrgetter("name")
 
-
-@gamla.before(
-    gamla.compose_left(
-        inspect.signature,
-        gamla.attrgetter("parameters"),
-        MappingProxyType.values,
-        tuple,
-    )
+_func_parameters = gamla.compose_left(
+    inspect.signature, gamla.attrgetter("parameters"), MappingProxyType.values, tuple
 )
-def from_callable(function_parameters: Tuple) -> base_types.NodeSignature:
+
+
+def from_callable(func: Callable) -> base_types.NodeSignature:
+    function_parameters = _func_parameters(func)
     return base_types.NodeSignature(
         is_args=gamla.anymap(parameter_is_star)(function_parameters),
         is_kwargs=gamla.anymap(parameter_is_double_star)(function_parameters),

{computation-graph-53 → computation-graph-54}/computation_graph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: computation-graph
-Version: 53
+Version: 54
 Requires-Python: >=3
 Description-Content-Type: text/markdown
 License-File: LICENSE.md

{computation-graph-53 → computation-graph-54}/setup.py

@@ -7,7 +7,7 @@ with open("README.md", "r") as fh:
 setuptools.setup(
     name="computation-graph",
     python_requires=">=3",
-    version="53",
+    version="54",
     long_description=_LONG_DESCRIPTION,
     long_description_content_type="text/markdown",
     packages=setuptools.find_namespace_packages(),