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

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

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

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

@@ -152,7 +152,7 @@ assert_no_unwanted_ambiguity = gamla.side_effect(
 
 @gamla.side_effect
 def _assert_no_unwanted_ambiguity_when_debug_set(graph):
-    if os.getenv(COMPUTATION_GRAPH_DEBUG_ENV_KEY):
+    if os.getenv(COMPUTATION_GRAPH_DEBUG_ENV_KEY) is not None:
         assert_no_unwanted_ambiguity(graph)
 
 

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

@@ -1,5 +1,5 @@
 import dataclasses
-from typing import Callable, FrozenSet
+from typing import Callable, FrozenSet, Tuple
 
 import gamla
 from gamla.optimized import sync as opt_gamla
@@ -148,6 +148,25 @@ def _replace_source_in_edges(
     )
 
 
+traverse_forward: Callable[
+    [base_types.GraphType],
+    Callable[[base_types.CallableOrNode], Tuple[base_types.ComputationNode, ...]],
+] = gamla.compose_left(
+    gamla.mapcat(
+        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]),
+    ),
+    gamla.dict_to_getter_with_default(()),
+    gamla.before(make_computation_node),
+)
+
+
 @gamla.curry
 def replace_source(
     original: base_types.CallableOrNode,
@@ -158,7 +177,7 @@ def replace_source(
         return current_graph
 
     if gamla.is_instance(base_types.CallableOrNode)(replacement):
-        return _replace_source_in_edges(original, replacement)(current_graph)
+        return _replace_source_in_edges(original, replacement)(current_graph)  # type: ignore
 
     if base_types.is_computation_graph(replacement):
         return gamla.pipe(

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

@@ -1,4 +1,5 @@
 import asyncio
+from typing import Dict
 
 import gamla
 import pytest
@@ -445,7 +446,9 @@ def test_double_star_signature_considered_unary():
     )
 
 
-def test_type_safety_messages(caplog):
+def test_type_safety_messages(caplog, monkeypatch):
+    monkeypatch.setenv(base_types.COMPUTATION_GRAPH_DEBUG_ENV_KEY, "j")
+
     def f(x) -> int:  # Bad typing!
         return "hello " + x
 
@@ -456,7 +459,9 @@ def test_type_safety_messages(caplog):
     assert "TypeError" in caplog.text
 
 
-def test_type_safety_messages_no_overtrigger(caplog):
+def test_type_safety_messages_no_overtrigger(caplog, monkeypatch):
+    monkeypatch.setenv(base_types.COMPUTATION_GRAPH_DEBUG_ENV_KEY, "h")
+
     def f(x) -> str:
         return "hello " + x
 
@@ -798,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-51 → computation-graph-53}/computation_graph/run.py

@@ -3,6 +3,7 @@ import dataclasses
 import functools
 import itertools
 import logging
+import os
 import time
 import typing
 from typing import Any, Callable, Dict, FrozenSet, Set, Tuple, Type
@@ -41,7 +42,7 @@ def _transpose_graph(
 
 
 _toposort_nodes: Callable[
-    [base_types.GraphType], Tuple[FrozenSet[base_types.ComputationNode], ...],
+    [base_types.GraphType], Tuple[FrozenSet[base_types.ComputationNode], ...]
 ] = opt_gamla.compose_left(
     opt_gamla.groupby_many(base_types.edge_sources),
     opt_gamla.valmap(
@@ -76,7 +77,6 @@ def _profile(node, time_started: float):
 def _make_get_node_input_and_apply(
     is_async: bool, side_effect: _SingleNodeSideEffect
 ) -> Callable[..., base_types.Result]:
-
     if is_async:
 
         @opt_async_gamla.star
@@ -149,6 +149,12 @@ def _to_callable_with_side_effect_for_single_and_multiple(
     edges: base_types.GraphType,
     handled_exceptions: Tuple[Type[Exception], ...],
 ) -> Callable[[_NodeToResults, _NodeToResults], _NodeToResults]:
+    single_node_side_effect = (
+        (lambda node, result: result)
+        if os.getenv(base_types.COMPUTATION_GRAPH_DEBUG_ENV_KEY) is None
+        else single_node_side_effect
+    )
+
     future_sources = _graph_to_future_sources(edges)
     future_source_to_placeholder = _map_future_source_to_placeholder(future_sources)
     edges = gamla.pipe(
@@ -247,7 +253,7 @@ def _node_incoming_edges_to_input_spec(
 
 def _edges_to_accumulated_results_to_node_to_first_possible_input(
     edges,
-) -> Callable[[_NodeToResults], _NodeToComputationInput,]:
+) -> 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]

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

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

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

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