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

{python_workflow_definition-0.1.0 → python_workflow_definition-0.1.3}/.gitignore

@@ -178,7 +178,7 @@ cython_debug/
 input_tmp.in
 pyiron.log
 pyiron_draw.png
-python_workflow_definition/src/python_workflow_definition/__pycache__/
+src/python_workflow_definition/__pycache__/
 test/
 mini/
 evcurve.png
@@ -199,4 +199,4 @@ jobflow_to_aiida_qe.json
 aiida_to_jobflow_qe.json
 pyiron_base_to_aiida_simple.json
 pyiron_base_to_jobflow_qe.json
-
+**/*.h5

python_workflow_definition-0.1.3/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Jan Janssen
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python_workflow_definition
-Version: 0.1.0
+Version: 0.1.3
 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
@@ -32,12 +32,16 @@ License: BSD 3-Clause License
         CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
         OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
         OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-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
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: pydantic<=2.12.4,>=2.7.0
+Provides-Extra: aiida
+Requires-Dist: aiida-workgraph<=0.7.6,>=0.5.1; extra == 'aiida'
+Provides-Extra: jobflow
+Requires-Dist: jobflow<=0.2.1,>=0.1.18; extra == 'jobflow'
 Provides-Extra: plot
-Requires-Dist: ipython<=9.0.2,>=7.33.0; extra == 'plot'
-Requires-Dist: networkx<=3.4.2,>=2.8.8; extra == 'plot'
+Requires-Dist: ipython<=9.8.0,>=7.33.0; extra == 'plot'
+Requires-Dist: networkx<=3.5,>=2.8.8; extra == 'plot'
 Requires-Dist: pygraphviz<=1.14,>=1.10; extra == 'plot'
+Provides-Extra: pyiron
+Requires-Dist: pyiron-base<=0.15.12,>=0.11.10; extra == 'pyiron'

python_workflow_definition-0.1.3/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "python_workflow_definition"
+description = "Python Workflow Definition - workflow interoperability for aiida, jobflow and pyiron"
+authors = [
+  { name = "Jan Janssen", email = "janssen@mpie.de" },
+  { name = "Janine George", email = "janine.geogre@bam.de" },
+  { name = "Julian Geiger", email = "julian.geiger@psi.ch" },
+  { name = "Xing Wang", email = "xing.wang@psi.ch" },
+  { name = "Marnik Bercx", email = "marnik.bercx@psi.ch" },
+  { name = "Christina Ertural", email = "christina.ertural@bam.de" },
+]
+license = { file = "LICENSE" }
+dependencies = [
+    "numpy>=1.21",
+    "pydantic>=2.7.0,<=2.12.4",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+aiida = [
+    "aiida-workgraph>=0.5.1,<=0.7.6",
+]
+jobflow = [
+    "jobflow>=0.1.18,<=0.2.1",
+]
+pyiron = [
+    "pyiron_base>=0.11.10,<=0.15.12",
+]
+plot = [
+    "pygraphviz>=1.10,<=1.14",
+    "networkx>=2.8.8,<=3.5",
+    "ipython>=7.33.0,<=9.8.0",
+]
+
+[tool.hatch.build]
+include = [
+    "src/python_workflow_definition"
+]
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/python_workflow_definition/_version.py"
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/python_workflow_definition"
+]
+
+[tool.hatch.build.targets.wheel]
+packages = [
+    "src/python_workflow_definition"
+]
+
+[tool.hatch.version]
+source = "vcs"
+path = "src/python_workflow_definition/_version.py"
+
+[tool.coverage.run]
+source = ["python_workflow_definition"]
+command_line = "-m unittest discover tests"

python_workflow_definition-0.1.3/src/python_workflow_definition/__init__.py

@@ -0,0 +1,3 @@
+import python_workflow_definition._version
+
+__version__ = python_workflow_definition._version.__version__

python_workflow_definition-0.1.3/src/python_workflow_definition/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.3'
+__version_tuple__ = version_tuple = (0, 1, 3)
+
+__commit_id__ = commit_id = None

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

@@ -3,14 +3,14 @@ import traceback
 
 from aiida import orm
 from aiida_pythonjob.data.serializer import general_serializer
-from aiida_workgraph import WorkGraph, task
+from aiida_workgraph import WorkGraph, task, Task, namespace
 from aiida_workgraph.socket import TaskSocketNamespace
-
+from dataclasses import replace
+from node_graph.node_spec import SchemaSource
 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,
@@ -24,11 +24,8 @@ from python_workflow_definition.shared import (
 
 
 def load_workflow_json(file_name: str) -> WorkGraph:
-    data = remove_result(
-        workflow_dict=PythonWorkflowDefinitionWorkflow.load_json_file(
-            file_name=file_name
-        )
-    )
+
+    data = PythonWorkflowDefinitionWorkflow.load_json_file(file_name=file_name)
 
     wg = WorkGraph()
     task_name_mapping = {}
@@ -40,10 +37,10 @@ def load_workflow_json(file_name: str) -> WorkGraph:
             p, m = identifier.rsplit(".", 1)
             mod = import_module(p)
             func = getattr(mod, m)
-            wg.add_task(func)
-            # Remove the default result output, because we will add the outputs later from the data in the link
-            del wg.tasks[-1].outputs["result"]
-            task_name_mapping[id] = wg.tasks[-1]
+            decorated_func = task(outputs=namespace())(func)
+            new_task = wg.add_task(decorated_func)
+            new_task.spec = replace(new_task.spec, schema_source=SchemaSource.EMBEDDED)
+            task_name_mapping[id] = new_task
         else:
             # data task
             data_node = general_serializer(identifier)
@@ -51,13 +48,17 @@ def load_workflow_json(file_name: str) -> WorkGraph:
 
     # add links
     for link in data[EDGES_LABEL]:
+        # TODO: continue here
         to_task = task_name_mapping[str(link[TARGET_LABEL])]
         # if the input is not exit, it means we pass the data into to the kwargs
         # in this case, we add the input socket
-        if link[TARGET_PORT_LABEL] not in to_task.inputs:
-            to_socket = to_task.add_input("workgraph.any", name=link[TARGET_PORT_LABEL])
-        else:
-            to_socket = to_task.inputs[link[TARGET_PORT_LABEL]]
+        if isinstance(to_task, Task):
+            if link[TARGET_PORT_LABEL] not in to_task.inputs:
+                to_socket = to_task.add_input_spec(
+                    "workgraph.any", name=link[TARGET_PORT_LABEL]
+                )
+            else:
+                to_socket = to_task.inputs[link[TARGET_PORT_LABEL]]
         from_task = task_name_mapping[str(link[SOURCE_LABEL])]
         if isinstance(from_task, orm.Data):
             to_socket.value = from_task
@@ -69,16 +70,14 @@ def load_workflow_json(file_name: str) -> WorkGraph:
                 # we add it here, and assume the output exit
                 if link[SOURCE_PORT_LABEL] not in from_task.outputs:
                     # if str(link["sourcePort"]) not in from_task.outputs:
-                    from_socket = from_task.add_output(
+                    from_socket = from_task.add_output_spec(
                         "workgraph.any",
                         name=link[SOURCE_PORT_LABEL],
-                        # name=str(link["sourcePort"]),
-                        metadata={"is_function_output": True},
                     )
                 else:
                     from_socket = from_task.outputs[link[SOURCE_PORT_LABEL]]
-
-                wg.add_link(from_socket, to_socket)
+                if isinstance(to_task, Task):
+                    wg.add_link(from_socket, to_socket)
             except Exception as e:
                 traceback.print_exc()
                 print("Failed to link", link, "with error:", e)
@@ -90,12 +89,18 @@ def write_workflow_json(wg: WorkGraph, file_name: str) -> dict:
     node_name_mapping = {}
     data_node_name_mapping = {}
     i = 0
+    GRAPH_LEVEL_NAMES = ["graph_inputs", "graph_outputs", "graph_ctx"]
+
     for node in wg.tasks:
-        executor = node.get_executor()
+
+        if node.name in GRAPH_LEVEL_NAMES:
+            continue
+
         node_name_mapping[node.name] = i
 
-        callable_name = executor["callable_name"]
-        callable_name = f"{executor['module_path']}.{callable_name}"
+        executor = node.get_executor()
+        callable_name = f"{executor.module_path}.{executor.callable_name}"
+
         data[NODES_LABEL].append({"id": i, "type": "function", "value": callable_name})
         i += 1
 
@@ -141,6 +146,7 @@ def write_workflow_json(wg: WorkGraph, file_name: str) -> dict:
                         SOURCE_PORT_LABEL: None,
                     }
                 )
+
     data[VERSION_LABEL] = VERSION_NUMBER
     PythonWorkflowDefinitionWorkflow(
         **set_result_node(workflow_dict=update_node_names(workflow_dict=data))

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

@@ -34,7 +34,7 @@ def _get_value(result_dict: dict, nodes_new_dict: dict, link_dict: dict, exe: Ex
     if source_handle is None:
         return result
     else:
-        return exe.submit(fn=get_item, obj=result, key=source_handle)
+        return exe.submit(get_item, obj=result, key=source_handle)
 
 
 def load_workflow_json(file_name: str, exe: Executor):

{python_workflow_definition-0.1.0 → python_workflow_definition-0.1.3}/src/python_workflow_definition/models.py

@@ -1,5 +1,15 @@
 from pathlib import Path
-from typing import List, Union, Optional, Literal, Any, Annotated, Type, TypeVar
+from typing import (
+    List,
+    Union,
+    Optional,
+    Literal,
+    Any,
+    Annotated,
+    Type,
+    TypeVar,
+)
+from typing_extensions import TypeAliasType
 from pydantic import BaseModel, Field, field_validator, field_serializer
 from pydantic import ValidationError
 import json
@@ -19,6 +29,13 @@ __all__ = (
 )
 
 
+JsonPrimitive = Union[str, int, float, bool, None]
+AllowableDefaults = TypeAliasType(
+    "AllowableDefaults",
+    "Union[JsonPrimitive, dict[str, AllowableDefaults], list[AllowableDefaults]]",
+)
+
+
 class PythonWorkflowDefinitionBaseNode(BaseModel):
     """Base model for all node types, containing common fields."""
 
@@ -33,7 +50,7 @@ class PythonWorkflowDefinitionInputNode(PythonWorkflowDefinitionBaseNode):
 
     type: Literal["input"]
     name: str
-    value: Optional[Any] = None
+    value: Optional[AllowableDefaults] = None
 
 
 class PythonWorkflowDefinitionOutputNode(PythonWorkflowDefinitionBaseNode):

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

@@ -98,11 +98,11 @@ def get_dict(**kwargs) -> dict:
 
 
 def get_list(**kwargs) -> list:
-    return list(kwargs["kwargs"].values())
+    return list(kwargs["kwargs"])
 
 
 def _remove_server_obj(nodes_dict: dict, edges_lst: list):
-    server_lst = [k for k in nodes_dict.keys() if k.startswith("server_obj_")]
+    server_lst = [k for k in nodes_dict.keys() if k.startswith("_server_obj_")]
     for s in server_lst:
         del nodes_dict[s]
         edges_lst = [ep for ep in edges_lst if s not in ep]
@@ -285,18 +285,32 @@ def write_workflow_json(
     )
 
     nodes_store_lst = []
-    for k, v in nodes_new_dict.items():
+    translate_dict = {}
+    for i, k in enumerate(list(nodes_new_dict.keys())[::-1]):
+        v = nodes_new_dict[k]
+        translate_dict[k] = i
         if isfunction(v):
             mod = v.__module__
             if mod == "python_workflow_definition.pyiron_base":
                 mod = "python_workflow_definition.shared"
             nodes_store_lst.append(
-                {"id": k, "type": "function", "value": mod + "." + v.__name__}
+                {"id": i, "type": "function", "value": mod + "." + v.__name__}
             )
         elif isinstance(v, np.ndarray):
-            nodes_store_lst.append({"id": k, "type": "input", "value": v.tolist()})
+            nodes_store_lst.append({"id": i, "type": "input", "value": v.tolist()})
         else:
-            nodes_store_lst.append({"id": k, "type": "input", "value": v})
+            nodes_store_lst.append({"id": i, "type": "input", "value": v})
+
+    print(translate_dict)
+    edges_store_lst = [
+        {
+            TARGET_LABEL: translate_dict[edge[TARGET_LABEL]],
+            TARGET_PORT_LABEL: edge[TARGET_PORT_LABEL],
+            SOURCE_LABEL: translate_dict[edge[SOURCE_LABEL]],
+            SOURCE_PORT_LABEL: edge[SOURCE_PORT_LABEL],
+        }
+        for edge in edges_new_lst
+    ]
 
     PythonWorkflowDefinitionWorkflow(
         **set_result_node(
@@ -304,7 +318,7 @@ def write_workflow_json(
                 workflow_dict={
                     VERSION_LABEL: VERSION_NUMBER,
                     NODES_LABEL: nodes_store_lst,
-                    EDGES_LABEL: edges_new_lst,
+                    EDGES_LABEL: edges_store_lst,
                 }
             )
         )

python_workflow_definition-0.1.3/src/python_workflow_definition/pyiron_workflow.py

@@ -0,0 +1,407 @@
+from collections import Counter
+from inspect import isfunction
+from importlib import import_module
+from typing import Any
+
+import numpy as np
+from pyiron_workflow import as_function_node, function_node, Workflow
+from pyiron_workflow.api import Function
+
+from python_workflow_definition.models import PythonWorkflowDefinitionWorkflow
+from python_workflow_definition.shared import (
+    get_dict,
+    update_node_names,
+    set_result_node,
+    remove_result,
+    NODES_LABEL,
+    EDGES_LABEL,
+    SOURCE_LABEL,
+    SOURCE_PORT_LABEL,
+    TARGET_LABEL,
+    TARGET_PORT_LABEL,
+    VERSION_NUMBER,
+    VERSION_LABEL,
+)
+
+
+def get_linked_nodes(graph_dict):
+    nodes_dict = {}
+    node_mapping_dict = {}
+    input_dict = {}
+    for i, [k, v] in enumerate(graph_dict["nodes"].items()):
+        if "inputs_to_dict_factory" in str(type(v)):
+            nodes_dict[i] = get_dict
+        else:
+            nodes_dict[i] = v.node_function
+        node_mapping_dict[k] = i
+        input_dict[k] = {
+            con.full_label: con.value
+            for con in v.inputs.channel_dict.to_list()
+            if len(con.connections) == 0
+        }
+    return nodes_dict, node_mapping_dict, input_dict
+
+
+def extend_nodes_dict(nodes_dict, input_dict):
+    i = len(nodes_dict)
+    nodes_links_dict = {}
+    nodes_values_str_lst = [str(s) for s in nodes_dict.values()]
+    for val_dict in input_dict.values():
+        for k, v in val_dict.items():
+            if str(v) not in nodes_values_str_lst:
+                nodes_dict[i] = v
+                nodes_links_dict[k] = i
+                i += 1
+            else:
+                nodes_links_dict[k] = {tv: tk for tk, tv in nodes_dict.items()}[v]
+    return nodes_links_dict
+
+
+def get_edges(graph_dict, node_mapping_dict, nodes_links_dict):
+    edges_lst = []
+    for link in list(graph_dict["edges"]["data"].keys()):
+        source_combo, target_combo = link
+        target, target_handle = target_combo.split(".")
+        source, source_handle = source_combo.split(".")
+        edges_lst.append(
+            {
+                TARGET_LABEL: node_mapping_dict[target],
+                TARGET_PORT_LABEL: target_handle,
+                SOURCE_LABEL: node_mapping_dict[source],
+                SOURCE_PORT_LABEL: source_handle,
+            }
+        )
+
+    for k, v in nodes_links_dict.items():
+        target, target_handle = k.split(".")
+        edges_lst.append(
+            {
+                TARGET_LABEL: node_mapping_dict[target],
+                TARGET_PORT_LABEL: target_handle,
+                SOURCE_LABEL: v,
+                SOURCE_PORT_LABEL: None,
+            }
+        )
+    return edges_lst
+
+
+def write_workflow_json(graph_as_dict: dict, file_name: str = "workflow.json"):
+    nodes_dict, node_mapping_dict, input_dict = get_linked_nodes(
+        graph_dict=graph_as_dict
+    )
+    nodes_links_dict = extend_nodes_dict(nodes_dict=nodes_dict, input_dict=input_dict)
+    edges_lst = get_edges(
+        graph_dict=graph_as_dict,
+        node_mapping_dict=node_mapping_dict,
+        nodes_links_dict=nodes_links_dict,
+    )
+
+    pyiron_workflow_modules = {}
+    for k, v in nodes_dict.items():
+        if isfunction(v) and "pyiron_workflow" in v.__module__:
+            pyiron_workflow_modules[k] = v
+
+    cache_mapping_dict, remap_dict = {}, {}
+    for k, v in nodes_dict.items():
+        if not isfunction(v) and str(v) not in cache_mapping_dict:
+            cache_mapping_dict[str(v)] = k
+        elif not isfunction(v):
+            remap_dict[k] = cache_mapping_dict[str(v)]
+
+    item_node_lst = [
+        e[SOURCE_LABEL]
+        for e in edges_lst
+        if e[TARGET_LABEL] in pyiron_workflow_modules.keys()
+        and e[TARGET_PORT_LABEL] == "item"
+    ]
+
+    values_from_dict_lst = [
+        k
+        for k, v in nodes_dict.items()
+        if isfunction(v) and v.__name__ == "get_values_from_dict"
+    ]
+
+    remap_get_list_dict = {}
+    for e in edges_lst:
+        if e[TARGET_LABEL] in values_from_dict_lst:
+            remap_get_list_dict[e[SOURCE_LABEL]] = e[TARGET_LABEL]
+
+    nodes_remaining_dict = {
+        k: v
+        for k, v in nodes_dict.items()
+        if k not in pyiron_workflow_modules.keys()
+        and k not in remap_dict.keys()
+        and k not in item_node_lst
+        and k not in remap_get_list_dict.values()
+    }
+
+    nodes_store_lst = []
+    nodes_final_order_dict = {}
+    for k, [i, v] in enumerate(nodes_remaining_dict.items()):
+        if i in remap_get_list_dict:
+            nodes_store_lst.append(
+                {
+                    "id": k,
+                    "type": "function",
+                    "value": "python_workflow_definition.shared.get_list",
+                }
+            )
+        elif isfunction(v):
+            mod = v.__module__
+            if mod == "python_workflow_definition.pyiron_workflow":
+                mod = "python_workflow_definition.shared"
+            nodes_store_lst.append(
+                {"id": k, "type": "function", "value": mod + "." + v.__name__}
+            )
+        elif isinstance(v, np.ndarray):
+            nodes_store_lst.append({"id": k, "type": "input", "value": v.tolist()})
+        else:
+            nodes_store_lst.append({"id": k, "type": "input", "value": v})
+        nodes_final_order_dict[i] = k
+
+    remap_get_list_remove_edges = [
+        edge for edge in edges_lst if edge[TARGET_LABEL] in remap_get_list_dict.values()
+    ]
+
+    edge_get_list_updated_lst = []
+    for edge in edges_lst:
+        if edge[SOURCE_LABEL] in remap_get_list_dict.values():
+            connected_edge = [
+                edge_con
+                for edge_con in remap_get_list_remove_edges
+                if edge_con[TARGET_LABEL] == edge[SOURCE_LABEL]
+            ][-1]
+            edge_updated = {
+                TARGET_LABEL: edge[TARGET_LABEL],
+                TARGET_PORT_LABEL: edge[TARGET_PORT_LABEL],
+                SOURCE_LABEL: connected_edge[SOURCE_LABEL],
+                SOURCE_PORT_LABEL: connected_edge[SOURCE_PORT_LABEL],
+            }
+            edge_get_list_updated_lst.append(edge_updated)
+        elif edge[SOURCE_LABEL] in remap_dict.keys():
+            edge_updated = {
+                TARGET_LABEL: edge[TARGET_LABEL],
+                TARGET_PORT_LABEL: edge[TARGET_PORT_LABEL],
+                SOURCE_LABEL: remap_dict[edge[SOURCE_LABEL]],
+                SOURCE_PORT_LABEL: edge[SOURCE_PORT_LABEL],
+            }
+            edge_get_list_updated_lst.append(edge_updated)
+        elif edge[TARGET_LABEL] not in remap_get_list_dict.values():
+            edge_get_list_updated_lst.append(edge)
+
+    target_dict = {}
+    for edge in edge_get_list_updated_lst:
+        for k in pyiron_workflow_modules.keys():
+            if k == edge[TARGET_LABEL]:
+                if k not in target_dict:
+                    target_dict[k] = []
+                target_dict[k].append(edge)
+
+    source_dict = {}
+    for edge in edge_get_list_updated_lst:
+        for k in pyiron_workflow_modules.keys():
+            if k == edge[SOURCE_LABEL]:
+                if k not in source_dict:
+                    source_dict[k] = []
+                source_dict[k].append(edge)
+
+    edge_new_lst, nodes_to_delete = [], []
+    for k in target_dict.keys():
+        source, sourcehandle = None, None
+        for edge in target_dict[k]:
+            if edge[SOURCE_PORT_LABEL] is None:
+                sourcehandle = nodes_dict[edge[SOURCE_LABEL]]
+                nodes_to_delete.append(edge[SOURCE_LABEL])
+            else:
+                source = edge[SOURCE_LABEL]
+        if "s_" == source_dict[k][-1][TARGET_PORT_LABEL][:2]:
+            edge_new_lst.append(
+                {
+                    SOURCE_LABEL: nodes_final_order_dict[source],
+                    SOURCE_PORT_LABEL: sourcehandle,
+                    TARGET_LABEL: nodes_final_order_dict[
+                        source_dict[k][-1][TARGET_LABEL]
+                    ],
+                    TARGET_PORT_LABEL: source_dict[k][-1][TARGET_PORT_LABEL][2:],
+                }
+            )
+        else:
+            edge_new_lst.append(
+                {
+                    SOURCE_LABEL: nodes_final_order_dict[source],
+                    SOURCE_PORT_LABEL: sourcehandle,
+                    TARGET_LABEL: nodes_final_order_dict[
+                        source_dict[k][-1][TARGET_LABEL]
+                    ],
+                    TARGET_PORT_LABEL: source_dict[k][-1][TARGET_PORT_LABEL],
+                }
+            )
+
+    nodes_to_skip = nodes_to_delete + list(pyiron_workflow_modules.keys())
+    for edge in edge_get_list_updated_lst:
+        if (
+            edge[TARGET_LABEL] not in nodes_to_skip
+            and edge[SOURCE_LABEL] not in nodes_to_skip
+        ):
+            source_node = nodes_remaining_dict[edge[SOURCE_LABEL]]
+            if (
+                isfunction(source_node)
+                and source_node.__name__ == edge[SOURCE_PORT_LABEL]
+            ):
+                edge_new_lst.append(
+                    {
+                        TARGET_LABEL: nodes_final_order_dict[edge[TARGET_LABEL]],
+                        TARGET_PORT_LABEL: edge[TARGET_PORT_LABEL],
+                        SOURCE_LABEL: nodes_final_order_dict[edge[SOURCE_LABEL]],
+                        SOURCE_PORT_LABEL: None,
+                    }
+                )
+            elif (
+                isfunction(source_node)
+                and source_node.__name__ == "get_dict"
+                and edge[SOURCE_PORT_LABEL] == "dict"
+            ):
+                edge_new_lst.append(
+                    {
+                        TARGET_LABEL: nodes_final_order_dict[edge[TARGET_LABEL]],
+                        TARGET_PORT_LABEL: edge[TARGET_PORT_LABEL],
+                        SOURCE_LABEL: nodes_final_order_dict[edge[SOURCE_LABEL]],
+                        SOURCE_PORT_LABEL: None,
+                    }
+                )
+            else:
+                edge_new_lst.append(
+                    {
+                        TARGET_LABEL: nodes_final_order_dict[edge[TARGET_LABEL]],
+                        TARGET_PORT_LABEL: edge[TARGET_PORT_LABEL],
+                        SOURCE_LABEL: nodes_final_order_dict[edge[SOURCE_LABEL]],
+                        SOURCE_PORT_LABEL: edge[SOURCE_PORT_LABEL],
+                    }
+                )
+
+    PythonWorkflowDefinitionWorkflow(
+        **set_result_node(
+            workflow_dict=update_node_names(
+                workflow_dict={
+                    VERSION_LABEL: VERSION_NUMBER,
+                    NODES_LABEL: nodes_store_lst,
+                    EDGES_LABEL: edge_new_lst,
+                }
+            )
+        )
+    ).dump_json_file(file_name=file_name, indent=2)
+
+
+def import_from_string(library_path: str) -> Any:
+    # Copied from bagofholding
+    split_path = library_path.split(".", 1)
+    if len(split_path) == 1:
+        module_name, path = split_path[0], ""
+    else:
+        module_name, path = split_path
+    obj = import_module(module_name)
+    for k in path.split("."):
+        obj = getattr(obj, k)
+    return obj
+
+
+def generate_get_dict_function(args_of_lst):
+    lines = "def get_dict(" + ", ".join(args_of_lst) + "):\n"
+    lines += "    return {\n"
+    for parameter in args_of_lst:
+        lines += '        "' + parameter + '": ' + parameter + ",\n"
+    lines += "    }"
+    return lines
+
+
+def generate_get_list_function(args_of_lst):
+    lines = "def get_list(" + ", ".join(args_of_lst) + "):\n"
+    lines += "    return [\n"
+    for parameter in args_of_lst:
+        lines += "        " + parameter + ",\n"
+    lines += "    ]"
+    return lines
+
+
+def load_workflow_json(file_name: str) -> Workflow:
+    content = remove_result(
+        PythonWorkflowDefinitionWorkflow.load_json_file(file_name=file_name)
+    )
+
+    input_values: dict[int, object] = (
+        {}
+    )  # Type is actually more restrictive, must be jsonifyable object
+    nodes: dict[int, Function] = {}
+    total_counter_dict = Counter(
+        [n["value"] for n in content[NODES_LABEL] if n["type"] == "function"]
+    )
+    counter_dict = {k: -1 for k in total_counter_dict.keys()}
+    wf = Workflow(file_name.split(".")[0])
+    nodes_look_up_dict = {node["id"]: node["value"] for node in content[NODES_LABEL]}
+    for node_dict in content[NODES_LABEL]:
+        if node_dict["type"] == "function":
+            if node_dict["value"] == "python_workflow_definition.shared.get_dict":
+                exec(
+                    generate_get_dict_function(
+                        args_of_lst=[
+                            edge[TARGET_PORT_LABEL]
+                            for edge in content[EDGES_LABEL]
+                            if edge[TARGET_LABEL] == node_dict["id"]
+                        ]
+                    )
+                )
+                fnc = eval("get_dict")
+            elif node_dict["value"] == "python_workflow_definition.shared.get_list":
+                exec(
+                    generate_get_list_function(
+                        args_of_lst=[
+                            "s_" + edge[TARGET_PORT_LABEL]
+                            for edge in content[EDGES_LABEL]
+                            if edge[TARGET_LABEL] == node_dict["id"]
+                        ]
+                    )
+                )
+                fnc = eval("get_list")
+            else:
+                fnc = import_from_string(node_dict["value"])
+            if total_counter_dict[node_dict["value"]] > 1:
+                counter_dict[node_dict["value"]] += 1
+                name = fnc.__name__ + "_" + str(counter_dict[node_dict["value"]])
+            else:
+                name = fnc.__name__
+            n = function_node(
+                fnc, output_labels=name, validate_output_labels=False
+            )  # Strictly force single-output
+            nodes[node_dict["id"]] = n
+            wf.add_child(child=n, label=name)
+        elif node_dict["type"] == "input":
+            input_values[node_dict["id"]] = node_dict["value"]
+
+    for edge_dict in content[EDGES_LABEL]:
+        target_id = edge_dict[TARGET_LABEL]
+        target_port = edge_dict[TARGET_PORT_LABEL]
+        source_id = edge_dict[SOURCE_LABEL]
+        source_port = edge_dict[SOURCE_PORT_LABEL]
+
+        if source_port is None:
+            if source_id in input_values.keys():  # Parent input value
+                upstream = input_values[source_id]
+            else:  # Single-output sibling
+                upstream = nodes[source_id]
+        else:  # Dictionary-output sibling
+            injected_attribute_access = nodes[source_id].__getitem__(source_port)
+            upstream = injected_attribute_access
+        downstream = nodes[target_id]
+        if (
+            nodes_look_up_dict[target_id]
+            == "python_workflow_definition.shared.get_list"
+        ):
+            setattr(downstream.inputs, "s_" + target_port, upstream)
+        else:
+            setattr(
+                downstream.inputs, target_port, upstream
+            )  # Exploit input panel magic
+            # Warning: edge setup routine is bespoke for an environment where all nodes return
+            # a single value or a dictionary
+
+    return wf

python_workflow_definition-0.1.0/pyproject.toml

@@ -1,31 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "python_workflow_definition"
-version = "0.1.0"
-description = "Python Workflow Definition - workflow interoperability for aiida, jobflow and pyiron"
-authors = [
-  { name = "Jan Janssen", email = "janssen@mpie.de" },
-  { name = "Janine George", email = "janine.geogre@bam.de" },
-  { name = "Julian Geiger", email = "julian.geiger@psi.ch" },
-  { name = "Xing Wang", email = "xing.wang@psi.ch" },
-  { name = "Marnik Bercx", email = "marnik.bercx@psi.ch" },
-  { name = "Christina Ertural", email = "christina.ertural@bam.de" },
-]
-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",
-    "pydantic>=2.7.0,<=2.11.4",
-]
-
-[project.optional-dependencies]
-plot = [
-    "pygraphviz>=1.10,<=1.14",
-    "networkx>=2.8.8,<=3.4.2",
-    "ipython>=7.33.0,<=9.0.2",
-]