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

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

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

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

@@ -1,6 +1,7 @@
 import asyncio
 import functools
 import inspect
+from typing import Dict
 
 import gamla
 
@@ -20,6 +21,7 @@ def duplicate_function(func):
     def inner(*args, **kwargs):
         return func(*args, **kwargs)
 
+    inner.__name__ = f"duplicate of {inner.__name__}"
     return inner
 
 
@@ -42,8 +44,8 @@ _duplicate_node = gamla.compose_left(
     graph.make_computation_node,
 )
 
+
 _node_to_duplicated_node = gamla.compose_left(
-    graph.get_all_nodes,
     gamla.remove(base_types.node_is_terminal),
     gamla.map(gamla.pair_right(_duplicate_node)),
     dict,
@@ -51,7 +53,7 @@ _node_to_duplicated_node = gamla.compose_left(
 )
 
 duplicate_graph = gamla.compose_left(
-    gamla.pair_with(_node_to_duplicated_node),
+    gamla.pair_with(gamla.compose_left(graph.get_all_nodes, _node_to_duplicated_node)),
     gamla.star(
         lambda get_duplicated_node, graph: gamla.pipe(
             graph,
@@ -68,3 +70,38 @@ duplicate_graph = gamla.compose_left(
 duplicate_function_or_graph = gamla.ternary(
     gamla.is_instance(tuple), duplicate_graph, duplicate_function
 )
+
+
+def safe_replace_sources(
+    source_to_replacement_dict: Dict[
+        base_types.CallableOrNode, base_types.CallableOrNodeOrGraph
+    ],
+    cg: base_types.GraphType,
+) -> base_types.GraphType:
+    source_to_replacement_dict = gamla.keymap(graph.make_computation_node)(
+        source_to_replacement_dict
+    )
+    reachable_to_duplicate_map = gamla.pipe(
+        gamla.graph_traverse_many(
+            source_to_replacement_dict.keys(), graph.traverse_forward(cg)
+        ),
+        gamla.remove(gamla.contains(source_to_replacement_dict.keys())),
+        _node_to_duplicated_node,
+    )
+    get_node_replacement = gamla.compose_left(
+        gamla.lazyjuxt(
+            gamla.dict_to_getter_with_default(None)(source_to_replacement_dict),
+            reachable_to_duplicate_map,
+            gamla.identity,
+        ),
+        gamla.find(gamla.identity),
+    )
+
+    def update_edge(e: base_types.ComputationEdge) -> base_types.GraphType:
+        dest = base_types.edge_destination(e)
+        g = graph.replace_node(dest, get_node_replacement(dest))((e,))
+        for source in base_types.edge_sources(e):
+            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)

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

@@ -1,21 +1,21 @@
 import dataclasses
-from typing import Callable, FrozenSet
+from typing import Callable, FrozenSet, Tuple
 
 import gamla
 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,
@@ -148,6 +150,25 @@ def _replace_source_in_edges(
     )
 
 
+traverse_forward: Callable[
+    [base_types.GraphType],
+    Callable[[base_types.CallableOrNode], Tuple[base_types.ComputationNode, ...]],
+] = opt_gamla.compose_left(
+    gamla.mapcat(
+        opt_gamla.compose_left(
+            gamla.juxt(base_types.edge_sources, base_types.edge_destination),
+            gamla.explode(0),
+        )
+    ),
+    gamla.groupby_many_reduce(
+        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),
+)
+
+
 @gamla.curry
 def replace_source(
     original: base_types.CallableOrNode,
@@ -193,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),
     )
 
 
@@ -264,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-52 → computation-graph-54}/computation_graph/graph_test.py

@@ -1,4 +1,5 @@
 import asyncio
+from typing import Dict
 
 import gamla
 import pytest
@@ -375,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
@@ -402,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)),
@@ -417,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(
@@ -802,3 +803,100 @@ def test_ambig_edges_assertion_in_merge_graphs_active_only_when_env_var_is_activ
             composers.compose_left_unary(lambda: 1, a),
             composers.compose_left_unary(lambda: 1, a),
         )
+
+
+def a():
+    pass
+
+
+def b(x):
+    pass
+
+
+def c(x):
+    pass
+
+
+def d(x, y):
+    pass
+
+
+def kuky():
+    pass
+
+
+def kuku():
+    pass
+
+
+t = graph.make_terminal("t", lambda x: x)
+
+g = (
+    composers.compose_left(a, c)
+    + composers.compose_left(c, d, key="x")
+    + composers.compose_left(b, d, key="y")
+    + composers.compose_left_future(d, b, "x", "bla")
+    + composers.compose_left(a, t)
+)
+
+
+@pytest.mark.parametrize(
+    "to_replace,expected_edges_strs",
+    [
+        pytest.param(
+            {a: kuky},
+            {
+                "kuky----x---->duplicate of c",
+                "kuky----x---->t",
+                "duplicate of c----x---->duplicate of d",
+                "when_memory_unavailable----x---->duplicate of b",
+                "duplicate of d....x....>duplicate of b",
+                "duplicate of b----y---->duplicate of d",
+            },
+            id="replace source node",
+        ),
+        pytest.param(
+            {c: kuky},
+            {
+                "a----x---->kuky",
+                "a----x---->t",
+                "kuky----x---->duplicate of d",
+                "when_memory_unavailable----x---->duplicate of b",
+                "duplicate of d....x....>duplicate of b",
+                "duplicate of b----y---->duplicate of d",
+            },
+            id="replace node not in cycle",
+        ),
+        pytest.param(
+            {b: kuky},
+            {
+                "a----x---->c",
+                "a----x---->t",
+                "c----x---->duplicate of d",
+                "when_memory_unavailable----x---->kuky",
+                "duplicate of d....x....>kuky",
+                "kuky----y---->duplicate of d",
+            },
+            id="replace node in cycle",
+        ),
+        pytest.param(
+            {a: kuku, b: kuky},
+            {
+                "duplicate of c----x---->duplicate of d",
+                "duplicate of d....x....>kuky",
+                "kuku----x---->duplicate of c",
+                "kuku----x---->t",
+                "kuky----y---->duplicate of d",
+                "when_memory_unavailable----x---->kuky",
+            },
+            id="replace multiple nodes - duplicate reachables once",
+        ),
+    ],
+)
+def test_safe_replace_node(
+    to_replace: Dict[base_types.CallableOrNode, base_types.CallableOrNodeOrGraph],
+    expected_edges_strs: str,
+):
+    assert expected_edges_strs == {
+        str(e) for e in duplication.safe_replace_sources(to_replace, g)
+    }

{computation-graph-52 → 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-52 → 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-52 → 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-52 → computation-graph-54}/computation_graph.egg-info/PKG-INFO

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

{computation-graph-52 → 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="52",
+    version="54",
     long_description=_LONG_DESCRIPTION,
     long_description_content_type="text/markdown",
     packages=setuptools.find_namespace_packages(),