aiida-pythonjob 0.3.1__tar.gz → 0.3.2__tar.gz

{aiida_pythonjob-0.3.1 → aiida_pythonjob-0.3.2}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.4
 Name: aiida-pythonjob
-Version: 0.3.1
+Version: 0.3.2
 Summary: Run Python functions on a remote computer.
-Project-URL: Source, https://github.com/aiidateam/aiida-pythonjob
 Author-email: Xing Wang <xingwang1991@gmail.com>
 License: MIT License
         
@@ -25,33 +24,40 @@ License: MIT License
         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
-License-File: LICENSE
+        
+Project-URL: Source, https://github.com/aiidateam/aiida-pythonjob
 Keywords: aiida,plugin
-Classifier: Development Status :: 3 - Alpha
-Classifier: Framework :: AiiDA
+Classifier: Programming Language :: Python
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
-Classifier: Programming Language :: Python
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AiiDA
 Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: aiida-core<3,>=2.3
 Requires-Dist: ase
 Requires-Dist: cloudpickle
-Requires-Dist: node-graph~=0.2.23
-Provides-Extra: dev
-Requires-Dist: hatch; extra == 'dev'
-Provides-Extra: docs
-Requires-Dist: furo; extra == 'docs'
-Requires-Dist: markupsafe<2.1; extra == 'docs'
-Requires-Dist: nbsphinx; extra == 'docs'
-Requires-Dist: sphinx; extra == 'docs'
-Requires-Dist: sphinx-gallery; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme; extra == 'docs'
-Requires-Dist: sphinxcontrib-contentui; extra == 'docs'
-Requires-Dist: sphinxcontrib-details-directive; extra == 'docs'
+Requires-Dist: node-graph>=0.3.0
+Provides-Extra: test
+Requires-Dist: pgtest>=1.3.1,~=1.3; extra == "test"
+Requires-Dist: coverage~=7.0; extra == "test"
+Requires-Dist: pytest~=7.0; extra == "test"
+Requires-Dist: pytest-cov~=4.1; extra == "test"
+Requires-Dist: ipdb; extra == "test"
 Provides-Extra: pre-commit
