flowrep 0.6.1__tar.gz → 0.6.2__tar.gz

{flowrep-0.6.1 → flowrep-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowrep
-Version: 0.6.1
+Version: 0.6.2
 Summary: flowrep - Your premier tool for workflow representations
 Project-URL: Homepage, https://pyiron.org/
 Project-URL: Documentation, https://flowrep.readthedocs.io

{flowrep-0.6.1 → flowrep-0.6.2}/src/flowrep/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.6.1'
-__version_tuple__ = version_tuple = (0, 6, 1)
+__version__ = version = '0.6.2'
+__version_tuple__ = version_tuple = (0, 6, 2)
 
 __commit_id__ = commit_id = None

{flowrep-0.6.1 → flowrep-0.6.2}/src/flowrep/base_models.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import abc
 import inspect
 import keyword
 from collections.abc import Hashable
@@ -94,7 +95,7 @@ UniqueList = Annotated[list[T], pydantic.AfterValidator(validate_unique)]
 Labels = UniqueList[Label]
 
 
-class NodeRecipe(pydantic.BaseModel):
+class NodeRecipe(pydantic.BaseModel, abc.ABC):
     type: RecipeElementType
     inputs: Labels
     outputs: Labels
@@ -131,6 +132,7 @@ class NodeRecipe(pydantic.BaseModel):
     def validate_internal_data_completeness(self):
         return self
 
+    @abc.abstractmethod
     def __call__(self, *args, **kwargs):
         raise NotImplementedError(
             f"{self.__class__.__name__} is not a callable recipe type"

{flowrep-0.6.1 → flowrep-0.6.2}/src/flowrep/prospective/for_recipe.py

@@ -179,3 +179,9 @@ class ForEachRecipe(base_models.NodeRecipe):
             self.prospective_nodes, self.input_edges
         )
         return self
+
+    def __call__(self, *args, **kwargs):
+        from flowrep import wfms
+
+        data = wfms._run_for(self, **wfms.variadic_to_inputs(self, *args, **kwargs))
+        return wfms.data_to_return(data)

{flowrep-0.6.1 → flowrep-0.6.2}/src/flowrep/prospective/if_recipe.py

@@ -116,3 +116,9 @@ class IfRecipe(base_models.NodeRecipe):
             self.prospective_nodes, self.input_edges
         )
         return self
+
+    def __call__(self, *args, **kwargs):
+        from flowrep import wfms
+
+        data = wfms._run_if(self, **wfms.variadic_to_inputs(self, *args, **kwargs))
+        return wfms.data_to_return(data)

{flowrep-0.6.1 → flowrep-0.6.2}/src/flowrep/prospective/try_recipe.py

@@ -103,3 +103,9 @@ class TryRecipe(base_models.NodeRecipe):
             self.prospective_nodes, self.input_edges
         )
         return self
+
+    def __call__(self, *args, **kwargs):
+        from flowrep import wfms
+
+        data = wfms._run_try(self, **wfms.variadic_to_inputs(self, *args, **kwargs))
+        return wfms.data_to_return(data)

{flowrep-0.6.1 → flowrep-0.6.2}/src/flowrep/prospective/while_recipe.py

@@ -143,3 +143,9 @@ class WhileRecipe(base_models.NodeRecipe):
             self.prospective_nodes, self.input_edges
         )
         return self
+
+    def __call__(self, *args, **kwargs):
+        from flowrep import wfms
+
+        data = wfms._run_while(self, **wfms.variadic_to_inputs(self, *args, **kwargs))
+        return wfms.data_to_return(data)

{flowrep-0.6.1 → flowrep-0.6.2}/src/flowrep/prospective/workflow_recipe.py

@@ -87,10 +87,12 @@ class WorkflowRecipe(base_models.NodeRecipe):
 
     def __call__(self, *args, **kwargs):
         if self.reference is None:
