computation-graph 60__tar.gz → 62__tar.gz

{computation_graph-60 → computation_graph-62}/PKG-INFO

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

{computation_graph-60 → computation_graph-62}/computation_graph/graph_test.py

@@ -245,6 +245,26 @@ async def test_raise_handled_from_async():
     )
 
 
+async def test_no_result_for_node_that_raised_handled_exception():
+    async def raises(x):
+        raise base_types.SkipComputationError
+
+    def sink(x):
+        return x
+
+    @graph.make_computation_node
+    def source():
+        return 4
+
+    res = await run.to_callable_strict(composers.compose_left(source, raises, sink))(
+        {}, {}
+    )
+
+    assert res[source] == 4
+    assert raises not in res
+    assert sink not in res
+
+
 def test_raise_unhandled_exception():
     class MyExceptionError(Exception):
         ...
@@ -256,6 +276,27 @@ def test_raise_unhandled_exception():
         graph_runners.nullary_infer_sink(composers.make_first(raises, lambda: 1))
 
 
+async def test_raise_unhandled_exception_async():
+    class MyExceptionError(Exception):
+        ...
+
+    @composers.compose_left_dict(
+        {"x": composers.compose_left_unary(lambda: 1, lambda x: 1)}
+    )
+    def raises(x):
+        raise MyExceptionError("BAD")
+
+    @composers.compose_left_dict({"x": lambda: 1})
+    async def not_awaited(x):
+        raise base_types.SkipComputationError("DAB")
+
+    with pytest.raises(MyExceptionError, match="BAD"):
+        await graph_runners.nullary_infer_sink(
+            composers.compose_left_dict({"y": raises, "x": not_awaited}, lambda x, y: 1)
+        )
+    assert len(asyncio.all_tasks()) == 1
+
+
 async def test_raise_exception_in_sync_after_async():
     def raises(x):
         raise TypeError("BAD")
@@ -684,11 +725,11 @@ def test_compose_future():
     )(([[{a: 2, b: 2, c: 2}, 9], [{a: 2, b: 2, c: 2}, 25]]))
 
 
-def test_compose_future_async():
+async def test_compose_future_async():
     a = graph.make_source()
     b = graph.make_source()
     c = graph.make_source()
-    graph_runners.variadic_with_state_and_expectations(
+    await graph_runners.variadic_with_state_and_expectations(
         base_types.merge_graphs(
             composers.compose_source_unary(_plus_1_async, c),
             composers.compose_source_unary(_times_2, b),

{computation_graph-60 → computation_graph-62}/computation_graph/run.py

@@ -226,32 +226,10 @@ def _to_callable_with_side_effect_for_single_and_multiple(
     if is_async:
 
         async def final_runner(sources_to_values):
-            node_to_task_or_result = _run_graph(
-                translate_source_to_placeholder(sources_to_values),
-                handled_exceptions,
-                topological_sorted_nodes,
+            inputs = translate_source_to_placeholder(sources_to_values)
+            all_results = await _run_graph_async(
+                inputs, handled_exceptions, topological_sorted_nodes
             )
-            results_by_is_async = _group_by_is_future(node_to_task_or_result.items())
-            async_results = tuple(zip(*results_by_is_async.get(True, ())))
-            sync_results = dict(results_by_is_async.get(False, ()))
-
-            all_results = sync_results
-            if async_results:
-                for (node, node_result) in zip(
-                    async_results[0],
-                    await asyncio.gather(*async_results[1], return_exceptions=True),
-                ):
-                    e = node_to_task_or_result[node].exception()
-                    if e and not isinstance(
-                        e,
-                        (
-                            _DepNotFoundError,
-                            base_types.SkipComputationError,
-                            *handled_exceptions,
-                        ),
-                    ):
-                        raise e from e
-                    all_results[node] = node_result
 
             return all_node_side_effects_on_edges(all_results)
 
@@ -504,6 +482,57 @@ def _make_get_node_executor(
     return get_executor
 
 
+async def _run_graph_async(inputs, handled_exceptions, topological_sorted_nodes):
+    node_to_task_or_result = inputs.copy()
+    unhandled_exception = None
+    try:
+        for node_executor in topological_sorted_nodes:
+            try:
+                node_to_task_or_result[node_executor[0]] = node_executor[1](
+                    node_to_task_or_result, node_executor[0]
+                )
+            except (
+                _DepNotFoundError,
+                base_types.SkipComputationError,
+                *handled_exceptions,
+            ):
+                pass
+    except Exception as exc:
+        unhandled_exception = exc
+    finally:
+        results_by_is_async = _group_by_is_future(node_to_task_or_result.items())
+        async_results = tuple(zip(*results_by_is_async.get(True, ())))
+        sync_results = dict(results_by_is_async.get(False, ()))
+
+        all_results = sync_results
+        if async_results:
+            for (node, node_result) in zip(
+                async_results[0],
+                await asyncio.gather(*async_results[1], return_exceptions=True),
+            ):
+                task_e = node_to_task_or_result[node].exception()
+                if not task_e:
+                    all_results[node] = node_result
+                elif not unhandled_exception and not isinstance(
+                    task_e,
+                    (
+                        _DepNotFoundError,
+                        base_types.SkipComputationError,
+                        *handled_exceptions,
+                    ),
+                ):
+                    unhandled_exception = task_e
+        if unhandled_exception:
+            # this trick avoids cyclic reference and garbage collection issues
+            try:
+                raise unhandled_exception from unhandled_exception
+            except Exception as e:
+                del node_to_task_or_result
+                del unhandled_exception
+                raise e from e
+    return all_results
+
+
 def _run_graph(
     inputs: dict,
     handled_exceptions,

{computation_graph-60 → computation_graph-62}/computation_graph.egg-info/PKG-INFO

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

{computation_graph-60 → computation_graph-62}/setup.py

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