-Requires-Dist: pre-commit~=3.5; extra == 'pre-commit'
-Description-Content-Type: text/markdown
+Requires-Dist: pre-commit~=3.5; extra == "pre-commit"
+Provides-Extra: docs
+Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinxcontrib-contentui; extra == "docs"
+Requires-Dist: sphinxcontrib-details-directive; extra == "docs"
+Requires-Dist: sphinx-gallery; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: markupsafe<2.1; extra == "docs"
+Requires-Dist: nbsphinx; extra == "docs"
+Dynamic: license-file
 
 # AiiDA-PythonJob
 [![PyPI version](https://badge.fury.io/py/aiida-pythonjob.svg)](https://badge.fury.io/py/aiida-pythonjob)

aiida_pythonjob-0.3.2/pyproject.toml

@@ -0,0 +1,114 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aiida-pythonjob"
+dynamic = ["version"]  # read from src/aiida_pythonjob/__init__.py via setuptools
+description = "Run Python functions on a remote computer."
+authors = [{name = "Xing Wang", email = "xingwang1991@gmail.com"}]
+readme = "README.md"
+license = {file = "LICENSE"}
+classifiers = [
+    "Programming Language :: Python",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Natural Language :: English",
+    "Development Status :: 3 - Alpha",
+    "Framework :: AiiDA"
+]
+keywords = ["aiida", "plugin"]
+requires-python = ">=3.9"
+dependencies = [
+    "aiida-core>=2.3,<3",
+    "ase",
+    "cloudpickle",
+    "node-graph>=0.3.0",
+]
+
+[project.optional-dependencies]
+test = [
+  "pgtest~=1.3,>=1.3.1",
+  "coverage~=7.0",
+  "pytest~=7.0",
+  "pytest-cov~=4.1",
+  "ipdb"
+]
+pre-commit = [
+  "pre-commit~=3.5",
+]
+docs = [
+  "sphinx_rtd_theme",
+  "sphinx",
+  "sphinxcontrib-contentui",
+  "sphinxcontrib-details-directive",
+  "sphinx-gallery",
+  "furo",
+  "markupsafe<2.1",
+  "nbsphinx"
+]
+
+[project.urls]
+Source = "https://github.com/aiidateam/aiida-pythonjob"
+
+[project.entry-points."aiida.data"]
+"pythonjob.jsonable_data" = "aiida_pythonjob.data.jsonable_data:JsonableData"
+"pythonjob.pickled_data" = "aiida_pythonjob.data.pickled_data:PickledData"
+"pythonjob.ase.atoms.Atoms" = "aiida_pythonjob.data.atoms:AtomsData"
+"pythonjob.builtins.int" = "aiida.orm.nodes.data.int:Int"
+"pythonjob.builtins.float" = "aiida.orm.nodes.data.float:Float"
+"pythonjob.builtins.str" = "aiida.orm.nodes.data.str:Str"
+"pythonjob.builtins.bool" = "aiida.orm.nodes.data.bool:Bool"
+"pythonjob.builtins.list" = "aiida_pythonjob.data.data_wrapper:List"
+"pythonjob.builtins.dict" = "aiida_pythonjob.data.data_wrapper:Dict"
+"pythonjob.numpy.float32" = "aiida.orm.nodes.data.float:Float"
+"pythonjob.numpy.float64" = "aiida.orm.nodes.data.float:Float"
+"pythonjob.numpy.int64" = "aiida.orm.nodes.data.int:Int"
+"pythonjob.numpy.bool_" = "aiida.orm.nodes.data.bool:Bool"
+"pythonjob.numpy.ndarray" = "aiida_pythonjob.data.data_wrapper:ArrayData"
+
+[project.entry-points."aiida.calculations"]
+"pythonjob.pythonjob" = "aiida_pythonjob.calculations.pythonjob:PythonJob"
+
+[project.entry-points."aiida.parsers"]
+"pythonjob.pythonjob" = "aiida_pythonjob.parsers.pythonjob:PythonJobParser"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["aiida_pythonjob*"]
+
+[tool.setuptools.dynamic]
+version = {attr = "aiida_pythonjob.__version__"}
+
+[tool.pytest.ini_options]
+python_files = "test_*.py example_*.py"
+addopts = "--pdbcls=IPython.terminal.debugger:TerminalPdb"
+filterwarnings = [
+  "ignore::DeprecationWarning:aiida:",
+  "ignore:Creating AiiDA configuration folder:",
+  "ignore::DeprecationWarning:plumpy:",
+  "ignore::DeprecationWarning:yaml:",
+]
+
+[tool.coverage.run]
+source = ["src/aiida_pythonjob"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+ignore = [
+  "F403",
+  "F405",
+  "PLR0911",
+  "PLR0912",
+  "PLR0913",
+  "PLR0915",
+  "PLR2004",
+  "RUF005",
+  "RUF012"
+]
+select = ["E", "W", "F", "I", "N", "PLC", "PLE", "PLR", "PLW", "RUF"]

aiida_pythonjob-0.3.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{aiida_pythonjob-0.3.1 → aiida_pythonjob-0.3.2}/src/aiida_pythonjob/__init__.py

@@ -1,16 +1,17 @@
 """AiiDA plugin that run Python function on remote computers."""
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"
 
-from node_graph import spec
+from node_graph import socket_spec as spec
 
-from .calculations import PythonJob
+from .calculations import PyFunction, PythonJob
 from .decorator import pyfunction
 from .launch import prepare_pythonjob_inputs
 from .parsers import PythonJobParser
 
 __all__ = (
     "PythonJob",
+    "PyFunction",
     "pyfunction",
     "PickledData",
     "prepare_pythonjob_inputs",

aiida_pythonjob-0.3.2/src/aiida_pythonjob/calculations/__init__.py

@@ -0,0 +1,4 @@
+from .pyfunction import PyFunction
+from .pythonjob import PythonJob
+
+__all__ = ("PythonJob", "PyFunction")

{aiida_pythonjob-0.3.1 → aiida_pythonjob-0.3.2}/src/aiida_pythonjob/calculations/pyfunction.py

@@ -17,12 +17,13 @@ from aiida.orm import (
     Str,
     to_aiida_type,
 )
+from node_graph.socket_spec import SocketSpec
 
 __all__ = ("PyFunction",)
 
 
 class PyFunction(Process):
-    """"""
+    """Run a Python function in-process, using SocketSpec for I/O."""
 
     _node_class = CalcFunctionNode
 
@@ -53,8 +54,8 @@ class PyFunction(Process):
         """Define the process specification, including its inputs, outputs and known exit codes."""
         super().define(spec)
         spec.input_namespace("function_data", dynamic=True, required=True)
-        spec.input("function_data.output_ports", valid_type=Dict, serializer=to_aiida_type, required=False)
-        spec.input("function_data.input_ports", valid_type=Dict, serializer=to_aiida_type, required=False)
+        spec.input("function_data.outputs_spec", valid_type=Dict, serializer=to_aiida_type, required=False)
+        spec.input("function_data.inputs_spec", valid_type=Dict, serializer=to_aiida_type, required=False)
         spec.input("process_label", valid_type=Str, serializer=to_aiida_type, required=False)
         spec.input_namespace("function_inputs", valid_type=Data, required=False)
         spec.input(
@@ -160,11 +161,13 @@ class PyFunction(Process):
         else:
             self.deserializers = None
 
+        # Build input namespace (raw Python) from AiiDA inputs using the declared SocketSpec
         inputs = dict(self.inputs.function_inputs or {})
         try:
+            inputs_spec = SocketSpec.from_dict(self.node.inputs.function_data.inputs_spec.get_dict())
             inputs = deserialize_ports(
                 serialized_data=inputs,
-                port_schema=self.node.inputs.function_data.input_ports.get_dict(),
+                port_schema=inputs_spec,
                 deserializers=self.deserializers,
             )
         except Exception as exception:
@@ -174,6 +177,7 @@ class PyFunction(Process):
                 exception=exception_message, traceback=traceback_str
             )
 
+        # Execute user function
         try:
             results = self.func(**inputs)
         except Exception as exception:
@@ -182,16 +186,18 @@ class PyFunction(Process):
             return self.exit_codes.ERROR_FUNCTION_EXECUTION_FAILED.format(
                 exception=exception_message, traceback=traceback_str
             )
+
+        # Parse & output
         return self.parse(results)
 
     def parse(self, results):
-        """Parse the results of the function."""
-        from aiida_pythonjob.utils import parse_outputs
+        """Parse the results of the function and attach outputs."""
+        from aiida_pythonjob.parsers.utils import parse_outputs
 
-        self.output_ports = self.node.inputs.function_data.output_ports.get_dict()
-        exit_code = parse_outputs(
+        outputs_spec = SocketSpec.from_dict(self.node.inputs.function_data.outputs_spec.get_dict())
+        outputs, exit_code = parse_outputs(
             results,
-            output_ports=self.output_ports,
+            output_spec=outputs_spec,
             exit_codes=self.exit_codes,
             logger=self.logger,
             serializers=self.serializers,
@@ -199,8 +205,7 @@ class PyFunction(Process):
         if exit_code:
             return exit_code
         # Store the outputs
-        for name, port in self.output_ports["ports"].items():
-            if "value" in port:
-                self.out(name, port["value"])
+        for name, value in (outputs or {}).items():
+            self.out(name, value)
 
         return ExitCode()

{aiida_pythonjob-0.3.1 → aiida_pythonjob-0.3.2}/src/aiida_pythonjob/calculations/pythonjob.py

@@ -45,8 +45,8 @@ class PythonJob(CalcJob):
         """Define the process specification, including its inputs, outputs and known exit codes."""
         super().define(spec)
         spec.input_namespace("function_data", dynamic=True, required=True)
-        spec.input("function_data.input_ports", valid_type=Dict, serializer=to_aiida_type, required=False)
-        spec.input("function_data.output_ports", valid_type=Dict, serializer=to_aiida_type, required=False)
+        spec.input("function_data.inputs_spec", valid_type=Dict, serializer=to_aiida_type, required=False)
+        spec.input("function_data.outputs_spec", valid_type=Dict, serializer=to_aiida_type, required=False)
         spec.input("process_label", valid_type=Str, serializer=to_aiida_type, required=False)
         spec.input_namespace("function_inputs", valid_type=Data, required=False)
         spec.input(

{aiida_pythonjob-0.3.1 → aiida_pythonjob-0.3.2}/src/aiida_pythonjob/data/serializer.py

@@ -18,23 +18,32 @@ def atoms_to_structure_data(structure):
 
 
 def get_serializers_from_entry_points() -> dict:
-    # Retrieve the entry points for 'aiida.data' and store them in a dictionary
-    eps = entry_points()
+    """Retrieve the entry points for 'aiida.data' and store them in a dictionary."""
+    eps_all = entry_points()
     if sys.version_info >= (3, 10):
-        group = eps.select(group="aiida.data")
+        group = eps_all.select(group="aiida.data")
     else:
-        group = eps.get("aiida.data", [])
-    eps = {}
-    for ep in group:
+        group = eps_all.get("aiida.data", [])
+
+    # By converting the group to a set, we remove accidental duplicates
+    # where the same EntryPoint object is discovered twice. Legitimate
+    # competing entry points from different packages will remain.
+    unique_group = set(group)
+
+    serializers = {}
+    for ep in unique_group:
         # split the entry point name by first ".", and check the last part
         key = ep.name.split(".", 1)[-1]
+
         # skip key without "." because it is not a module name for a data type
         if "." not in key:
             continue
-        eps.setdefault(key, [])
+
+        serializers.setdefault(key, [])
         # get the path of the entry point value and replace ":" with "."
-        eps[key].append(ep.value.replace(":", "."))
-    return eps
+        serializers[key].append(ep.value.replace(":", "."))
+
+    return serializers
 
 
 def get_serializers() -> dict:

{aiida_pythonjob-0.3.1 → aiida_pythonjob-0.3.2}/src/aiida_pythonjob/decorator.py

@@ -5,11 +5,12 @@ import logging
 import signal
 import sys
 import typing as t
-from typing import Any, Mapping
+from typing import List
 
 from aiida.engine.processes.functions import FunctionType, get_stack_size
 from aiida.manage import get_manager
 from aiida.orm import ProcessNode
+from node_graph.socket_spec import SocketSpec
 
 from aiida_pythonjob.calculations.pyfunction import PyFunction
 from aiida_pythonjob.launch import create_inputs, prepare_pyfunction_inputs
@@ -19,8 +20,8 @@ LOGGER = logging.getLogger(__name__)
 
 # The following code is modified from the aiida-core.engine.processes.functions module
 def pyfunction(
-    inputs: t.Optional[Mapping[str, Any]] = None,
-    outputs: t.Optional[t.List[Mapping[str, Any]]] = None,
+    inputs: t.Optional[SocketSpec | List[str]] = None,
+    outputs: t.Optional[t.List[SocketSpec | List[str]]] = None,
 ) -> t.Callable[[FunctionType], FunctionType]:
     """The base function decorator to create a FunctionProcess out of a normal python function.
 
@@ -62,8 +63,6 @@ def pyfunction(
             # # Remove all the known inputs from the kwargs
             outputs_spec = kwargs.pop("outputs_spec", None) or outputs
             inputs_spec = kwargs.pop("inputs_spec", None) or inputs
-            input_ports = kwargs.pop("input_ports", None)
-            output_ports = kwargs.pop("output_ports", None)
             metadata = kwargs.pop("metadata", None)
             function_data = kwargs.pop("function_data", None)
             deserializers = kwargs.pop("deserializers", None)
@@ -77,8 +76,6 @@ def pyfunction(
                 function_inputs=function_inputs,
                 inputs_spec=inputs_spec,
                 outputs_spec=outputs_spec,
-                input_ports=input_ports,
-                output_ports=output_ports,
                 metadata=metadata,
                 process_label=process_label,
                 function_data=function_data,

{aiida_pythonjob-0.3.1 → aiida_pythonjob-0.3.2}/src/aiida_pythonjob/launch.py

@@ -5,9 +5,9 @@ import os
 from typing import Any, Callable, Dict, Optional, Union
 
 from aiida import orm
-from node_graph.nodes.utils import generate_input_sockets, generate_output_sockets
+from node_graph.node_spec import BaseHandle
+from node_graph.socket_spec import infer_specs_from_callable
 
-from .ports_adapter import inputs_sockets_to_ports, outputs_sockets_to_ports
 from .utils import build_function_data, get_or_create_code, serialize_ports
 
 
@@ -16,8 +16,6 @@ def prepare_pythonjob_inputs(
     function_inputs: Optional[Dict[str, Any]] = None,
     inputs_spec: Optional[type] = None,
     outputs_spec: Optional[type] = None,
-    output_ports: Optional[Dict[str, Any]] = None,
-    input_ports: Optional[Dict[str, Any]] = None,
     code: Optional[orm.AbstractCode] = None,
     command_info: Optional[Dict[str, str]] = None,
     computer: Union[str, orm.Computer] = "localhost",
@@ -36,6 +34,8 @@ def prepare_pythonjob_inputs(
         raise ValueError("Either function or function_data must be provided")
     if function is not None and function_data is not None:
         raise ValueError("Only one of function or function_data should be provided")
+    if isinstance(function, BaseHandle):
+        function = function._func
     # if function is a function, inspect it and get the source code
     if function is not None and inspect.isfunction(function):
         function_data = build_function_data(function, register_pickle_by_value=register_pickle_by_value)
@@ -60,20 +60,12 @@ def prepare_pythonjob_inputs(
     if code is None:
         command_info = command_info or {}
         code = get_or_create_code(computer=computer, **command_info)
-    # outputs
-    if not output_ports:
-        node_outputs = generate_output_sockets(function or (lambda **_: None), outputs=outputs_spec)
-        output_ports = outputs_sockets_to_ports(node_outputs)
-    # inputs
-    if not input_ports:
-        node_inputs = generate_input_sockets(function or (lambda **_: None), inputs=inputs_spec)
-        input_ports = inputs_sockets_to_ports(node_inputs)
-
-    function_data["output_ports"] = output_ports
-    function_data["input_ports"] = input_ports
+    in_spec, out_spec = infer_specs_from_callable(function, inputs=inputs_spec, outputs=outputs_spec)
+    function_data["inputs_spec"] = in_spec.to_dict()
+    function_data["outputs_spec"] = out_spec.to_dict()
     # serialize kwargs against the (nested) input schema
     function_inputs = function_inputs or {}
-    function_inputs = serialize_ports(python_data=function_inputs, port_schema=input_ports, serializers=serializers)
+    function_inputs = serialize_ports(python_data=function_inputs, port_schema=in_spec, serializers=serializers)
     # replace "." with "__dot__" in the keys of a dictionary
     if deserializers:
         deserializers = orm.Dict({k.replace(".", "__dot__"): v for k, v in deserializers.items()})
@@ -116,8 +108,6 @@ def prepare_pyfunction_inputs(
     function_inputs: Optional[Dict[str, Any]] = None,
     inputs_spec: Optional[type] = None,
     outputs_spec: Optional[type] = None,
-    output_ports: Optional[Dict[str, Any]] = None,
-    input_ports: Optional[Dict[str, Any]] = None,
     metadata: Optional[Dict[str, Any]] = None,
     process_label: Optional[str] = None,
     function_data: dict | None = None,
@@ -126,13 +116,15 @@ def prepare_pyfunction_inputs(
     register_pickle_by_value: bool = False,
     **kwargs: Any,
 ) -> Dict[str, Any]:
-    """Prepare the inputs for PythonJob"""
+    """Prepare the inputs for PyFunction."""
     import types
 
     if function is None and function_data is None:
         raise ValueError("Either function or function_data must be provided")
     if function is not None and function_data is not None:
         raise ValueError("Only one of function or function_data should be provided")
+    if isinstance(function, BaseHandle):
+        function = function._func
     # if function is a function, inspect it and get the source code
     if function is not None:
         if inspect.isfunction(function):
@@ -141,20 +133,13 @@ def prepare_pyfunction_inputs(
             raise NotImplementedError("Built-in functions are not supported yet")
         else:
             raise ValueError("Invalid function type")
-    # outputs
-    if not output_ports:
-        node_outputs = generate_output_sockets(function or (lambda **_: None), outputs=outputs_spec)
-        output_ports = outputs_sockets_to_ports(node_outputs)
-    # inputs
-    if not input_ports:
-        node_inputs = generate_input_sockets(function or (lambda **_: None), inputs=inputs_spec)
-        input_ports = inputs_sockets_to_ports(node_inputs)
-
-    function_data["output_ports"] = output_ports
-    function_data["input_ports"] = input_ports
+    # spec
+    in_spec, out_spec = infer_specs_from_callable(function, inputs=inputs_spec, outputs=outputs_spec)
+    function_data["inputs_spec"] = in_spec.to_dict()
+    function_data["outputs_spec"] = out_spec.to_dict()
     # serialize the kwargs into AiiDA Data
     function_inputs = function_inputs or {}
-    function_inputs = serialize_ports(python_data=function_inputs, port_schema=input_ports, serializers=serializers)
+    function_inputs = serialize_ports(python_data=function_inputs, port_schema=in_spec, serializers=serializers)
     # replace "." with "__dot__" in the keys of a dictionary
     if deserializers:
         deserializers = orm.Dict({k.replace(".", "__dot__"): v for k, v in deserializers.items()})

{aiida_pythonjob-0.3.1 → aiida_pythonjob-0.3.2}/src/aiida_pythonjob/parsers/pythonjob.py

@@ -3,8 +3,9 @@
 import json
 
 from aiida.parsers.parser import Parser
+from node_graph.socket_spec import SocketSpec
 
-from aiida_pythonjob.utils import parse_outputs
+from .utils import parse_outputs
 
 # Map error_type from script.py to exit code label
 ERROR_TYPE_TO_EXIT_CODE = {
@@ -22,8 +23,9 @@ class PythonJobParser(Parser):
     def parse(self, **kwargs):
         import pickle
 
-        # Read output_ports specification
-        self.output_ports = self.node.inputs.function_data.output_ports.get_dict()
+        # Read outputs SocketSpec
+        spec_dict = self.node.inputs.function_data.outputs_spec.get_dict()
+        self.outputs_spec = SocketSpec.from_dict(spec_dict)
 
         # load custom serializers
         if "serializers" in self.node.inputs and self.node.inputs.serializers:
@@ -53,7 +55,7 @@ class PythonJobParser(Parser):
             pass
         except json.JSONDecodeError as exc:
             self.logger.error(f"Error reading _error.json: {exc}")
-            return self.exit_codes.ERROR_INVALID_OUTPUT  # or a different exit code
+            return self.exit_codes.ERROR_INVALID_OUTPUT
 
         # 2) If we reach here, _error.json exists but is empty or doesn't exist at all -> no error recorded
         #    Proceed with parsing results.pickle
@@ -61,9 +63,9 @@ class PythonJobParser(Parser):
             with self.retrieved.base.repository.open("results.pickle", "rb") as handle:
                 results = pickle.load(handle)
 
-                exit_code = parse_outputs(
+                outputs, exit_code = parse_outputs(
                     results,
-                    output_ports=self.output_ports,
+                    output_spec=self.outputs_spec,
                     exit_codes=self.exit_codes,
                     logger=self.logger,
                     serializers=self.serializers,
@@ -72,9 +74,8 @@ class PythonJobParser(Parser):
                     return exit_code
 
                 # Store the outputs
-                for name, port in self.output_ports["ports"].items():
-                    if "value" in port:
-                        self.out(name, port["value"])
+                for name, value in (outputs or {}).items():
+                    self.out(name, value)
 
         except OSError:
             return self.exit_codes.ERROR_READING_OUTPUT_FILE