flowrep 0.5.1__tar.gz → 0.5.2__tar.gz

{flowrep-0.5.1 → flowrep-0.5.2}/PKG-INFO

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

{flowrep-0.5.1 → flowrep-0.5.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.5.1'
-__version_tuple__ = version_tuple = (0, 5, 1)
+__version__ = version = '0.5.2'
+__version_tuple__ = version_tuple = (0, 5, 2)
 
 __commit_id__ = commit_id = None

{flowrep-0.5.1 → flowrep-0.5.2}/src/flowrep/parsers/atomic_parser.py

@@ -241,19 +241,25 @@ def _parse_dataclass_return_labels(func: FunctionType) -> list[str]:
             f"{source_code_return}"
         )
 
-    sig = inspect.signature(func)
-    ann = sig.return_annotation
+    try:
+        hints = get_type_hints(func, include_extras=True)
+    except NameError as e:
+        raise NameError(
+            "Dataclass unpack mode requires the return annotation to be importable at "
+            "runtime. Evaluating the return annotation for "
+            f"{func.__module__}.{func.__qualname__} failed with: {e}"
+        ) from e
+    ann = hints.get("return")
 
-    # unwrap Annotated
     origin = get_origin(ann)
-    return_annotation = get_args(ann)[0] if origin is Annotated else ann
+    return_hint = get_args(ann)[0] if origin is Annotated else ann
 
-    if dataclasses.is_dataclass(return_annotation):
-        return [f.name for f in dataclasses.fields(return_annotation)]
+    if dataclasses.is_dataclass(return_hint):
+        return [f.name for f in dataclasses.fields(return_hint)]
 
     raise ValueError(
         f"Dataclass unpack mode requires a return type annotation that is a "
-        f"(perhaps Annotated) dataclass, but got {ann}"
+        f"(perhaps Annotated) dataclass, but got {return_hint}"
     )
 
 

{flowrep-0.5.1 → flowrep-0.5.2}/src/flowrep/retrospective/datastructures.py

@@ -239,7 +239,16 @@ def _parse_function(
     dict[base_models.Label, OutputDataPort],
 ]:
     function = retrieve.import_from_string(fully_qualified_name)
