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

{computation-graph-53 → computation_graph-56}/PKG-INFO

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

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

@@ -96,11 +96,13 @@ class ComputationNode:
     func: Callable
     signature: NodeSignature
     is_terminal: bool
+    computed_hash: int = dataclasses.field(init=False)
+
+    def __post_init__(self):
+        object.__setattr__(self, "computed_hash", hash(self.func))
 
     def __hash__(self):
-        if self.is_terminal:
-            return hash(self.name)
-        return hash(self.func)
+        return self.computed_hash
 
     def __repr__(self):
         return self.name

{computation-graph-53 → computation_graph-56}/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-56}/computation_graph/composers/duplication.py

@@ -44,6 +44,7 @@ _duplicate_node = gamla.compose_left(
     graph.make_computation_node,
 )
 
+duplicate_node = _duplicate_node
 
 _node_to_duplicated_node = gamla.compose_left(
     gamla.remove(base_types.node_is_terminal),
@@ -104,4 +105,4 @@ def safe_replace_sources(
             g = graph.replace_source(source, get_node_replacement(source), g)
         return g
 
-    return gamla.reduce(lambda updated_cg, e: updated_cg + update_edge(e), (), cg)
+    return base_types.merge_graphs(*(update_edge(e) for e in cg))

{computation-graph-53 → computation_graph-56}/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,16 +153,16 @@ 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),
-        lambda destinations, e: (*(destinations if destinations else ()), e[1]),
+        opt_gamla.compose_left(gamla.head, gamla.wrap_tuple),
+        lambda destinations, e: {*(destinations if destinations else ()), e[1]},
     ),
     gamla.dict_to_getter_with_default(()),
     gamla.before(make_computation_node),
@@ -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-56}/computation_graph/graph_test.py

@@ -63,6 +63,55 @@ def test_simple():
         )
 
 
+async def test_async_run_as_soon_as_possible(capsys):
+    # This test is to make sure that the async node runs as soon as possible.
+    # nodes in different topological layers should run concurrently if not dependent on each other.
+    async def concurrent1(x):
+        print("start concurrent1")  # noqa
+        await asyncio.sleep(0.1)
+        print("end concurrent1")  # noqa
+        return "concurrent1"
+
+    async def concurrent2(x):
+        print("start concurrent2")  # noqa
+        await asyncio.sleep(0.1)
+        print("end concurrent2")  # noqa
+        return "concurrent2"
+
+    def sink(x, y):
+        return f"x={x}, y={y}"
+
+    g = base_types.merge_graphs(
+        composers.compose_unary(concurrent1, lambda: "x"),
+        composers.compose_unary(concurrent2, lambda y: y, lambda: "y"),
+        composers.compose_left(concurrent1, sink, key="x"),
+        composers.compose_left(concurrent2, sink, key="y"),
+    )
+
+    await graph_runners.nullary(g, sink)
+
+    # Capture the output
+    captured = capsys.readouterr()
+
+    # Assertions
+    assert "start concurrent1" in captured.out
+    assert "start concurrent2" in captured.out
+    assert "end concurrent1" in captured.out
+    assert "end concurrent2" in captured.out
+    assert captured.out.index("start concurrent1") < captured.out.index(
+        "end concurrent1"
+    )
+    assert captured.out.index("start concurrent2") < captured.out.index(
+        "end concurrent2"
+    )
+    assert captured.out.index("start concurrent1") < captured.out.index(
+        "end concurrent2"
+    )
+    assert captured.out.index("start concurrent2") < captured.out.index(
+        "end concurrent1"
+    )
+
+
 async def test_simple_async():
     assert (
         await graph_runners.unary(
@@ -376,7 +425,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 +452,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 +467,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-56}/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