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

{computation_graph-56 → computation_graph-58}/PKG-INFO

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

{computation_graph-56 → computation_graph-58}/computation_graph/graph_test.py

@@ -233,6 +233,17 @@ def test_first():
     )
 
 
+def test_raise_unhandled_exception():
+    class MyExceptionError(Exception):
+        ...
+
+    def raises():
+        raise MyExceptionError("BAD")
+
+    with pytest.raises(MyExceptionError, match="BAD"):
+        graph_runners.nullary_infer_sink(composers.make_first(raises, lambda: 1))
+
+
 def test_first_all_unactionable():
     def raises():
         raise base_types.SkipComputationError

{computation_graph-56 → computation_graph-58}/computation_graph/run.py

@@ -29,7 +29,6 @@ import typeguard
 from gamla.optimized import sync as opt_gamla
 
 from computation_graph import base_types, composers, graph, signature
-from computation_graph.composers import debug
 
 CG_NO_RESULT = "CG_NO_RESULT"
 
@@ -44,6 +43,16 @@ _SingleNodeSideEffect = Callable[[base_types.ComputationNode, Any], None]
 _ComputationInputSpec = Tuple[
     Tuple[base_types.ComputationNode, ...], Dict[str, base_types.ComputationNode]
 ]
+_NodeExecutor = Callable[
+    [
+        Mapping[
+            base_types.ComputationNode,
+            base_types.Result | Awaitable[base_types.Result],
+        ],
+        base_types.ComputationNode,
+    ],
+    base_types.Result,
+]
 
 
 def _transpose_graph(
@@ -63,6 +72,12 @@ _toposort_nodes: Callable[
     ),
     _transpose_graph,
     toposort.toposort,
+    # Make async functions come first in each layer so they'll start running before all the sync functions
+    opt_gamla.maptuple(
+        gamla.sort_by(lambda n: 0 if inspect.iscoroutinefunction(n.func) else 1)
+    ),
+    gamla.concat,
+    tuple,
 )
 
 
@@ -198,14 +213,8 @@ def _to_callable_with_side_effect_for_single_and_multiple(
     topological_layers = opt_gamla.pipe(
         edges,
         _toposort_nodes,
-        gamla.map_filter_empty(
-            gamla.compose_left(
-                gamla.remove(gamla.contains(placeholder_to_future_source)),
-                opt_gamla.map(opt_gamla.pair_right(get_node_executor)),
-                frozenset,
-            )
-        ),
-        tuple,
+        gamla.remove(gamla.contains(placeholder_to_future_source)),
+        opt_gamla.maptuple(opt_gamla.pair_right(get_node_executor)),
     )
 
     translate_source_to_placeholder = opt_gamla.compose_left(
@@ -214,18 +223,16 @@ def _to_callable_with_side_effect_for_single_and_multiple(
     )
     all_node_side_effects_on_edges = gamla.side_effect(all_nodes_side_effect(edges))
 
-    reduce_layers = _make_reduce_layers(handled_exceptions)
-
     if is_async:
 
         async def final_runner(sources_to_values):
             d = gamla.pipe(
                 topological_layers,
-                reduce_layers(
-                    immutables.Map(translate_source_to_placeholder(sources_to_values))
+                _run_graph(
+                    translate_source_to_placeholder(sources_to_values),
+                    handled_exceptions,
                 ),
                 dict,
-                gamla.side_effect(all_node_side_effects_on_edges),
             )
             results_by_is_async = _group_by_is_async_result(d.items())
             async_results = tuple(zip(*results_by_is_async.get(True, ())))
@@ -253,8 +260,9 @@ def _to_callable_with_side_effect_for_single_and_multiple(
         def final_runner(sources_to_values):
             return gamla.pipe(
                 topological_layers,
-                reduce_layers(
-                    immutables.Map(translate_source_to_placeholder(sources_to_values))
+                _run_graph(
+                    translate_source_to_placeholder(sources_to_values),
+                    handled_exceptions,
                 ),
                 dict,
                 all_node_side_effects_on_edges,
@@ -483,18 +491,7 @@ def _make_get_node_executor(
     sync_and_downstream = sync & downstream_from_async
     sync_not_downstream = sync - downstream_from_async
 
-    def get_executor(
-        node: base_types.ComputationNode,
-    ) -> Callable[
-        [
-            Mapping[
-                base_types.ComputationNode,
-                base_types.Result | Awaitable[base_types.Result],
-            ],
-            base_types.ComputationNode,
-        ],
-        base_types.Result,
-    ]:
+    def get_executor(node: base_types.ComputationNode) -> _NodeExecutor:
         if node in async_and_downstream:
             return await_deps_and_await
         if node in async_not_downstream:
@@ -509,48 +506,25 @@ def _make_get_node_executor(
     return get_executor
 
 
-def _make_reduce_layers(
-    handled_exceptions: Tuple[Type[Exception], ...]
-) -> Callable[[immutables.Map], Callable[[Tuple[FrozenSet, ...]], immutables.Map]]:
-    def apply_executor(accumulated_results, node, executor):
-        try:
-            return node, executor(accumulated_results, node)
-        except (
-            _DepNotFoundError,
-            base_types.SkipComputationError,
-            *handled_exceptions,
-        ):
-            # We delete the references to the upstream tasks to avoid circular reference (task->exception->traceback->task) and improve memory performance
-            del accumulated_results
-            return None
-
-    single_layer_reducer = debug.name_callable(
-        gamla.compose_left(
-            gamla.pack,
-            gamla.juxt(
-                gamla.head,
-                gamla.compose_left(
-                    gamla.explode(1),
-                    opt_gamla.map(
-                        lambda results__node_executor: apply_executor(
-                            results__node_executor[0],
-                            results__node_executor[1][0],
-                            results__node_executor[1][1],
-                        )
-                    ),
-                    opt_gamla.filter(bool),
-                    tuple,
-                ),
-            ),
-            opt_gamla.star(
-                lambda prev_results, current_results: prev_results.update(
-                    current_results
+def _run_graph(inputs: dict, handled_exceptions):
+    def run_graph(
+        nodes: tuple[tuple[base_types.ComputationNode, _NodeExecutor]]
+    ) -> _NodeToResults:
+        accumulated_results = inputs.copy()
+        for node_executor in nodes:
+            try:
+                accumulated_results[node_executor[0]] = node_executor[1](
+                    accumulated_results, node_executor[0]
                 )
-            ),
-        ),
-        "single_layer_reducer",
-    )
-    return gamla.curry(gamla.reduce_curried)(single_layer_reducer)
+            except (
+                _DepNotFoundError,
+                base_types.SkipComputationError,
+                *handled_exceptions,
+            ):
+                pass
+        return accumulated_results
+
+    return run_graph
 
 
 def _graph_reducer(graph_callable):

{computation_graph-56 → computation_graph-58}/computation_graph.egg-info/PKG-INFO

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

{computation_graph-56 → computation_graph-58}/setup.py

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