flowrep 0.4.0__tar.gz → 0.5.0__tar.gz

{flowrep-0.4.0 → flowrep-0.5.0}/.gitignore

@@ -1,5 +1,6 @@
 *.pyc
 .DS_Store
+.claude/
 .coverage
 .pre-commit-config.yaml
 nohup.out
@@ -10,5 +11,6 @@ _build/
 apidoc/
 .ipynb_checkpoints/
 test_times.dat
+CLAUD.md
 core.*
 src/flowrep/_version.py

{flowrep-0.4.0 → flowrep-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowrep
-Version: 0.4.0
+Version: 0.5.0
 Summary: flowrep - Your premier tool for workflow representations
 Project-URL: Homepage, https://pyiron.org/
 Project-URL: Documentation, https://flowrep.readthedocs.io
@@ -50,13 +50,13 @@ Requires-Python: <3.15,>=3.11
 Requires-Dist: pydantic<2.13.0,>=2.12.0
 Requires-Dist: pyiron-snippets<2.0.0,>=1.2.1
 Provides-Extra: notebooks
-Requires-Dist: numpy==2.4.3; extra == 'notebooks'
+Requires-Dist: numpy==2.4.6; extra == 'notebooks'
 Provides-Extra: pwd
-Requires-Dist: python-workflow-definition==0.1.4; extra == 'pwd'
+Requires-Dist: python-workflow-definition==0.1.5; extra == 'pwd'
 Provides-Extra: storage
-Requires-Dist: bagofholding==0.1.10; extra == 'storage'
+Requires-Dist: bagofholding==0.1.11; extra == 'storage'
 Provides-Extra: storage-widget
-Requires-Dist: bagofholding==0.1.10; extra == 'storage-widget'
+Requires-Dist: bagofholding==0.1.11; extra == 'storage-widget'
 Requires-Dist: ipytree==0.2.2; extra == 'storage-widget'
 Description-Content-Type: text/markdown
 
@@ -76,10 +76,11 @@ Description-Content-Type: text/markdown
 ## flowrep — Workflow Recipes from Python
 
 **flowrep** turns plain Python functions into shareable, versionable *workflow
-recipes* — JSON-serialisable graphs that describe *what* to compute (which
+recipes* — JSON-serialisable "class view" graphs that describe *what* to compute (which
 functions, how they connect) without doing the computation or holding any data.
 Recipes are prospective blueprints that a Workflow Management System (WfMS) can
-digest, visualise, and execute.
+digest, visualise, and execute. To support this, **flowrep** also provides a set of 
+retrospective, "instance view" data classes for WfMS to populate when executing recipes.
 
 Flowchart-style representations are already the lingua franca for describing
 processes in science and engineering. flowrep gives you a way to author them in
@@ -209,6 +210,9 @@ control structures you use in real code. Flow control nodes are inherently
 dynamic: their exact execution path depends on data and cannot be known until
 run-time, but their IO signature is always fully known a priori.
 
+**Clear separation.** Of prospective, "class view" recipes, and retrospective, 
+"instance view" data objects.
+
 ### Example: flow control and nesting
 
 So far we've seen `"workflow"` nodes, and alluded to `"atomic"` nodes.
@@ -307,7 +311,7 @@ the decorated functions are still just python functions; second, to show in the
 section that the recipe we parse from this are intended to give the same result as 
 these underlying functions when we run the recipe with a WfMS.
 
-## Beyond Recipes: Live Data and Execution
+## Beyond Recipes: Retrospective "Instance View" Data and Execution
 
 Recipes are *prospective* — they describe a computation template without holding
 data. For retrospective analysis (inspecting what actually happened during a
@@ -318,18 +322,18 @@ run), flowrep provides two additional layers accessible through the API:
 
 ```
 
-**`flowrep.api.tools.recipe2live`** converts a recipe into a *live* object — a mutable
-data structure whose input and output ports can hold actual Python values. Live
-objects mirror the recipe graph but trade JSON-serializability for the ability to
-carry arbitrary data:
+**`flowrep.api.tools.recipe2data`** converts a recipe from the prospective "class view"
+to the retrospective "instance view" — a mutable data structure whose input and output 
+ports can hold actual Python values. Retrospective data objects mirror the recipe graph
+but trade JSON-serializability for the ability to carry arbitrary data:
 
 ```python
->>> live_wf = frt.recipe2live(double_and_add.flowrep_recipe)
+>>> wf_data = frt.recipe2data(double_and_add.flowrep_recipe)
 
 ```
 
 **`flowrep.api.tools.run_recipe`** goes one step further: it executes the recipe with
-the provided inputs and returns a fully populated live object. This is powered
+the provided inputs and returns a fully populated data object. This is powered
 by a minimal, built-in WfMS intended as a reference implementation and for use
 in tests and documentation (like this!):
 
@@ -342,8 +346,8 @@ in tests and documentation (like this!):
 
 ```
 
-Because every child node's ports are populated too, the live graph gives you
-full data provenance — you can walk the tree and inspect exactly what each node
+Because every child node's ports are populated too, the retrospective data graph gives 
+you full data provenance — you can walk the tree and inspect exactly what each node
 received and produced.
 For flow control nodes, which are _prospectively_ "black boxes", we find that 
 _retrospectively_ they are simple DAGs.
@@ -360,14 +364,13 @@ each loop iteration:
 ```
 
 For a deeper look at all available node types, edge semantics, version
-provenance, and the live/WfMS layer, see the
+provenance, and the retropective data/WfMS layer, see the
 [user guide](https://mybinder.org/v2/gh/pyiron/flowrep/HEAD?urlpath=%2Fdoc%2Ftree%2Fuser-guide.ipynb).
 
 
 ## Documentation
 
-- The user guide notebook comprehensively covers all node types, edge models, flow control, versioning, 
-  live/retrospective data formats, a demo WfMS implementation, and recipe format converters. 
+- The user guide notebook comprehensively covers all node types, edge models, flow control, versioning, retrospective data formats, a demo WfMS implementation, and recipe format converters. 
   Launch it interactively on
   [mybinder](https://mybinder.org/v2/gh/pyiron/flowrep/HEAD?urlpath=%2Fdoc%2Ftree%2Fuser-guide.ipynb).
 - [readthedocs](https://flowrep.readthedocs.io/en/latest/)

{flowrep-0.4.0 → flowrep-0.5.0}/docs/README.md

@@ -14,10 +14,11 @@
 ## flowrep — Workflow Recipes from Python
 
 **flowrep** turns plain Python functions into shareable, versionable *workflow
-recipes* — JSON-serialisable graphs that describe *what* to compute (which
+recipes* — JSON-serialisable "class view" graphs that describe *what* to compute (which
 functions, how they connect) without doing the computation or holding any data.
 Recipes are prospective blueprints that a Workflow Management System (WfMS) can
-digest, visualise, and execute.
+digest, visualise, and execute. To support this, **flowrep** also provides a set of 
+retrospective, "instance view" data classes for WfMS to populate when executing recipes.
 
 Flowchart-style representations are already the lingua franca for describing
 processes in science and engineering. flowrep gives you a way to author them in
@@ -147,6 +148,9 @@ control structures you use in real code. Flow control nodes are inherently
 dynamic: their exact execution path depends on data and cannot be known until
 run-time, but their IO signature is always fully known a priori.
 
+**Clear separation.** Of prospective, "class view" recipes, and retrospective, 
+"instance view" data objects.
+
 ### Example: flow control and nesting
 
 So far we've seen `"workflow"` nodes, and alluded to `"atomic"` nodes.
@@ -245,7 +249,7 @@ the decorated functions are still just python functions; second, to show in the
 section that the recipe we parse from this are intended to give the same result as 
 these underlying functions when we run the recipe with a WfMS.
 
-## Beyond Recipes: Live Data and Execution
+## Beyond Recipes: Retrospective "Instance View" Data and Execution
 
 Recipes are *prospective* — they describe a computation template without holding
 data. For retrospective analysis (inspecting what actually happened during a
@@ -256,18 +260,18 @@ run), flowrep provides two additional layers accessible through the API:
 
 ```
 
-**`flowrep.api.tools.recipe2live`** converts a recipe into a *live* object — a mutable
-data structure whose input and output ports can hold actual Python values. Live
-objects mirror the recipe graph but trade JSON-serializability for the ability to
-carry arbitrary data:
+**`flowrep.api.tools.recipe2data`** converts a recipe from the prospective "class view"
+to the retrospective "instance view" — a mutable data structure whose input and output 
+ports can hold actual Python values. Retrospective data objects mirror the recipe graph
+but trade JSON-serializability for the ability to carry arbitrary data:
 
 ```python
->>> live_wf = frt.recipe2live(double_and_add.flowrep_recipe)
+>>> wf_data = frt.recipe2data(double_and_add.flowrep_recipe)
 
 ```
 
 **`flowrep.api.tools.run_recipe`** goes one step further: it executes the recipe with
-the provided inputs and returns a fully populated live object. This is powered
+the provided inputs and returns a fully populated data object. This is powered
 by a minimal, built-in WfMS intended as a reference implementation and for use
 in tests and documentation (like this!):
 
@@ -280,8 +284,8 @@ in tests and documentation (like this!):
 
 ```
 
-Because every child node's ports are populated too, the live graph gives you
-full data provenance — you can walk the tree and inspect exactly what each node
+Because every child node's ports are populated too, the retrospective data graph gives 
+you full data provenance — you can walk the tree and inspect exactly what each node
 received and produced.
 For flow control nodes, which are _prospectively_ "black boxes", we find that 
 _retrospectively_ they are simple DAGs.
@@ -298,14 +302,13 @@ each loop iteration:
 ```
 
 For a deeper look at all available node types, edge semantics, version
-provenance, and the live/WfMS layer, see the
+provenance, and the retropective data/WfMS layer, see the
 [user guide](https://mybinder.org/v2/gh/pyiron/flowrep/HEAD?urlpath=%2Fdoc%2Ftree%2Fuser-guide.ipynb).
 
 
 ## Documentation
 
-- The user guide notebook comprehensively covers all node types, edge models, flow control, versioning, 
-  live/retrospective data formats, a demo WfMS implementation, and recipe format converters. 
+- The user guide notebook comprehensively covers all node types, edge models, flow control, versioning, retrospective data formats, a demo WfMS implementation, and recipe format converters. 
   Launch it interactively on
   [mybinder](https://mybinder.org/v2/gh/pyiron/flowrep/HEAD?urlpath=%2Fdoc%2Ftree%2Fuser-guide.ipynb).
 - [readthedocs](https://flowrep.readthedocs.io/en/latest/)

{flowrep-0.4.0 → flowrep-0.5.0}/pyproject.toml

@@ -28,9 +28,9 @@ Documentation = "https://flowrep.readthedocs.io"
 Repository = "https://github.com/pyiron/flowrep"
 
 [project.optional-dependencies]
-pwd = [ "python-workflow-definition==0.1.4",]
-notebooks = [ "numpy==2.4.3",]
-storage = [ "bagofholding==0.1.10",]
+pwd = [ "python-workflow-definition==0.1.5",]
+notebooks = [ "numpy==2.4.6",]
+storage = [ "bagofholding==0.1.11",]
 storage-widget = [ "flowrep[storage]", "ipytree==0.2.2",]
 
 [tool.ruff]

flowrep-0.5.0/src/flowrep/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)
+
+__commit_id__ = commit_id = None

flowrep-0.5.0/src/flowrep/api/schemas.py

@@ -0,0 +1,50 @@
+"""
+Pydantic models, types and classes, enums, and constants used in constructing or
+inspecting recipe models.
+
+Primarily intended for power-users like workflow management system (WfMS) designers to
+work deeply with recipe objects in a structured, well-typed way.
+"""
+
+from flowrep.base_models import RESERVED_NAMES as RESERVED_NAMES
+from flowrep.base_models import Label as Label
+from flowrep.base_models import Labels as Labels
+from flowrep.base_models import NodeRecipe as NodeRecipe
+from flowrep.base_models import PythonReference as PythonReference
+from flowrep.base_models import RecipeElementType as RecipeElementType
+from flowrep.base_models import RestrictedParamKind as RestrictedParamKind
+from flowrep.edge_models import Edges as Edges
+from flowrep.edge_models import InputEdges as InputEdges
+from flowrep.edge_models import InputSource as InputSource
+from flowrep.edge_models import OutputEdges as OutputEdges
+from flowrep.edge_models import OutputTarget as OutputTarget
+from flowrep.edge_models import SourceHandle as SourceHandle
+from flowrep.edge_models import TargetHandle as TargetHandle
+from flowrep.nodes.atomic_recipe import AtomicRecipe as AtomicRecipe
+from flowrep.nodes.atomic_recipe import UnpackMode as UnpackMode
+from flowrep.nodes.for_recipe import ForEachRecipe as ForEachRecipe
+from flowrep.nodes.helper_models import ConditionalCase as ConditionalCase
+from flowrep.nodes.helper_models import ExceptionCase as ExceptionCase
+from flowrep.nodes.helper_models import LabeledRecipe as LabeledRecipe
+from flowrep.nodes.if_recipe import IfRecipe as IfRecipe
+from flowrep.nodes.try_recipe import TryRecipe as TryRecipe
+from flowrep.nodes.union_types import RecipeDiscrimination as RecipeDiscrimination
+from flowrep.nodes.union_types import Recipes as Recipes
+from flowrep.nodes.while_recipe import WhileRecipe as WhileRecipe
+from flowrep.nodes.workflow_recipe import WorkflowRecipe as WorkflowRecipe
+from flowrep.retrospective import NOT_DATA as NOT_DATA
+from flowrep.retrospective import AtomicData as AtomicData
+from flowrep.retrospective import CompositeData as CompositeData
+from flowrep.retrospective import DagData as DagData
+from flowrep.retrospective import FlowControlData as FlowControlData
+from flowrep.retrospective import ForEachData as ForEachData
+from flowrep.retrospective import IfData as IfData
+from flowrep.retrospective import InputDataPort as InputDataPort
+from flowrep.retrospective import InputDataPorts as InputDataPorts
+from flowrep.retrospective import NodeData as NodeData
+from flowrep.retrospective import NotData as NotData
+from flowrep.retrospective import OutputDataPort as OutputDataPort
+from flowrep.retrospective import OutputDataPorts as OutputDataPorts
+from flowrep.retrospective import TryData as TryData
+from flowrep.retrospective import WhileData as WhileData
+from flowrep.subgraph_validation import ProspectiveOutputEdges as ProspectiveOutputEdges

{flowrep-0.4.0 → flowrep-0.5.0}/src/flowrep/api/tools.py

@@ -9,7 +9,7 @@ and the python-workflow-definition format. (When PWD is available in the environ
 Where PWD supports the workflow structure; round-trip from flowrep to PWD and back is
 lossy in versioning info.)
 
-Use `recipe2live` to convert recipes into state-ful data-ful instances of recipes,
+Use `recipe2data` to convert recipes into state-ful data-ful instances of recipes,
 which directly hold python objects (including, potentially, IO data values), but
 which no longer trivially serialize to JSON.
 
@@ -17,15 +17,16 @@ Use decorators (`@atomic` and `@workflow`) to attach a recipe as a `.flowrep_rec
 attribute onto a function at definition time, and parsers (`parse_atomic`,
 `parse_workflow`) to return a recipe from an existing function object.
 
-Use `run_recipe` to convert recipes into live objects with output data.
+Use `run_recipe` to convert recipes into retrospective instance objects with output
+data.
 """
 
 from flowrep.converters.python_workflow_definition import flowrep2pwd as flowrep2pwd
 from flowrep.converters.python_workflow_definition import pwd2flowrep as pwd2flowrep
-from flowrep.live import recipe2live as recipe2live
 from flowrep.parsers.atomic_parser import atomic as atomic
 from flowrep.parsers.atomic_parser import parse_atomic as parse_atomic
 from flowrep.parsers.workflow_parser import parse_workflow as parse_workflow
 from flowrep.parsers.workflow_parser import workflow as workflow
+from flowrep.retrospective import recipe2data as recipe2data
 from flowrep.storage import LexicalBagBrowser as LexicalBagBrowser
 from flowrep.wfms import run_recipe as run_recipe

{flowrep-0.4.0 → flowrep-0.5.0}/src/flowrep/base_models.py

@@ -69,7 +69,7 @@ UniqueList = Annotated[list[T], pydantic.AfterValidator(validate_unique)]
 Labels = UniqueList[Label]
 
 
-class NodeModel(pydantic.BaseModel):
+class NodeRecipe(pydantic.BaseModel):
     type: RecipeElementType
     inputs: Labels
     outputs: Labels
@@ -78,7 +78,7 @@ class NodeModel(pydantic.BaseModel):
     @classmethod
     def __pydantic_init_subclass__(cls, **kwargs):
         super().__pydantic_init_subclass__(**kwargs)
-        if cls.__name__ != NodeModel.__name__:  # I.e. for subclasses
+        if cls.__name__ != NodeRecipe.__name__:  # I.e. for subclasses
             type_field = cls.model_fields["type"]
             if type_field.default is pydantic_core.PydanticUndefined:
                 raise TypeError(

{flowrep-0.4.0 → flowrep-0.5.0}/src/flowrep/converters/python_workflow_definition.py

@@ -13,7 +13,7 @@ from typing import Any
 from pyiron_snippets import import_alarm, versions
 
 from flowrep import base_models, edge_models
-from flowrep.nodes import atomic_model, workflow_model
+from flowrep.nodes import atomic_recipe, workflow_recipe
 from flowrep.parsers import label_helpers
 
 with import_alarm.ImportAlarm(
@@ -66,7 +66,7 @@ def _desanitize_port(port: str) -> str:
 @_import_alarm
 def pwd2flowrep(
     wf: pwd.PythonWorkflowDefinitionWorkflow,
-) -> tuple[workflow_model.WorkflowNode, dict[str, pwd.AllowableDefaults]]:
+) -> tuple[workflow_recipe.WorkflowRecipe, dict[str, pwd.AllowableDefaults]]:
     """
     Convert a *python-workflow-definition* workflow to flowrep.
 
@@ -74,7 +74,7 @@ def pwd2flowrep(
         wf: A validated PWD workflow instance.
 
     Returns:
-        A ``(WorkflowNode, defaults)`` pair where *defaults* maps each
+        A ``(WorkflowRecipe, defaults)`` pair where *defaults* maps each
         workflow-input name to the default value carried by the corresponding
         PWD input node.
     """
@@ -101,7 +101,7 @@ def pwd2flowrep(
         label_map,
     )
 
-    result = workflow_model.WorkflowNode(
+    result = workflow_recipe.WorkflowRecipe(
         inputs=wf_inputs,
         outputs=wf_outputs,
         nodes=nodes,
@@ -114,13 +114,13 @@ def pwd2flowrep(
 
 @_import_alarm
 def flowrep2pwd(
-    wf: workflow_model.WorkflowNode,
+    wf: workflow_recipe.WorkflowRecipe,
     **terminal_inputs: pwd.AllowableDefaults,
 ) -> pwd.PythonWorkflowDefinitionWorkflow:
     """
-    Convert a flowrep :class:`WorkflowNode` to *python-workflow-definition*.
+    Convert a flowrep :class:`WorkflowRecipe` to *python-workflow-definition*.
 
-    Every child of *wf* must be an :class:`AtomicNode` (the pwd format does not
+    Every child of *wf* must be an :class:`AtomicRecipe` (the pwd format does not
     support nested sub-graphs).  A default value must be supplied for **every**
     workflow input via *terminal_inputs*.
 
@@ -176,7 +176,7 @@ def flowrep2pwd(
         nid = id_counter.next()
         func_node_ids[label] = nid
         # Guaranteed by _validate_flat_workflow
-        assert isinstance(node, atomic_model.AtomicNode)
+        assert isinstance(node, atomic_recipe.AtomicRecipe)
         pwd_nodes.append(
             pwd.PythonWorkflowDefinitionFunctionNode(
                 id=nid,
@@ -280,9 +280,9 @@ def _build_atomic_nodes(
     label_map: dict[int, str],
     node_inputs: dict[int, list[str]],
     node_outputs: dict[int, list[str]],
-) -> dict[str, atomic_model.AtomicNode]:
-    """Build flowrep :class:`AtomicNode` instances from PWD function nodes."""
-    nodes: dict[str, atomic_model.AtomicNode] = {}
+) -> dict[str, atomic_recipe.AtomicRecipe]:
+    """Build flowrep :class:`AtomicRecipe` instances from PWD function nodes."""
+    nodes: dict[str, atomic_recipe.AtomicRecipe] = {}
     for node_id in sorted(function_nodes):
         fn_node = function_nodes[node_id]
         label = label_map[node_id]
@@ -295,7 +295,7 @@ def _build_atomic_nodes(
         # This rsplit is at least consistent with the assumptions made in the PWD
         # ecosystem:
         # https://github.com/pythonworkflow/python-workflow-definition/blob/a372769e190176fe49e71740ad899937df0eeb94/src/python_workflow_definition/purepython.py#L80-L82
-        nodes[label] = atomic_model.AtomicNode(
+        nodes[label] = atomic_recipe.AtomicRecipe(
             reference=base_models.PythonReference(
                 info=versions.VersionInfo(
                     module=module,
@@ -375,18 +375,18 @@ class _IdCounter:
         return nid
 
 
-def _validate_flat_workflow(wf: workflow_model.WorkflowNode) -> None:
-    """Raise :class:`ValueError` if any child is not an :class:`AtomicNode`."""
+def _validate_flat_workflow(wf: workflow_recipe.WorkflowRecipe) -> None:
+    """Raise :class:`ValueError` if any child is not an :class:`AtomicRecipe`."""
     for label, node in wf.nodes.items():
-        if not isinstance(node, atomic_model.AtomicNode):
+        if not isinstance(node, atomic_recipe.AtomicRecipe):
             raise ValueError(
-                f"flowrep2pwd requires all children to be AtomicNode, but "
+                f"flowrep2pwd requires all children to be AtomicRecipe, but "
                 f"'{label}' is {type(node).__name__}."
             )
 
 
 def _validate_terminal_inputs(
-    wf: workflow_model.WorkflowNode,
+    wf: workflow_recipe.WorkflowRecipe,
     terminal_inputs: dict[str, Any],
 ) -> None:
     """Raise :class:`ValueError` if *terminal_inputs* != workflow inputs."""
@@ -419,7 +419,7 @@ def _flowrep_port_to_pwd_source_port(port: str) -> str | None:
 
 
 def _build_pwd_edges(
-    wf: workflow_model.WorkflowNode,
+    wf: workflow_recipe.WorkflowRecipe,
     input_node_ids: dict[str, int],
     output_node_ids: dict[str, int],
     func_node_ids: dict[str, int],

{flowrep-0.4.0 → flowrep-0.5.0}/src/flowrep/nodes/__init__.py

@@ -3,15 +3,15 @@ from typing import cast
 import pydantic
 
 from flowrep.nodes import (
-    atomic_model,
-    for_model,
+    atomic_recipe,
+    for_recipe,
     helper_models,
-    if_model,
-    try_model,
-    while_model,
-    workflow_model,
+    if_recipe,
+    try_recipe,
+    while_recipe,
+    workflow_recipe,
 )
-from flowrep.nodes.union import Nodes, NodeType
+from flowrep.nodes.union_types import RecipeDiscrimination, Recipes
 
 # Subtlety: Anywhere we use `typing.TYPE_CHECKING` to avoid a real import _and_ use
 # the guarded object as a pydantic field annotator, we are going to need to make sure
@@ -21,12 +21,12 @@ from flowrep.nodes.union import Nodes, NodeType
 # security that pydantic can find all the necessary types.
 
 for cls in [
-    atomic_model.AtomicNode,
-    for_model.ForEachNode,
-    helper_models.LabeledNode,
-    if_model.IfNode,
-    try_model.TryNode,
-    while_model.WhileNode,
-    workflow_model.WorkflowNode,
+    atomic_recipe.AtomicRecipe,
+    for_recipe.ForEachRecipe,
+    helper_models.LabeledRecipe,
+    if_recipe.IfRecipe,
+    try_recipe.TryRecipe,
+    while_recipe.WhileRecipe,
+    workflow_recipe.WorkflowRecipe,
 ]:
     cast(type[pydantic.BaseModel], cls).model_rebuild()

flowrep-0.4.0/src/flowrep/nodes/atomic_model.py → flowrep-0.5.0/src/flowrep/nodes/atomic_recipe.py

@@ -23,7 +23,7 @@ class UnpackMode(StrEnum):
     DATACLASS = "dataclass"
 
 
-class AtomicNode(base_models.NodeModel):
+class AtomicRecipe(base_models.NodeRecipe):
     """
     Atomos: uncuttable, indivisible.
 

flowrep-0.4.0/src/flowrep/nodes/for_model.py → flowrep-0.5.0/src/flowrep/nodes/for_recipe.py

@@ -8,10 +8,10 @@ from flowrep import base_models, edge_models, subgraph_validation
 from flowrep.nodes import helper_models
 
 if TYPE_CHECKING:
-    from flowrep.nodes.union import Nodes
+    from flowrep.nodes.union_types import Recipes
 
 
-class ForEachNode(base_models.NodeModel):
+class ForEachRecipe(base_models.NodeRecipe):
     """
     Loop over a body node and collect outputs as a list.
     Each loop step is to be treated independently, such that the overall loop behaves
@@ -76,14 +76,14 @@ class ForEachNode(base_models.NodeModel):
     type: Literal[base_models.RecipeElementType.FOR_EACH] = pydantic.Field(
         default=base_models.RecipeElementType.FOR_EACH, frozen=True
     )
-    body_node: helper_models.LabeledNode
+    body_node: helper_models.LabeledRecipe
     input_edges: edge_models.InputEdges
     output_edges: edge_models.OutputEdges
     nested_ports: base_models.Labels = pydantic.Field(default_factory=list)
     zipped_ports: base_models.Labels = pydantic.Field(default_factory=list)
 
     @property
-    def prospective_nodes(self) -> Nodes:
+    def prospective_nodes(self) -> Recipes:
         return {self.body_node.label: self.body_node.node}
 
     @property

{flowrep-0.4.0 → flowrep-0.5.0}/src/flowrep/nodes/helper_models.py

@@ -8,7 +8,7 @@ from pyiron_snippets import versions
 from flowrep import base_models
 
 if TYPE_CHECKING:
-    from flowrep.nodes.union import NodeType  # Satisfies mypy
+    from flowrep.nodes.union_types import RecipeDiscrimination  # Satisfies mypy
 
     # Still not enough to satisfy ruff, which doesn't understand the string forward
     # reference, even with the TYPE_CHECKING import
@@ -17,14 +17,14 @@ if TYPE_CHECKING:
     # Ultimately, just silence ruff as needed
 
 
-class LabeledNode(pydantic.BaseModel):
+class LabeledRecipe(pydantic.BaseModel):
     label: base_models.Label
-    node: "NodeType"  # noqa: F821, UP037
+    node: "RecipeDiscrimination"  # noqa: F821, UP037
 
 
 class ConditionalCase(pydantic.BaseModel):
-    condition: LabeledNode
-    body: LabeledNode
+    condition: LabeledRecipe
+    body: LabeledRecipe
     condition_output: base_models.Label | None = None
 
     @pydantic.model_validator(mode="after")
@@ -70,7 +70,7 @@ class ExceptionCase(pydantic.BaseModel):
     """
 
     exceptions: list[versions.VersionInfo]
-    body: LabeledNode
+    body: LabeledRecipe
 
     @pydantic.field_validator("exceptions")
     @classmethod

flowrep-0.4.0/src/flowrep/nodes/if_model.py → flowrep-0.5.0/src/flowrep/nodes/if_recipe.py

@@ -8,10 +8,10 @@ from flowrep import base_models, edge_models, subgraph_validation
 from flowrep.nodes import helper_models
 
 if TYPE_CHECKING:
-    from flowrep.nodes.union import Nodes
+    from flowrep.nodes.union_types import Recipes
 
 
-class IfNode(base_models.NodeModel):
+class IfRecipe(base_models.NodeRecipe):
     """
     Walk through one or more cases, executing and returning the body result for the
     first case with a positive condition evaluation.
@@ -51,14 +51,14 @@ class IfNode(base_models.NodeModel):
         default=base_models.RecipeElementType.IF, frozen=True
     )
     cases: list[helper_models.ConditionalCase]
-    else_case: helper_models.LabeledNode | None = None
+    else_case: helper_models.LabeledRecipe | None = None
     input_edges: edge_models.InputEdges
     prospective_output_edges: dict[
         edge_models.OutputTarget, base_models.UniqueList[edge_models.SourceHandle]
     ]
 
     @property
-    def prospective_nodes(self) -> Nodes:
+    def prospective_nodes(self) -> Recipes:
         nodes = {}
         for case in self.cases:
             nodes[case.condition.label] = case.condition.node

flowrep-0.4.0/src/flowrep/nodes/try_model.py → flowrep-0.5.0/src/flowrep/nodes/try_recipe.py

@@ -8,10 +8,10 @@ from flowrep import base_models, edge_models, subgraph_validation
 from flowrep.nodes import helper_models
 
 if TYPE_CHECKING:
-    from flowrep.nodes.union import Nodes
+    from flowrep.nodes.union_types import Recipes
 
 
-class TryNode(base_models.NodeModel):
+class TryRecipe(base_models.NodeRecipe):
     """
     Try and except your way through a series of exceptions, with the option to perform
     a finally step.
@@ -49,7 +49,7 @@ class TryNode(base_models.NodeModel):
     type: Literal[base_models.RecipeElementType.TRY] = pydantic.Field(
         default=base_models.RecipeElementType.TRY, frozen=True
     )
-    try_node: helper_models.LabeledNode
+    try_node: helper_models.LabeledRecipe
     exception_cases: list[helper_models.ExceptionCase]
     input_edges: edge_models.InputEdges
     prospective_output_edges: dict[
@@ -57,7 +57,7 @@ class TryNode(base_models.NodeModel):
     ]
 
     @property
-    def prospective_nodes(self) -> Nodes:
+    def prospective_nodes(self) -> Recipes:
         nodes = {self.try_node.label: self.try_node.node}
         for case in self.exception_cases:
             nodes[case.body.label] = case.body.node
@@ -73,7 +73,7 @@ class TryNode(base_models.NodeModel):
     @classmethod
     def validate_exception_cases_not_empty(cls, v):
         if len(v) < 1:
-            raise ValueError("TryNode must have at least one exception case")
+            raise ValueError("TryRecipe must have at least one exception case")
         return v
 
     @pydantic.model_validator(mode="after")