break/REFACT(NET): screm on execute (not compute) ...

so as caompute() calmly calculates needs/provides,
based on given IO.

Author: ankostis

graphtik/netop.py

@@ -207,7 +207,10 @@ def compute(self, named_inputs, outputs=None, recompile=None) -> dict:
             )
 
             solution = plan.execute(
-                named_inputs, self.overwrites_collector, self.execution_method
+                named_inputs,
+                outputs,
+                overwrites=self.overwrites_collector,
+                method=self.execution_method,
             )
 
             return solution

graphtik/network.py

@@ -397,25 +397,37 @@ def _execute_sequential_method(self, solution, overwrites, executed):
             else:
                 raise AssertionError("Unrecognized instruction.%r" % step)
 
-    def execute(self, named_inputs, overwrites=None, method=None):
+    def execute(self, named_inputs, outputs=None, *, overwrites=None, method=None):
         """
         :param named_inputs:
             A maping of names --> values that must contain at least
             the compulsory inputs that were specified when the plan was built
             (but cannot enforce that!).
             Cloned, not modified.
-
+        :param outputs:
+            If not None, they are just checked if possible, based on :attr:`provides`,
+            and scream if not.
         :param overwrites:
             (optional) a mutable dict to collect calculated-but-discarded values
             because they were "pinned" by input vaules.
             If missing, the overwrites values are simply discarded.
 
         :raises ValueError:
-            If given `inputs` mismatched `plan.needs`, with msg:
+            - If given `inputs` mismatched `plan.needs`, with msg:
 
                 *Plan needs more inputs...*
+            - If `outputs` asked cannot be produced by the `graph`, with msg:
+
+                *Impossible outputs...*
+
+            - If cannot produce any `outputs` from the given `inputs`, with msg:
+
+                *Unsolvable graph: ...*
         """
         try:
+            if not self.dag:
+                raise ValueError(f"Unsolvable graph:\n  {self}")
+
             # Check plan<-->inputs mismatch.
             #
             missing = iset(self.needs) - iset(named_inputs)
@@ -425,6 +437,17 @@ def execute(self, named_inputs, overwrites=None, method=None):
                     f"\n  given inputs: {list(named_inputs)}\n  {self}"
                 )
 
+            if outputs is not None:
+                unknown = (
+                    iset(astuple(outputs, "outputs", allowed_types=abc.Sequence))
+                    - self.provides
+                )
+                if unknown:
+                    raise ValueError(
+                        f"Impossible outputs: {list(unknown)}\n for graph: {self}"
+                        f"\n  {self}"
+                    )
+
             # choose a method of execution
             executor = (
                 self._execute_thread_pool_barrier_method
@@ -614,10 +637,6 @@ def prune(
             - if `outputs` asked do not exist in network, with msg:
 
                 *Unknown output nodes: ...*
-
-            - if `outputs` asked cannot be produced by the `graph`, with msg:
-
-                *Impossible outputs...*
         """
         # TODO: break cycles here.
         dag = self.graph
@@ -678,13 +697,6 @@ def prune(
             outputs = iset(
                 n for n in self.provides if n not in inputs and n in pruned_dag
             )
-        else:
-            unknown = iset(outputs) - pruned_dag
-            if unknown:
-                raise ValueError(
-                    f"Impossible outputs: {list(unknown)}\n for graph: {pruned_dag.nodes}"
-                    f"\n  {self}"
-                )
 
         assert all(_yield_datanodes(pruned_dag)), pruned_dag
         assert inputs is not None and not isinstance(inputs, str)
@@ -847,11 +859,6 @@ def compile(
             plan = self._cached_plans[cache_key]
         else:
             pruned_dag, broken_edges, needs, provides = self.prune(inputs, outputs)
-            if not pruned_dag:
-                raise ValueError(
-                    f"Unsolvable graph:\n  needs: {inputs}\n  provides: {outputs}\n  {self}"
-                )
-
             steps = self._build_execution_steps(pruned_dag, needs, outputs or ())
             plan = ExecutionPlan(
                 self,

test/test_graphtik.py

@@ -181,23 +181,32 @@ def powers_in_trange(a, exponent):
     }
 
     inputs = {"a": 1, "b": 2, "exponent": 3}
-    plan = net.compile(outputs=None, inputs=inputs.keys())
-    sol = plan.execute(named_inputs=inputs)
+    outputs = None
+    plan = net.compile(outputs=outputs, inputs=inputs.keys())
+    sol = plan.execute(inputs)
+    assert sol == exp
+    sol = plan.execute(inputs, outputs)
     assert sol == exp
 
     # get specific outputs
     exp = {"sum_ab_times_b": 6}
-    plan = net.compile(outputs=["sum_ab_times_b"], inputs=list(inputs))
-    sol = plan.execute(named_inputs=inputs)
+    outputs=["sum_ab_times_b"]
+    plan = net.compile(outputs=outputs, inputs=list(inputs))
+    sol = plan.execute(inputs)
+    assert sol == exp
+    sol = plan.execute(inputs, outputs)
     assert sol == exp
 
     # start with inputs already computed
     inputs = {"sum_ab": 1, "b": 2, "exponent": 3}
     exp = {"sum_ab_times_b": 2}
-    plan = net.compile(outputs=["sum_ab_times_b"], inputs=inputs)
+    outputs=["sum_ab_times_b"]
+    plan = net.compile(outputs=outputs, inputs=inputs)
     with pytest.raises(ValueError, match=r"Plan needs more inputs:"):
         sol = plan.execute(named_inputs={"sum_ab": 1})
-    sol = plan.execute(named_inputs=inputs)
+    sol = plan.execute(inputs)
+    assert sol == exp
+    sol = plan.execute(inputs, outputs)
     assert sol == exp
 
 
@@ -790,8 +799,9 @@ def add(a=0, b=0):
         == "NetworkOperation('t', needs=[optional('a')], provides=['sum1'])"
     )
 
-    with pytest.raises(ValueError, match="Impossible outputs:"):
-        compose("t", *ops, needs="bb", provides=["sum2"])
+    netop = compose("t", *ops, needs="bb", provides=["sum2"])
+    with pytest.raises(ValueError, match="Unsolvable graph:"):
+        netop.compute({'bb': 11})
 
     ## Narrow by unknown needs
     #
@@ -845,7 +855,7 @@ def test_sideffect_no_real_data(exemethod, netop_sideffect1: NetworkOperation):
     with pytest.raises(ValueError, match="Unsolvable graph"):
         assert graph.compute(inp, recompile=True)
 
-    with pytest.raises(ValueError, match="Impossible output"):
+    with pytest.raises(ValueError, match="Unsolvable graph"):
         graph.compute(inp, ["box", sideffect("b")])
 
     with pytest.raises(ValueError, match="Plan needs more inputs"):
@@ -859,7 +869,7 @@ def test_sideffect_no_real_data(exemethod, netop_sideffect1: NetworkOperation):
     assert sol == {"box": [1, 2, 3], sideffect("a"): True}
     #
     # bad, not asked the out-sideffect
-    with pytest.raises(ValueError, match="Impossible output"):
+    with pytest.raises(ValueError, match="Unsolvable graph"):
         sol = graph.compute({"box": [0], sideffect("a"): True}, "box")
     #
     # ok, asked the 1st out-sideffect