-    hints = get_type_hints(function, include_extras=True)
+    try:
+        hints = get_type_hints(function, include_extras=True)
+    except NameError as e:
+        raise NameError(
+            f"While parsing {fully_qualified_name!r} for recipe inputs {inputs} and "
+            f"outputs {outputs}, could not find the symbol for at least one "
+            f"annotation. This is likely due to forward referenced annotations. Please "
+            f"cross reference the underlying name error ({str(e)!r}) and the function "
+            f"being parsed, and locally make the necessary imports before re-parsing."
+        ) from e
     sig = inspect.signature(function)
 
     variadics_in_sig = {
@@ -342,13 +351,27 @@ def _parse_return_tuple(
 def _parse_return_dataclass(
     return_annotation, outputs: list[str]
 ) -> dict[str, OutputDataPort]:
-    if not dataclasses.is_dataclass(return_annotation):  # pragma: no cover
+    if not (
+        isinstance(return_annotation, type)
+        and dataclasses.is_dataclass(return_annotation)
+    ):  # pragma: no cover
         raise TypeError(
             f"Return annotation {return_annotation!r} is not a dataclass. This should "
             f"have been caught by the underlying recipe validation. Please raise a "
             f"GitHub issue reporting how you got here!"
         )
 
+    # de-stringify dataclass annotations, if they were forward-references
+    try:
+        hints = get_type_hints(return_annotation, include_extras=True)
+    except NameError as e:
+        fqdn = f"{return_annotation.__module__}.{return_annotation.__qualname__}"
+        raise NameError(
+            f"While parsing return dataclass annotation {fqdn!r}, could not resolve "
+            f"at least one field annotation ({e}). Ensure the missing symbols are "
+            f"importable at runtime in the dataclass' defining module."
+        ) from e
+
     fields = dataclasses.fields(return_annotation)
     if len(outputs) != len(fields):  # pragma: no cover
         raise ValueError(
@@ -359,8 +382,6 @@ def _parse_return_dataclass(
         )
 
     return {
-        label: OutputDataPort(
-            annotation=(field.type if field.type is not dataclasses.MISSING else None),
-        )
+        label: OutputDataPort(annotation=hints.get(field.name, None))
         for label, field in zip(outputs, fields, strict=True)
     }

{flowrep-0.5.1 → flowrep-0.5.2}/src/flowrep/retrospective/storage.py

@@ -62,9 +62,12 @@ class LexicalBagBrowser:
     ) -> (
         datastructures.AtomicData
         | datastructures.DagData
-        | datastructures.FlowControlData
+        | datastructures.ForEachData
+        | datastructures.IfData
         | datastructures.InputDataPort
         | datastructures.OutputDataPort
+        | datastructures.TryData
+        | datastructures.WhileData
     ):
         """Load a node or IO port using its lexical path."""
         return load_from_bag(self.bag, path)
@@ -164,9 +167,12 @@ def load_from_bag(
 ) -> (
     datastructures.AtomicData
     | datastructures.DagData
-    | datastructures.FlowControlData
+    | datastructures.ForEachData
+    | datastructures.IfData
     | datastructures.InputDataPort
     | datastructures.OutputDataPort
+    | datastructures.TryData
+    | datastructures.WhileData
 ):
     """
     Load data from a :cls:`LiveNode` stored in a *bagofholding* by using its lexical
@@ -205,9 +211,12 @@ def load_from_bag(
     expected_types = (
         datastructures.AtomicData,
         datastructures.DagData,
-        datastructures.FlowControlData,
+        datastructures.ForEachData,
+        datastructures.IfData,
         datastructures.InputDataPort,
         datastructures.OutputDataPort,
+        datastructures.TryData,
+        datastructures.WhileData,
     )
     if not isinstance(obj, expected_types):
         raise TypeError(

{flowrep-0.5.1 → flowrep-0.5.2}/src/flowrep/wfms.py

@@ -207,7 +207,7 @@ def _populate_workflow_outputs(
 
 def _run_for(
     recipe: for_recipe.ForEachRecipe, **kwargs: Any
-) -> datastructures.FlowControlData:
+) -> datastructures.ForEachData:
     """
     Execute a for-node by scattering iterated inputs across body instances and
     collecting outputs into lists.
@@ -217,7 +217,7 @@ def _run_for(
     Transferred outputs collect the per-iteration value of a scattered input,
     preserving the link between input element and body output element.
     """
-    node = datastructures.FlowControlData.from_recipe(recipe)
+    node = datastructures.ForEachData.from_recipe(recipe)
     _populate_input_ports(node, kwargs)
 
     body_label = recipe.body_node.label
@@ -298,7 +298,7 @@ def _run_for(
 
 def _run_while(
     recipe: while_recipe.WhileRecipe, **kwargs: Any
-) -> datastructures.FlowControlData:
+) -> datastructures.WhileData:
     """
     Execute a while-node by repeatedly evaluating a condition and running a body.
 
@@ -306,7 +306,7 @@ def _run_while(
     feed back into the next condition/body evaluation.  If the condition is false on
     the first check, outputs are sourced from the initial input values.
     """
-    node = datastructures.FlowControlData.from_recipe(recipe)
+    node = datastructures.WhileData.from_recipe(recipe)
     _populate_input_ports(node, kwargs)
 
     cond_label = recipe.case.condition.label
@@ -355,16 +355,14 @@ def _run_while(
 # ---------------------------------------------------------------------------
 
 
-def _run_if(
-    recipe: if_recipe.IfRecipe, **kwargs: Any
-) -> datastructures.FlowControlData:
+def _run_if(recipe: if_recipe.IfRecipe, **kwargs: Any) -> datastructures.IfData:
     """
     Execute an if-node by walking cases until a condition evaluates positively,
     then executing the matching body (or the else case).
 
     Output ports that have no source from the executed branch remain NOT_DATA.
     """
-    node = datastructures.FlowControlData.from_recipe(recipe)
+    node = datastructures.IfData.from_recipe(recipe)
     _populate_input_ports(node, kwargs)
 
     for case in recipe.cases:
@@ -387,7 +385,7 @@ def _run_if(
 
 
 def _execute_if_branch(
-    node: datastructures.FlowControlData,
+    node: datastructures.IfData,
     recipe: if_recipe.IfRecipe,
     branch: helper_models.LabeledRecipe,
 ) -> None:
@@ -403,14 +401,12 @@ def _execute_if_branch(
 # ---------------------------------------------------------------------------
 
 
-def _run_try(
-    recipe: try_recipe.TryRecipe, **kwargs: Any
-) -> datastructures.FlowControlData:
+def _run_try(recipe: try_recipe.TryRecipe, **kwargs: Any) -> datastructures.TryData:
     """
     Execute a try-node: run the try body and, on exception, walk exception cases
     for a matching handler.  If no handler matches, the exception propagates.
     """
-    node = datastructures.FlowControlData.from_recipe(recipe)
+    node = datastructures.TryData.from_recipe(recipe)
     _populate_input_ports(node, kwargs)
 
     try_kwargs = _gather_dynamic_child_inputs(
@@ -493,7 +489,7 @@ def _evaluate_condition(
 
 
 def _populate_prospective_outputs(
-    node: datastructures.FlowControlData,
+    node: datastructures.IfData | datastructures.TryData,
     prospective_output_edges: dict[
         edge_models.OutputTarget, list[edge_models.SourceHandle]
     ],