computation-graph 61__tar.gz → 63__tar.gz

{computation_graph-61 → computation_graph-63}/PKG-INFO

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

{computation_graph-61 → computation_graph-63}/computation_graph/composers/debug.py

@@ -43,5 +43,6 @@ debug_log = _debug_with_frame(_debug_log_inner)
 
 
 def name_callable(f: Callable, name: str) -> Callable:
+    f.__code__ = f.__code__.replace(co_name=name)
     f.__name__ = name
     return f

{computation_graph-61 → computation_graph-63}/computation_graph/composers/duplication.py

@@ -6,6 +6,7 @@ from typing import Dict
 import gamla
 
 from computation_graph import base_types, graph
+from computation_graph.composers import debug
 
 
 def duplicate_function(func):
@@ -15,14 +16,13 @@ def duplicate_function(func):
         async def inner(*args, **kwargs):
             return await func(*args, **kwargs)
 
-        return inner
+    else:
 
-    @functools.wraps(func)
-    def inner(*args, **kwargs):
-        return func(*args, **kwargs)
+        @functools.wraps(func)
+        def inner(*args, **kwargs):
+            return func(*args, **kwargs)
 
-    inner.__name__ = f"duplicate of {inner.__name__}"
-    return inner
+    return debug.name_callable(inner, f"duplicate of {func.__name__}")
 
 
 def _duplicate_computation_edge(get_duplicated_node):

{computation_graph-61 → computation_graph-63}/computation_graph/graph_test.py

@@ -276,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")
@@ -704,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-61 → computation_graph-63}/computation_graph/run.py

@@ -226,33 +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 not e:
-                        all_results[node] = node_result
-                    elif not isinstance(
-                        e,
-                        (
-                            _DepNotFoundError,
-                            base_types.SkipComputationError,
-                            *handled_exceptions,
-                        ),
-                    ):
-                        raise e from e
 
             return all_node_side_effects_on_edges(all_results)
 
@@ -505,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-61 → computation_graph-63}/computation_graph.egg-info/PKG-INFO

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

{computation_graph-61 → computation_graph-63}/setup.py

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