python-workflow-definition 0.0.1__tar.gz → 0.1.0__tar.gz

{python_workflow_definition-0.0.1 → python_workflow_definition-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_workflow_definition
-Version: 0.0.1
+Version: 0.1.0
 Summary: Python Workflow Definition - workflow interoperability for aiida, jobflow and pyiron
 Author-email: Jan Janssen <janssen@mpie.de>, Janine George <janine.geogre@bam.de>, Julian Geiger <julian.geiger@psi.ch>, Xing Wang <xing.wang@psi.ch>, Marnik Bercx <marnik.bercx@psi.ch>, Christina Ertural <christina.ertural@bam.de>
 License: BSD 3-Clause License
@@ -35,6 +35,7 @@ License: BSD 3-Clause License
 Requires-Dist: aiida-workgraph<=0.5.2,>=0.5.1
 Requires-Dist: jobflow<=0.1.19,>=0.1.18
 Requires-Dist: numpy<2,>=1.21
+Requires-Dist: pydantic<=2.11.4,>=2.7.0
 Requires-Dist: pyiron-base<=0.11.11,>=0.11.10
 Provides-Extra: plot
 Requires-Dist: ipython<=9.0.2,>=7.33.0; extra == 'plot'

{python_workflow_definition-0.0.1 → python_workflow_definition-0.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python_workflow_definition"
-version = "0.0.1"
+version = "0.1.0"
 description = "Python Workflow Definition - workflow interoperability for aiida, jobflow and pyiron"
 authors = [
   { name = "Jan Janssen", email = "janssen@mpie.de" },
@@ -16,10 +16,11 @@ authors = [
 ]
 license = { file = "../LICENSE" }
 dependencies = [
-  "aiida-workgraph>=0.5.1,<=0.5.2",
-  "numpy>=1.21,<2",
-  "jobflow>=0.1.18,<=0.1.19",
-  "pyiron_base>=0.11.10,<=0.11.11",
+    "aiida-workgraph>=0.5.1,<=0.5.2",
+    "numpy>=1.21,<2",
+    "jobflow>=0.1.18,<=0.1.19",
+    "pyiron_base>=0.11.10,<=0.11.11",
+    "pydantic>=2.7.0,<=2.11.4",
 ]
 
 [project.optional-dependencies]

{python_workflow_definition-0.0.1 → python_workflow_definition-0.1.0}/src/python_workflow_definition/aiida.py

@@ -1,5 +1,4 @@
 from importlib import import_module
-import json
 import traceback
 
 from aiida import orm
@@ -7,20 +6,29 @@ from aiida_pythonjob.data.serializer import general_serializer
 from aiida_workgraph import WorkGraph, task
 from aiida_workgraph.socket import TaskSocketNamespace
 
+from python_workflow_definition.models import PythonWorkflowDefinitionWorkflow
 from python_workflow_definition.shared import (
     convert_nodes_list_to_dict,
+    update_node_names,
+    remove_result,
+    set_result_node,
     NODES_LABEL,
     EDGES_LABEL,
     SOURCE_LABEL,
     SOURCE_PORT_LABEL,
     TARGET_LABEL,
     TARGET_PORT_LABEL,
+    VERSION_NUMBER,
+    VERSION_LABEL,
 )
 
 
 def load_workflow_json(file_name: str) -> WorkGraph:
-    with open(file_name) as f:
-        data = json.load(f)
+    data = remove_result(
+        workflow_dict=PythonWorkflowDefinitionWorkflow.load_json_file(
+            file_name=file_name
+        )
+    )
 
     wg = WorkGraph()
     task_name_mapping = {}
@@ -88,7 +96,7 @@ def write_workflow_json(wg: WorkGraph, file_name: str) -> dict:
 
         callable_name = executor["callable_name"]
         callable_name = f"{executor['module_path']}.{callable_name}"
-        data[NODES_LABEL].append({"id": i, "function": callable_name})
+        data[NODES_LABEL].append({"id": i, "type": "function", "value": callable_name})
         i += 1
 
     for link in wg.links:
@@ -117,7 +125,9 @@ def write_workflow_json(wg: WorkGraph, file_name: str) -> dict:
                         raw_value.pop("node_type", None)
                     else:
                         raw_value = input.value.value
-                    data[NODES_LABEL].append({"id": i, "value": raw_value})
+                    data[NODES_LABEL].append(
+                        {"id": i, "type": "input", "value": raw_value}
+                    )
                     input_node_name = i
                     data_node_name_mapping[input.value.uuid] = input_node_name
                     i += 1
@@ -131,8 +141,7 @@ def write_workflow_json(wg: WorkGraph, file_name: str) -> dict:
                         SOURCE_PORT_LABEL: None,
                     }
                 )
-    with open(file_name, "w") as f:
-        # json.dump({"nodes": data[], "edges": edges_new_lst}, f)
-        json.dump(data, f, indent=2)
-
-    return data
+    data[VERSION_LABEL] = VERSION_NUMBER
+    PythonWorkflowDefinitionWorkflow(
+        **set_result_node(workflow_dict=update_node_names(workflow_dict=data))
+    ).dump_json_file(file_name=file_name, indent=2)

python_workflow_definition-0.1.0/src/python_workflow_definition/cwl/__init__.py

@@ -0,0 +1,240 @@
+import json
+import pickle
+from yaml import CDumper as Dumper, dump
+
+
+from python_workflow_definition.purepython import (
+    group_edges,
+    resort_total_lst,
+)
+from python_workflow_definition.shared import (
+    convert_nodes_list_to_dict,
+    remove_result,
+    EDGES_LABEL,
+    NODES_LABEL,
+    TARGET_LABEL,
+    TARGET_PORT_LABEL,
+    SOURCE_LABEL,
+    SOURCE_PORT_LABEL,
+)
+
+
+def _get_function_argument(argument: str, position: int = 3) -> dict:
+    return {
+        argument
+        + "_file": {
+            "type": "File",
+            "inputBinding": {
+                "prefix": "--arg_" + argument + "=",
+                "separate": False,
+                "position": position,
+            },
+        },
+    }
+
+
+def _get_function_template(function_name: str) -> dict:
+    return {
+        "function": {
+            "default": function_name,
+            "inputBinding": {"position": 3, "prefix": "--function=", "separate": False},
+            "type": "string",
+        },
+    }
+
+
+def _get_output_name(output_name: str) -> dict:
+    return {
+        output_name
+        + "_file": {"type": "File", "outputBinding": {"glob": output_name + ".pickle"}}
+    }
+
+
+def _get_function(workflow):
+    function_nodes_dict = {
+        n["id"]: n["value"] for n in workflow[NODES_LABEL] if n["type"] == "function"
+    }
+    funct_dict = {}
+    for funct_id in function_nodes_dict.keys():
+        target_ports = list(
+            set(
+                [
+                    e[TARGET_PORT_LABEL]
+                    for e in workflow[EDGES_LABEL]
+                    if e["target"] == funct_id
+                ]
+            )
+        )
+        source_ports = list(
+            set(
+                [
+                    e[SOURCE_PORT_LABEL]
+                    for e in workflow[EDGES_LABEL]
+                    if e["source"] == funct_id
+                ]
+            )
+        )
+        funct_dict[funct_id] = {
+            "targetPorts": target_ports,
+            "sourcePorts": source_ports,
+        }
+    return function_nodes_dict, funct_dict
+
+
+def _write_function_cwl(workflow):
+    function_nodes_dict, funct_dict = _get_function(workflow)
+
+    for i in function_nodes_dict.keys():
+        template = {
+            "cwlVersion": "v1.2",
+            "class": "CommandLineTool",
+            "baseCommand": "python",
+            "inputs": {
+                "wrapper": {
+                    "type": "string",
+                    "inputBinding": {"position": 1, "prefix": "-m"},
+                    "default": "python_workflow_definition.cwl",
+                },
+                "workflowfile": {
+                    "type": "File",
+                    "inputBinding": {
+                        "position": 2,
+                        "prefix": "--workflowfile=",
+                        "separate": False,
+                    },
+                    "default": {"class": "File", "location": "workflow.py"},
+                },
+            },
+            "outputs": {},
+        }
+        file_name = function_nodes_dict[i].split(".")[-1] + "_" + str(i) + ".cwl"
+        if function_nodes_dict[i].split(".")[0] != "python_workflow_definition":
+            template["inputs"]["workflowfile"]["default"]["location"] = (
+                function_nodes_dict[i].split(".")[0] + ".py"
+            )
+        else:
+            del template["inputs"]["workflowfile"]
+        template["inputs"].update(
+            _get_function_template(function_name=function_nodes_dict[i])
+        )
+        for j, arg in enumerate(funct_dict[i]["targetPorts"]):
+            template["inputs"].update(
+                _get_function_argument(argument=arg, position=4 + j)
+            )
+        for out in funct_dict[i]["sourcePorts"]:
+            if out is None:
+                template["outputs"].update(_get_output_name(output_name="result"))
+            else:
+                template["outputs"].update(_get_output_name(output_name=out))
+        with open(file_name, "w") as f:
+            dump(template, f, Dumper=Dumper)
+
+
+def _write_workflow_config(workflow):
+    input_dict = {
+        n["name"]: n["value"] for n in workflow[NODES_LABEL] if n["type"] == "input"
+    }
+    with open("workflow.yml", "w") as f:
+        dump(
+            {
+                k + "_file": {"class": "File", "path": k + ".pickle"}
+                for k in input_dict.keys()
+            },
+            f,
+            Dumper=Dumper,
+        )
+    for k, v in input_dict.items():
+        with open(k + ".pickle", "wb") as f:
+            pickle.dump(v, f)
+
+
+def _write_workflow(workflow):
+    workflow_template = {
+        "cwlVersion": "v1.2",
+        "class": "Workflow",
+        "inputs": {},
+        "steps": {},
+        "outputs": {},
+    }
+    input_dict = {
+        n["name"]: n["value"] for n in workflow[NODES_LABEL] if n["type"] == "input"
+    }
+    function_nodes_dict, funct_dict = _get_function(workflow)
+    result_id = [n["id"] for n in workflow[NODES_LABEL] if n["type"] == "output"][0]
+    last_compute_id = [
+        e[SOURCE_LABEL] for e in workflow[EDGES_LABEL] if e[TARGET_LABEL] == result_id
+    ][0]
+    workflow_template["inputs"].update({k + "_file": "File" for k in input_dict.keys()})
+    if funct_dict[last_compute_id]["sourcePorts"] == [None]:
+        workflow_template["outputs"] = {
+            "result_file": {
+                "type": "File",
+                "outputSource": function_nodes_dict[last_compute_id].split(".")[-1]
+                + "_"
+                + str(last_compute_id)
+                + "/result_file",
+            },
+        }
+    else:
+        raise ValueError()
+
+    content = remove_result(workflow_dict=workflow)
+    edges_new_lst = content[EDGES_LABEL]
+    total_lst = group_edges(edges_new_lst)
+    nodes_new_dict = {
+        int(k): v
+        for k, v in convert_nodes_list_to_dict(nodes_list=content[NODES_LABEL]).items()
+    }
+    total_new_lst = resort_total_lst(total_lst=total_lst, nodes_dict=nodes_new_dict)
+    step_name_lst = {
+        t[0]: function_nodes_dict[t[0]].split(".")[-1] for t in total_new_lst
+    }
+    input_id_dict = {
+        n["id"]: n["name"] for n in workflow[NODES_LABEL] if n["type"] == "input"
+    }
+    for t in total_new_lst:
+        ind = t[0]
+        node_script = step_name_lst[ind] + "_" + str(ind) + ".cwl"
+        output = [
+            o + "_file" if o is not None else "result_file"
+            for o in funct_dict[ind]["sourcePorts"]
+        ]
+        in_dict = {}
+        for k, v in t[1].items():
+            if v[SOURCE_LABEL] in input_id_dict:
+                in_dict[k + "_file"] = input_id_dict[v[SOURCE_LABEL]] + "_file"
+            else:
+                if v["sourcePort"] is None:
+                    in_dict[k + "_file"] = (
+                        step_name_lst[v[SOURCE_LABEL]]
+                        + "_"
+                        + str(v[SOURCE_LABEL])
+                        + "/result_file"
+                    )
+                else:
+                    in_dict[k + "_file"] = (
+                        step_name_lst[v[SOURCE_LABEL]]
+                        + "_"
+                        + str(v[SOURCE_LABEL])
+                        + "/"
+                        + v[SOURCE_PORT_LABEL]
+                        + "_file"
+                    )
+        workflow_template["steps"].update(
+            {
+                step_name_lst[ind]
+                + "_"
+                + str(ind): {"run": node_script, "in": in_dict, "out": output}
+            }
+        )
+    with open("workflow.cwl", "w") as f:
+        dump(workflow_template, f, Dumper=Dumper)
+
+
+def write_workflow(file_name: str):
+    with open(file_name, "r") as f:
+        workflow = json.load(f)
+
+    _write_function_cwl(workflow=workflow)
+    _write_workflow_config(workflow=workflow)
+    _write_workflow(workflow=workflow)

python_workflow_definition-0.1.0/src/python_workflow_definition/cwl/__main__.py

@@ -0,0 +1,51 @@
+import sys
+import pickle
+from ast import literal_eval
+import importlib.util
+
+
+def load_function(file_name, funct):
+    spec = importlib.util.spec_from_file_location("workflow", file_name)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["workflow"] = module
+    spec.loader.exec_module(module)
+    return getattr(module, funct.split(".")[-1])
+
+
+def convert_argument(arg):
+    if ".pickle" in arg:
+        with open(arg, "rb") as f:
+            return pickle.load(f)
+    else:
+        return literal_eval(arg)
+
+
+if __name__ == "__main__":
+    # load input
+    argument_lst = sys.argv[1:]
+    funct_lst = [arg.split("=")[-1] for arg in argument_lst if "--function=" in arg]
+    file_lst = [arg.split("=")[-1] for arg in argument_lst if "--workflowfile=" in arg]
+    if len(file_lst) > 0:
+        workflow_function = load_function(file_name=file_lst[0], funct=funct_lst[0])
+        internal_function = False
+    else:
+        m, p = funct_lst[0].rsplit(".", 1)
+        workflow_function = getattr(importlib.import_module(m), p)
+        internal_function = True
+    kwargs = {
+        arg.split("=")[0][6:]: convert_argument(arg=arg.split("=")[-1])
+        for arg in argument_lst
+        if "--arg_" in arg
+    }
+
+    # evaluate function
+    result = workflow_function(**kwargs)
+
+    # store output
+    if isinstance(result, dict) and not internal_function:
+        for k, v in result.items():
+            with open(k + ".pickle", "wb") as f:
+                pickle.dump(v, f)
+    else:
+        with open("result.pickle", "wb") as f:
+            pickle.dump(result, f)

{python_workflow_definition-0.0.1 → python_workflow_definition-0.1.0}/src/python_workflow_definition/executorlib.py

@@ -1,15 +1,16 @@
 from concurrent.futures import Executor
 from importlib import import_module
 from inspect import isfunction
-import json
 
 
+from python_workflow_definition.models import PythonWorkflowDefinitionWorkflow
 from python_workflow_definition.shared import (
     get_dict,
     get_list,
     get_kwargs,
     get_source_handles,
     convert_nodes_list_to_dict,
+    remove_result,
     NODES_LABEL,
     EDGES_LABEL,
     SOURCE_LABEL,
@@ -37,8 +38,11 @@ def _get_value(result_dict: dict, nodes_new_dict: dict, link_dict: dict, exe: Ex
 
 
 def load_workflow_json(file_name: str, exe: Executor):
-    with open(file_name, "r") as f:
-        content = json.load(f)
+    content = remove_result(
+        workflow_dict=PythonWorkflowDefinitionWorkflow.load_json_file(
+            file_name=file_name
+        )
+    )
 
     edges_new_lst = content[EDGES_LABEL]
     nodes_new_dict = {}

{python_workflow_definition-0.0.1 → python_workflow_definition-0.1.0}/src/python_workflow_definition/jobflow.py

@@ -1,22 +1,27 @@
-import json
 from importlib import import_module
 from inspect import isfunction
 
 import numpy as np
 from jobflow import job, Flow
 
+from python_workflow_definition.models import PythonWorkflowDefinitionWorkflow
 from python_workflow_definition.shared import (
     get_dict,
     get_list,
     get_kwargs,
     get_source_handles,
+    update_node_names,
     convert_nodes_list_to_dict,
+    remove_result,
+    set_result_node,
     NODES_LABEL,
     EDGES_LABEL,
     SOURCE_LABEL,
     SOURCE_PORT_LABEL,
     TARGET_LABEL,
     TARGET_PORT_LABEL,
+    VERSION_NUMBER,
+    VERSION_LABEL,
 )
 
 
@@ -269,8 +274,11 @@ def _get_item_from_tuple(input_obj, index, index_lst):
 
 
 def load_workflow_json(file_name: str) -> Flow:
-    with open(file_name, "r") as f:
-        content = json.load(f)
+    content = remove_result(
+        workflow_dict=PythonWorkflowDefinitionWorkflow.load_json_file(
+            file_name=file_name
+        )
+    )
 
     edges_new_lst = []
     for edge in content[EDGES_LABEL]:
@@ -322,12 +330,21 @@ def write_workflow_json(flow: Flow, file_name: str = "workflow.json"):
     for k, v in nodes_dict.items():
         if isfunction(v):
             nodes_store_lst.append(
-                {"id": k, "function": v.__module__ + "." + v.__name__}
+                {"id": k, "type": "function", "value": v.__module__ + "." + v.__name__}
             )
         elif isinstance(v, np.ndarray):
-            nodes_store_lst.append({"id": k, "value": v.tolist()})
+            nodes_store_lst.append({"id": k, "type": "input", "value": v.tolist()})
         else:
-            nodes_store_lst.append({"id": k, "value": v})
+            nodes_store_lst.append({"id": k, "type": "input", "value": v})
 
-    with open(file_name, "w") as f:
-        json.dump({NODES_LABEL: nodes_store_lst, EDGES_LABEL: edges_lst}, f)
+    PythonWorkflowDefinitionWorkflow(
+        **set_result_node(
+            workflow_dict=update_node_names(
+                workflow_dict={
+                    VERSION_LABEL: VERSION_NUMBER,
+                    NODES_LABEL: nodes_store_lst,
+                    EDGES_LABEL: edges_lst,
+                }
+            )
+        )
+    ).dump_json_file(file_name=file_name, indent=2)

python_workflow_definition-0.1.0/src/python_workflow_definition/models.py

@@ -0,0 +1,254 @@
+from pathlib import Path
+from typing import List, Union, Optional, Literal, Any, Annotated, Type, TypeVar
+from pydantic import BaseModel, Field, field_validator, field_serializer
+from pydantic import ValidationError
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+INTERNAL_DEFAULT_HANDLE = "__result__"
+T = TypeVar("T", bound="PythonWorkflowDefinitionWorkflow")
+
+__all__ = (
+    "PythonWorkflowDefinitionInputNode",
+    "PythonWorkflowDefinitionOutputNode",
+    "PythonWorkflowDefinitionFunctionNode",
+    "PythonWorkflowDefinitionEdge",
+    "PythonWorkflowDefinitionWorkflow",
+)
+
+
+class PythonWorkflowDefinitionBaseNode(BaseModel):
+    """Base model for all node types, containing common fields."""
+
+    id: int
+    # The 'type' field will be overridden in subclasses with Literal types
+    # to enable discriminated unions.
+    type: str
+
+
+class PythonWorkflowDefinitionInputNode(PythonWorkflowDefinitionBaseNode):
+    """Model for input nodes."""
+
+    type: Literal["input"]
+    name: str
+    value: Optional[Any] = None
+
+
+class PythonWorkflowDefinitionOutputNode(PythonWorkflowDefinitionBaseNode):
+    """Model for output nodes."""
+
+    type: Literal["output"]
+    name: str
+
+
+class PythonWorkflowDefinitionFunctionNode(PythonWorkflowDefinitionBaseNode):
+    """
+    Model for function execution nodes.
+    The 'name' attribute is computed automatically from 'value'.
+    """
+
+    type: Literal["function"]
+    value: str  # Expected format: 'module.function'
+
+    @field_validator("value")
+    @classmethod
+    def check_value_format(cls, v: str):
+        if not v or "." not in v or v.startswith(".") or v.endswith("."):
+            msg = (
+                "FunctionNode 'value' must be a non-empty string ",
+                "in 'module.function' format with at least one period.",
+            )
+            raise ValueError(msg)
+        return v
+
+
+# Discriminated Union for Nodes
+PythonWorkflowDefinitionNode = Annotated[
+    Union[
+        PythonWorkflowDefinitionInputNode,
+        PythonWorkflowDefinitionOutputNode,
+        PythonWorkflowDefinitionFunctionNode,
+    ],
+    Field(discriminator="type"),
+]
+
+
+class PythonWorkflowDefinitionEdge(BaseModel):
+    """Model for edges connecting nodes."""
+
+    target: int
+    targetPort: Optional[str] = None
+    source: int
+    sourcePort: Optional[str] = None
+
+    @field_validator("sourcePort", mode="before")
+    @classmethod
+    def handle_default_source(cls, v: Any) -> Optional[str]:
+        """
+        Transforms incoming None/null for sourcePort to INTERNAL_DEFAULT_HANDLE.
+        Runs before standard validation.
+        """
+        # Allow not specifying the sourcePort -> null gets resolved to __result__
+        if v is None:
+            return INTERNAL_DEFAULT_HANDLE
+        elif v == INTERNAL_DEFAULT_HANDLE:
+            # Disallow explicit use of the internal reserved handle name
+            msg = (
+                f"Explicit use of reserved sourcePort '{INTERNAL_DEFAULT_HANDLE}' "
+                f"is not allowed. Use null/None for default output."
+            )
+            raise ValueError(msg)
+        return v
+
+    @field_serializer("sourcePort")
+    def serialize_source_handle(self, v: Optional[str]) -> Optional[str]:
+        """
+        SERIALIZATION (Output): Converts internal INTERNAL_DEFAULT_HANDLE ("__result__")
+        back to None.
+        """
+        if v == INTERNAL_DEFAULT_HANDLE:
+            return None  # Map "__result__" back to None for JSON output
+        return v  # Keep other handle names as they are
+
+
+class PythonWorkflowDefinitionWorkflow(BaseModel):
+    """The main workflow model."""
+
+    version: str
+    nodes: List[PythonWorkflowDefinitionNode]
+    edges: List[PythonWorkflowDefinitionEdge]
+
+    def dump_json(
+        self,
+        *,
+        indent: Optional[int] = 2,
+        **kwargs,
+    ) -> str:
+        """
+        Dumps the workflow model to a JSON string.
+
+        Args:
+            indent: JSON indentation level.
+            exclude_computed_function_names: If True (default), excludes the computed
+                                             'name' field from FunctionNode objects
+                                             in the output.
+            **kwargs: Additional keyword arguments passed to Pydantic's model_dump.
+
+        Returns:
+            JSON string representation of the workflow.
+        """
+
+        # Dump the model to a dictionary first, using mode='json' for compatible types
+        # Pass any extra kwargs (like custom 'exclude' rules for other fields)
+        workflow_dict = self.model_dump(mode="json", **kwargs)
+
+        # Dump the dictionary to a JSON string
+        try:
+            json_string = json.dumps(workflow_dict, indent=indent)
+            logger.info("Successfully dumped workflow model to JSON string.")
+            return json_string
+        except TypeError as e:
+            logger.error(
+                f"Error serializing workflow dictionary to JSON: {e}", exc_info=True
+            )
+            raise  # Re-raise after logging
+
+    def dump_json_file(
+        self,
+        file_name: Union[str, Path],
+        *,
+        indent: Optional[int] = 2,
+        **kwargs,
+    ) -> None:
+        """
+        Dumps the workflow model to a JSON file.
+
+        Args:
+            file_path: Path to the output JSON file.
+            indent: JSON indentation level.
+            exclude_computed_function_names: If True, excludes the computed 'name' field
+                                             from FunctionNode objects.
+            **kwargs: Additional keyword arguments passed to Pydantic's model_dump.
+        """
+        logger.info(f"Dumping workflow model to JSON file: {file_name}")
+        # Pass kwargs to dump_json, which passes them to model_dump
+        json_string = self.dump_json(
+            indent=indent,
+            **kwargs,
+        )
+        try:
+            with open(file_name, "w", encoding="utf-8") as f:
+                f.write(json_string)
+            logger.info(f"Successfully wrote workflow model to {file_name}.")
+        except IOError as e:
+            logger.error(
+                f"Error writing workflow model to file {file_name}: {e}", exc_info=True
+            )
+            raise
+
+    @classmethod
+    def load_json_str(cls: Type[T], json_data: Union[str, bytes]) -> dict:
+        """
+        Loads and validates workflow data from a JSON string or bytes.
+
+        Args:
+            json_data: The JSON data as a string or bytes.
+
+        Returns:
+            An instance of PwdWorkflow.
+
+        Raises:
+            pydantic.ValidationError: If validation fails.
+            json.JSONDecodeError: If json_data is not valid JSON.
+        """
+        logger.info("Loading workflow model from JSON data...")
+        try:
+            # Pydantic v2 method handles bytes or str directly
+            instance = cls.model_validate_json(json_data)
+            # Pydantic v1 equivalent: instance = cls.parse_raw(json_data)
+            logger.info(
+                "Successfully loaded and validated workflow model from JSON data."
+            )
+            return instance.model_dump()
+        except ValidationError:  # Catch validation errors specifically
+            logger.error("Workflow model validation failed.", exc_info=True)
+            raise
+        except json.JSONDecodeError:  # Catch JSON parsing errors specifically
+            logger.error("Invalid JSON format encountered.", exc_info=True)
+            raise
+        except Exception as e:  # Catch any other unexpected errors
+            logger.error(
+                f"An unexpected error occurred during JSON loading: {e}", exc_info=True
+            )
+            raise
+
+    @classmethod
+    def load_json_file(cls: Type[T], file_name: Union[str, Path]) -> dict:
+        """
+        Loads and validates workflow data from a JSON file.
+
+        Args:
+            file_path: The path to the JSON file.
+
+        Returns:
+            An instance of PwdWorkflow.
+
+        Raises:
+            FileNotFoundError: If the file is not found.
+            pydantic.ValidationError: If validation fails.
+            json.JSONDecodeError: If the file is not valid JSON.
+            IOError: If there are other file reading issues.
+        """
+        logger.info(f"Loading workflow model from JSON file: {file_name}")
+        try:
+            file_content = Path(file_name).read_text(encoding="utf-8")
+            # Delegate validation to the string loading method
+            return cls.load_json_str(file_content)
+        except FileNotFoundError:
+            logger.error(f"JSON file not found: {file_name}", exc_info=True)
+            raise
+        except IOError as e:
+            logger.error(f"Error reading JSON file {file_name}: {e}", exc_info=True)
+            raise

{python_workflow_definition-0.0.1 → python_workflow_definition-0.1.0}/src/python_workflow_definition/plot.py

@@ -1,9 +1,8 @@
-import json
-
 from IPython.display import SVG, display
 import networkx as nx
 
 
+from python_workflow_definition.models import PythonWorkflowDefinitionWorkflow
 from python_workflow_definition.purepython import group_edges
 from python_workflow_definition.shared import (
     get_kwargs,
@@ -16,8 +15,7 @@ from python_workflow_definition.shared import (
 
 
 def plot(file_name: str):
-    with open(file_name, "r") as f:
-        content = json.load(f)
+    content = PythonWorkflowDefinitionWorkflow.load_json_file(file_name=file_name)
 
     graph = nx.DiGraph()
     node_dict = convert_nodes_list_to_dict(nodes_list=content[NODES_LABEL])
@@ -39,7 +37,10 @@ def plot(file_name: str):
                     k + "=result[" + v[SOURCE_PORT_LABEL] + "]"
                 )
         for k, v in edge_label_dict.items():
-            graph.add_edge(str(k), str(target_node), label=", ".join(v))
+            if len(v) == 1 and v[0] is not None:
+                graph.add_edge(str(k), str(target_node), label=", ".join(v))
+            else:
+                graph.add_edge(str(k), str(target_node))
 
     svg = nx.nx_agraph.to_agraph(graph).draw(prog="dot", format="svg")
     display(SVG(svg))

{python_workflow_definition-0.0.1 → python_workflow_definition-0.1.0}/src/python_workflow_definition/purepython.py

@@ -1,14 +1,15 @@
-import json
 from importlib import import_module
 from inspect import isfunction
 
 
+from python_workflow_definition.models import PythonWorkflowDefinitionWorkflow
 from python_workflow_definition.shared import (
     get_dict,
     get_list,
     get_kwargs,
     get_source_handles,
     convert_nodes_list_to_dict,
+    remove_result,
     NODES_LABEL,
     EDGES_LABEL,
     SOURCE_LABEL,
@@ -66,8 +67,11 @@ def _get_value(result_dict: dict, nodes_new_dict: dict, link_dict: dict):
 
 
 def load_workflow_json(file_name: str):
-    with open(file_name, "r") as f:
-        content = json.load(f)
+    content = remove_result(
+        workflow_dict=PythonWorkflowDefinitionWorkflow.load_json_file(
+            file_name=file_name
+        )
+    )
 
     edges_new_lst = content[EDGES_LABEL]
     nodes_new_dict = {}

{python_workflow_definition-0.0.1 → python_workflow_definition-0.1.0}/src/python_workflow_definition/pyiron_base.py

@@ -1,22 +1,27 @@
 from importlib import import_module
 from inspect import isfunction
-import json
 from typing import Optional
 
 import numpy as np
 from pyiron_base import job, Project
 from pyiron_base.project.delayed import DelayedObject
 
+from python_workflow_definition.models import PythonWorkflowDefinitionWorkflow
 from python_workflow_definition.shared import (
     get_kwargs,
     get_source_handles,
     convert_nodes_list_to_dict,
+    update_node_names,
+    remove_result,
+    set_result_node,
     NODES_LABEL,
     EDGES_LABEL,
     SOURCE_LABEL,
     SOURCE_PORT_LABEL,
     TARGET_LABEL,
     TARGET_PORT_LABEL,
+    VERSION_NUMBER,
+    VERSION_LABEL,
 )
 
 
@@ -227,8 +232,11 @@ def load_workflow_json(file_name: str, project: Optional[Project] = None):
     if project is None:
         project = Project(".")
 
-    with open(file_name, "r") as f:
-        content = json.load(f)
+    content = remove_result(
+        workflow_dict=PythonWorkflowDefinitionWorkflow.load_json_file(
+            file_name=file_name
+        )
+    )
 
     edges_new_lst = content[EDGES_LABEL]
     nodes_new_dict = {}
@@ -282,11 +290,22 @@ def write_workflow_json(
             mod = v.__module__
             if mod == "python_workflow_definition.pyiron_base":
                 mod = "python_workflow_definition.shared"
-            nodes_store_lst.append({"id": k, "function": mod + "." + v.__name__})
+            nodes_store_lst.append(
+                {"id": k, "type": "function", "value": mod + "." + v.__name__}
+            )
         elif isinstance(v, np.ndarray):
-            nodes_store_lst.append({"id": k, "value": v.tolist()})
+            nodes_store_lst.append({"id": k, "type": "input", "value": v.tolist()})
         else:
-            nodes_store_lst.append({"id": k, "value": v})
-
-    with open(file_name, "w") as f:
-        json.dump({NODES_LABEL: nodes_store_lst, EDGES_LABEL: edges_new_lst}, f)
+            nodes_store_lst.append({"id": k, "type": "input", "value": v})
+
+    PythonWorkflowDefinitionWorkflow(
+        **set_result_node(
+            workflow_dict=update_node_names(
+                workflow_dict={
+                    VERSION_LABEL: VERSION_NUMBER,
+                    NODES_LABEL: nodes_store_lst,
+                    EDGES_LABEL: edges_new_lst,
+                }
+            )
+        )
+    ).dump_json_file(file_name=file_name, indent=2)

python_workflow_definition-0.1.0/src/python_workflow_definition/shared.py

@@ -0,0 +1,117 @@
+from collections import Counter
+
+NODES_LABEL = "nodes"
+EDGES_LABEL = "edges"
+SOURCE_LABEL = "source"
+SOURCE_PORT_LABEL = "sourcePort"
+TARGET_LABEL = "target"
+TARGET_PORT_LABEL = "targetPort"
+VERSION_NUMBER = "0.1.0"
+VERSION_LABEL = "version"
+
+
+def get_dict(**kwargs) -> dict:
+    # NOTE: In WG, this will automatically be wrapped in a dict with the `result` key
+    return {k: v for k, v in kwargs.items()}
+    # return {'dict': {k: v for k, v in kwargs.items()}}
+
+
+def get_list(**kwargs) -> list:
+    return list(kwargs.values())
+
+
+def get_kwargs(lst: list) -> dict:
+    return {
+        t[TARGET_PORT_LABEL]: {
+            SOURCE_LABEL: t[SOURCE_LABEL],
+            SOURCE_PORT_LABEL: t[SOURCE_PORT_LABEL],
+        }
+        for t in lst
+    }
+
+
+def get_source_handles(edges_lst: list) -> dict:
+    source_handle_dict = {}
+    for ed in edges_lst:
+        if ed[SOURCE_LABEL] not in source_handle_dict.keys():
+            source_handle_dict[ed[SOURCE_LABEL]] = []
+        source_handle_dict[ed[SOURCE_LABEL]].append(ed[SOURCE_PORT_LABEL])
+    return {
+        k: list(range(len(v))) if len(v) > 1 and all([el is None for el in v]) else v
+        for k, v in source_handle_dict.items()
+    }
+
+
+def convert_nodes_list_to_dict(nodes_list: list) -> dict:
+    return {
+        str(el["id"]): el["value"] if "value" in el else el["name"]
+        for el in sorted(nodes_list, key=lambda d: d["id"])
+    }
+
+
+def update_node_names(workflow_dict: dict) -> dict:
+    node_names_final_dict = {}
+    input_nodes = [n for n in workflow_dict[NODES_LABEL] if n["type"] == "input"]
+    node_names_dict = {
+        n["id"]: list(
+            set(
+                [
+                    e[TARGET_PORT_LABEL]
+                    for e in workflow_dict[EDGES_LABEL]
+                    if e[SOURCE_LABEL] == n["id"]
+                ]
+            )
+        )[0]
+        for n in input_nodes
+    }
+
+    counter_dict = Counter(node_names_dict.values())
+    node_names_useage_dict = {k: -1 for k in counter_dict.keys()}
+    for k, v in node_names_dict.items():
+        node_names_useage_dict[v] += 1
+        if counter_dict[v] > 1:
+            node_names_final_dict[k] = v + "_" + str(node_names_useage_dict[v])
+        else:
+            node_names_final_dict[k] = v
+
+    for n in workflow_dict[NODES_LABEL]:
+        if n["type"] == "input":
+            n["name"] = node_names_final_dict[n["id"]]
+    return workflow_dict
+
+
+def set_result_node(workflow_dict):
+    node_id_lst = [n["id"] for n in workflow_dict[NODES_LABEL]]
+    source_lst = list(set([e[SOURCE_LABEL] for e in workflow_dict[EDGES_LABEL]]))
+
+    end_node_lst = []
+    for ni in node_id_lst:
+        if ni not in source_lst:
+            end_node_lst.append(ni)
+
+    node_id = len(workflow_dict[NODES_LABEL])
+    workflow_dict[NODES_LABEL].append(
+        {"id": node_id, "type": "output", "name": "result"}
+    )
+    workflow_dict[EDGES_LABEL].append(
+        {
+            TARGET_LABEL: node_id,
+            TARGET_PORT_LABEL: None,
+            SOURCE_LABEL: end_node_lst[0],
+            SOURCE_PORT_LABEL: None,
+        }
+    )
+
+    return workflow_dict
+
+
+def remove_result(workflow_dict):
+    node_output_id = [
+        n["id"] for n in workflow_dict[NODES_LABEL] if n["type"] == "output"
+    ][0]
+    return {
+        NODES_LABEL: [n for n in workflow_dict[NODES_LABEL] if n["type"] != "output"],
+        EDGES_LABEL: [
+            e for e in workflow_dict[EDGES_LABEL] if e[TARGET_LABEL] != node_output_id
+        ],
+    }

python_workflow_definition-0.0.1/src/python_workflow_definition/shared.py

@@ -1,45 +0,0 @@
-NODES_LABEL = "nodes"
-EDGES_LABEL = "edges"
-SOURCE_LABEL = "source"
-SOURCE_PORT_LABEL = "sourcePort"
-TARGET_LABEL = "target"
-TARGET_PORT_LABEL = "targetPort"
-
-
-def get_dict(**kwargs) -> dict:
-    # NOTE: In WG, this will automatically be wrapped in a dict with the `result` key
-    return {k: v for k, v in kwargs.items()}
-    # return {'dict': {k: v for k, v in kwargs.items()}}
-
-
-def get_list(**kwargs) -> list:
-    return list(kwargs.values())
-
-
-def get_kwargs(lst: list) -> dict:
-    return {
-        t[TARGET_PORT_LABEL]: {
-            SOURCE_LABEL: t[SOURCE_LABEL],
-            SOURCE_PORT_LABEL: t[SOURCE_PORT_LABEL],
-        }
-        for t in lst
-    }
-
-
-def get_source_handles(edges_lst: list) -> dict:
-    source_handle_dict = {}
-    for ed in edges_lst:
-        if ed[SOURCE_LABEL] not in source_handle_dict.keys():
-            source_handle_dict[ed[SOURCE_LABEL]] = []
-        source_handle_dict[ed[SOURCE_LABEL]].append(ed[SOURCE_PORT_LABEL])
-    return {
-        k: list(range(len(v))) if len(v) > 1 and all([el is None for el in v]) else v
-        for k, v in source_handle_dict.items()
-    }
-
-
-def convert_nodes_list_to_dict(nodes_list: list) -> dict:
-    return {
-        str(el["id"]): el["value"] if "value" in el else el["function"]
-        for el in sorted(nodes_list, key=lambda d: d["id"])
-    }