-            raise ValueError(
-                f"{self.__class__.__name__} recipes are only callable when they are "
-                f"attached to an underlying python definiton in their reference field."
+            from flowrep import wfms
+
+            data = wfms._run_workflow(
+                self, **wfms.variadic_to_inputs(self, *args, **kwargs)
             )
+            return wfms.data_to_return(data)
         func = retrieve.import_from_string(self.reference.info.fully_qualified_name)
         return func(*args, **kwargs)
 

{flowrep-0.6.1 → flowrep-0.6.2}/src/flowrep/wfms.py

@@ -30,6 +30,10 @@ from flowrep.prospective import (
 from flowrep.retrospective import datastructures
 
 
+def _unsupported_recipe(recipe: Any) -> TypeError:
+    return TypeError(f"Unsupported recipe type: {type(recipe).__name__}")
+
+
 def run_recipe(
     recipe: union_types.RecipeDiscrimination, **kwargs: Any
 ) -> datastructures.NodeData:
@@ -37,7 +41,12 @@ def run_recipe(
     Execute a flowrep recipe, returning a populated :class:`LiveNode`.
 
     All inputs are passed as keyword arguments matching the recipe's input port names.
+    Inputs backed by a python default may be omitted; anything else must be supplied.
     """
+    if not isinstance(recipe, base_models.NodeRecipe):
+        # Guard before binding, which needs the recipe's input labels
+        raise _unsupported_recipe(recipe)
+    kwargs = variadic_to_inputs(recipe, **kwargs)
     match recipe:
         case atomic_recipe.AtomicRecipe():
             return _run_atomic(recipe, **kwargs)
@@ -54,7 +63,7 @@ def run_recipe(
         case while_recipe.WhileRecipe():
             return _run_while(recipe, **kwargs)
         case _:
-            raise TypeError(f"Unsupported recipe type: {type(recipe).__name__}")
+            raise _unsupported_recipe(recipe)
 
 
 # ---------------------------------------------------------------------------
@@ -205,6 +214,25 @@ def _populate_workflow_outputs(
 # ---------------------------------------------------------------------------
 
 
+def _iterated_value(
+    node: datastructures.ForEachData, for_port: str, body_port: str
+) -> Collection:
+    """
+    The value to scatter over one iterated port.
+
+    A for-node cannot fall back on a default here the way an atomic child can -- there
+    is nothing to iterate -- so an unfilled port is reported directly, rather than
+    leaking a bare ``NotData`` into ``itertools.product``.
+    """
+    value = node.input_ports[for_port].value
+    if isinstance(value, datastructures.NotData):
+        raise ValueError(
+            f"Iterated input '{for_port}' (body port '{body_port}') has no value to "
+            f"iterate over"
+        )
+    return cast(Collection, value)
+
+
 def _run_for(
     recipe: for_recipe.ForEachRecipe, **kwargs: Any
 ) -> datastructures.ForEachData:
@@ -244,15 +272,14 @@ def _run_for(
 
     # Build iteration axes
     nested_iters = [
-        cast(Collection, node.input_ports[body_to_for[p]].value)
-        for p in recipe.nested_ports
+        _iterated_value(node, body_to_for[p], p) for p in recipe.nested_ports
     ]
     zipped_iters = [
-        cast(Collection, node.input_ports[body_to_for[p]].value)
-        for p in recipe.zipped_ports
+        _iterated_value(node, body_to_for[p], p) for p in recipe.zipped_ports
     ]
-    # Note that we simply cast iterated input values to the form we expect, and let the
-    # user pay the price if runtime data is non-compliant.
+    # Note that beyond insisting the value arrived at all, we simply cast iterated
+    # input values to the form we expect, and let the user pay the price if runtime
+    # data is non-compliant.
 
     nested_combos = list(itertools.product(*nested_iters)) if nested_iters else [()]
     if zipped_iters:
@@ -504,3 +531,65 @@ def _populate_prospective_outputs(
                     source.port
                 ].value
                 break
+
+
+def variadic_to_inputs(recipe: base_models.NodeRecipe, /, *args, **kwargs):
+    """
+    Bind ``*args`` and ``**kwargs`` onto ``recipe.inputs``, as a helper for
+    ``NodeRecipe.__call__`` implementations and the generic recipe runner.
+
+    Every input must be filled except those in ``recipe.inputs_with_defaults``, which
+    only recipes backed by an underlying python function have any of. Nothing else can
+    supply a value after the fact, so an unfilled input is simply a missing one --
+    which is exactly the invariant
+    :func:`subgraph_validation.validate_nodes_are_fully_sourced` already holds children
+    to, so validated recipes bind their own children by construction.
+
+    Binding failures raise :class:`TypeError`, mirroring python's own behaviour for
+    bad call signatures. (Deliberately not :class:`ValueError`: recipes catch
+    exceptions by type, and a try-recipe handling ``ValueError`` must not be able to
+    swallow its caller's mistake and quietly return partial data.)
+    """
+    who = f"{type(recipe).__name__}()"
+    if len(args) > len(recipe.inputs):
+        raise TypeError(
+            f"One of your {who} calls takes {len(recipe.inputs)} inputs but "
+            f"{len(args)} positional arguments were given -- its inputs are "
+            f"{recipe.inputs}"
+        )
+    inputs = {}
+    for label, val in zip(recipe.inputs, args, strict=False):
+        inputs[label] = val
+    for label, val in kwargs.items():
+        if label in inputs:
+            raise TypeError(
+                f"One of your {who} calls got multiple values for input '{label}' -- "
+                f"as a positional arg ({inputs[label]}) and as a kwarg ({val})"
+            )
+        if label in recipe.inputs:
+            inputs[label] = val
+        else:
+            raise TypeError(
+                f"One of your {who} calls got an unexpected input '{label}' -- its "
+                f"inputs are {recipe.inputs}"
+            )
+    missing = [
+        label
+        for label in recipe.inputs
+        if label not in inputs and label not in recipe.inputs_with_defaults
+    ]
+    if missing:
+        raise TypeError(
+            f"One of your {who} calls is missing {len(missing)} required "
+            f"input: {missing}"
+        )
+    return inputs
+
+
+def data_to_return(data: datastructures.NodeData):
+    """A helper for ``NodeRecipe.__call__`` implementations"""
+    returns = tuple(p.value for p in data.output_ports.values())
+    if len(returns) == 1:
+        return returns[0]
+    else:
+        return returns