aiida-pythonjob 0.1.2__tar.gz → 0.1.4__tar.gz

{aiida_pythonjob-0.1.2 → aiida_pythonjob-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aiida-pythonjob
-Version: 0.1.2
+Version: 0.1.4
 Summary: Run Python functions on a remote computer.
 Project-URL: Source, https://github.com/aiidateam/aiida-pythonjob
 Author-email: Xing Wang <xingwang1991@gmail.com>
@@ -34,6 +34,7 @@ Classifier: Natural Language :: English
 Classifier: Programming Language :: Python
 Requires-Python: >=3.9
 Requires-Dist: aiida-core<3,>=2.3
+Requires-Dist: ase
 Requires-Dist: cloudpickle
 Requires-Dist: voluptuous
 Provides-Extra: docs
@@ -55,7 +56,14 @@ Description-Content-Type: text/markdown
 [![codecov](https://codecov.io/gh/aiidateam/aiida-pythonjob/branch/main/graph/badge.svg)](https://codecov.io/gh/aiidateam/aiida-pythonjob)
 [![Docs status](https://readthedocs.org/projects/aiida-pythonjob/badge)](http://aiida-pythonjob.readthedocs.io/)
 
-Efficiently design and manage flexible workflows with AiiDA, featuring an interactive GUI, checkpoints, provenance tracking, error-resistant, and remote execution capabilities.
+`PythonJob` allows users to run Python functions on a remote computer. It is designed to enable users from non-AiiDA communities to run their Python functions remotely and construct workflows with checkpoints, maintaining all data provenance. For instance, users can use ASE's calculator to run a DFT calculation on a remote computer directly.
+
+## Key Features
+
+1. **Remote Execution**: Seamlessly run Python functions on a remote computer.
+2. **User-Friendly**: Designed for users who are not familiar with AiiDA, simplifying the process of remote execution.
+3. **Workflow Management**: Construct workflows using WorkGraph with checkpoints, ensuring that intermediate states and results are preserved.
+4. **Data Provenance**: Maintain comprehensive data provenance, tracking the full history and transformations of data.
 
 
 

{aiida_pythonjob-0.1.2 → aiida_pythonjob-0.1.4}/README.md

@@ -4,7 +4,14 @@
 [![codecov](https://codecov.io/gh/aiidateam/aiida-pythonjob/branch/main/graph/badge.svg)](https://codecov.io/gh/aiidateam/aiida-pythonjob)
 [![Docs status](https://readthedocs.org/projects/aiida-pythonjob/badge)](http://aiida-pythonjob.readthedocs.io/)
 
-Efficiently design and manage flexible workflows with AiiDA, featuring an interactive GUI, checkpoints, provenance tracking, error-resistant, and remote execution capabilities.
+`PythonJob` allows users to run Python functions on a remote computer. It is designed to enable users from non-AiiDA communities to run their Python functions remotely and construct workflows with checkpoints, maintaining all data provenance. For instance, users can use ASE's calculator to run a DFT calculation on a remote computer directly.
+
+## Key Features
+
+1. **Remote Execution**: Seamlessly run Python functions on a remote computer.
+2. **User-Friendly**: Designed for users who are not familiar with AiiDA, simplifying the process of remote execution.
+3. **Workflow Management**: Construct workflows using WorkGraph with checkpoints, ensuring that intermediate states and results are preserved.
+4. **Data Provenance**: Maintain comprehensive data provenance, tracking the full history and transformations of data.
 
 
 

{aiida_pythonjob-0.1.2 → aiida_pythonjob-0.1.4}/docs/gallery/autogen/how_to.py

@@ -6,16 +6,60 @@ How to guides
 
 
 ######################################################################
-# Introduction
-# ------------
+# Preparing inputs for `PythonJob`
+# --------------------------------
+# The `prepare_pythonjob_inputs` function is available for setting up the
+# inputs for a `PythonJob` calculation. This function simplifies the process
+# of preparing and serializing data, and configuring the execution environment.
+#
+# - **Code**: You can specify the `computer` where the job will run, which will
+#   create a `python3@computer` code if it doesn't already exist. Alternatively,
+#   if the code has already been created, you can set the `code` directly.
+#
+# - **Data**: Use standard Python data types for input. The `prepare_pythonjob_inputs`
+#   function handles the conversion to AiiDA data. For serialization:
+#    - The function first searches for an AiiDA data entry point corresponding to the module
+#      and class names (e.g., `ase.atoms.Atoms`).
+#    - If a matching entry point exists, it is used for serialization.
+#    - If no match is found, the data is serialized into binary format using `PickledData`.
+#
+# - **Python Version**: Ensure the Python version on the remote computer matches the local environment.
+#   This is important since pickle is used for data storage and retrieval. Use **conda** to
+#   create and activate a virtual environment with the same Python version. Pass metadata
+#   to the scheduler to activate the environment during the job execution:
+#
+#   .. code-block:: python
+#
+#       metadata = {
+#           "options": {
+#               'custom_scheduler_commands': 'module load anaconda\nconda activate py3.11\n',
+#           }
+#       }
+#
+# --------------------------------------------------
+# Create a conda environment on the remote computer
+# --------------------------------------------------
+# One can use the `create_conda_env` function to create a conda environment
+# on the remote computer. The function will create a conda environment with
+# the specified packages and modules. The function will update the packages
+# if the environment already exists.
+#
+# .. code-block:: python
+#
+#     from aiida_pythonjob.utils import create_conda_env
+#     # create a conda environment on remote computer
+#     create_conda_env(
+#            "merlin6",                # Remote computer
+#            "test_pythonjob",         # Name of the conda environment
+#            modules=["anaconda"],     # Modules to load (e.g., Anaconda)
+#            pip=["numpy", "matplotlib"],  # Python packages to install via pip
+#            conda={                   # Conda-specific settings
+#                "channels": ["conda-forge"],  # Channels to use
+#                "dependencies": ["qe"]       # Conda packages to install
+#            }
+#        )
 #
-# To run this tutorial, you need to load the AiiDA profile.
 #
-
-from aiida import load_profile
-
-load_profile()
-
 
 ######################################################################
 # Default outputs
@@ -24,8 +68,11 @@ load_profile()
 # The default output of the function is `result`. The `PythonJob` task
 # will store the result as one node in the database with the key `result`.
 #
-from aiida.engine import run_get_node  # noqa: E402
-from aiida_pythonjob import PythonJob, prepare_pythonjob_inputs  # noqa: E402
+from aiida import load_profile
+from aiida.engine import run_get_node
+from aiida_pythonjob import PythonJob, prepare_pythonjob_inputs
+
+load_profile()
 
 
 def add(x, y):

{aiida_pythonjob-0.1.2 → aiida_pythonjob-0.1.4}/pyproject.toml

@@ -22,6 +22,7 @@ keywords = ["aiida", "plugin"]
 requires-python = ">=3.9"
 dependencies = [
     "aiida-core>=2.3,<3",
+    "ase",
     "cloudpickle",
     "voluptuous"
 ]
@@ -46,7 +47,14 @@ Source = "https://github.com/aiidateam/aiida-pythonjob"
 
 [project.entry-points."aiida.data"]
 "pythonjob.pickled_data" = "aiida_pythonjob.data.pickled_data:PickledData"
-"pythonjob.pickled_function" = "aiida_pythonjob.data.pickled_function:PickledFunction"
+"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_with_value:List"
+"pythonjob.builtins.dict"="aiida_pythonjob.data.data_with_value:Dict"
+
 
 [project.entry-points."aiida.calculations"]
 "pythonjob.pythonjob" = "aiida_pythonjob.calculations.pythonjob:PythonJob"

{aiida_pythonjob-0.1.2 → aiida_pythonjob-0.1.4}/src/aiida_pythonjob/__init__.py

@@ -1,16 +1,14 @@
 """AiiDA plugin that run Python function on remote computers."""
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 
 from .calculations import PythonJob
-from .data import PickledData, PickledFunction
 from .launch import prepare_pythonjob_inputs
 from .parsers import PythonJobParser
 
 __all__ = (
     "PythonJob",
     "PickledData",
-    "PickledFunction",
     "prepare_pythonjob_inputs",
     "PythonJobParser",
 )

{aiida_pythonjob-0.1.2 → aiida_pythonjob-0.1.4}/src/aiida_pythonjob/calculations/pythonjob.py

@@ -11,6 +11,7 @@ from aiida.common.folders import Folder
 from aiida.engine import CalcJob, CalcJobProcessSpec
 from aiida.orm import (
     Data,
+    Dict,
     FolderData,
     List,
     RemoteData,
@@ -19,8 +20,6 @@ from aiida.orm import (
     to_aiida_type,
 )
 
-from aiida_pythonjob.data.pickled_function import PickledFunction, to_pickled_function
-
 __all__ = ("PythonJob",)
 
 
@@ -42,31 +41,11 @@ class PythonJob(CalcJob):
         :param spec: the calculation job process spec to define.
         """
         super().define(spec)
-        spec.input(
-            "function",
-            valid_type=PickledFunction,
-            serializer=to_pickled_function,
-            required=False,
-        )
-        spec.input(
-            "function_source_code",
-            valid_type=Str,
-            serializer=to_aiida_type,
-            required=False,
-        )
-        spec.input("function_name", valid_type=Str, serializer=to_aiida_type, required=False)
+        spec.input("function_data", 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
         )  # , serializer=serialize_to_aiida_nodes)
-        spec.input(
-            "function_outputs",
-            valid_type=List,
-            default=lambda: List(),
-            required=False,
-            serializer=to_aiida_type,
-            help="The information of the output ports",
-        )
         spec.input(
             "parent_folder",
             valid_type=(RemoteData, FolderData, SinglefileData),
@@ -146,7 +125,7 @@ class PythonJob(CalcJob):
         if "process_label" in self.inputs:
             return self.inputs.process_label.value
         else:
-            data = self.get_function_data()
+            data = self.inputs.function_data.get_dict()
             return f"PythonJob<{data['name']}>"
 
     def on_create(self) -> None:
@@ -155,21 +134,6 @@ class PythonJob(CalcJob):
         super().on_create()
         self.node.label = self._build_process_label()
 
-    def get_function_data(self) -> dict[str, t.Any]:
-        """Get the function data.
-
-        :returns: The function data.
-        """
-        if "function" in self.inputs:
-            metadata = self.inputs.function.metadata
-            metadata["source_code"] = metadata["import_statements"] + "\n" + metadata["source_code_without_decorator"]
-            return metadata
-        else:
-            return {
-                "source_code": self.inputs.function_source_code.value,
-                "name": self.inputs.function_name.value,
-            }
-
     def prepare_for_submission(self, folder: Folder) -> CalcInfo:
         """Prepare the calculation for submission.
 
@@ -192,7 +156,7 @@ class PythonJob(CalcJob):
             parent_folder_name = self.inputs.parent_folder_name.value
         else:
             parent_folder_name = self._DEFAULT_PARENT_FOLDER_NAME
-        function_data = self.get_function_data()
+        function_data = self.inputs.function_data.get_dict()
         # create python script to run the function
         script = f"""
 import pickle

aiida_pythonjob-0.1.4/src/aiida_pythonjob/data/__init__.py

@@ -0,0 +1,4 @@
+from .pickled_data import PickledData
+from .serializer import general_serializer, serialize_to_aiida_nodes
+
+__all__ = ("PickledData", "serialize_to_aiida_nodes", "general_serializer")

aiida_pythonjob-0.1.4/src/aiida_pythonjob/data/atoms.py

@@ -0,0 +1,53 @@
+import numpy as np
+from aiida.orm import Data
+from ase import Atoms
+from ase.db.row import atoms2dict
+
+__all__ = ("AtomsData",)
+
+
+class AtomsData(Data):
+    """Data to represent a ASE Atoms."""
+
+    _cached_atoms = None
+
+    def __init__(self, value=None, **kwargs):
+        """Initialise a `AtomsData` node instance.
+
+        :param value: ASE Atoms instance to initialise the `AtomsData` node from
+        """
+        atoms = value or Atoms()
+        super().__init__(**kwargs)
+        data, keys = self.atoms2dict(atoms)
+        self.base.attributes.set_many(data)
+        self.base.attributes.set("keys", keys)
+
+    @classmethod
+    def atoms2dict(cls, atoms):
+        data = atoms2dict(atoms)
+        data.pop("unique_id")
+        keys = list(data.keys())
+        formula = atoms.get_chemical_formula()
+        data = cls._convert_numpy_to_native(data)
+        data["formula"] = formula
+        data["symbols"] = atoms.get_chemical_symbols()
+        return data, keys
+
+    @classmethod
+    def _convert_numpy_to_native(cls, data):
+        """Convert numpy types to Python native types for JSON compatibility."""
+        for key, value in data.items():
+            if isinstance(value, np.bool_):
+                data[key] = bool(value)
+            elif isinstance(value, np.ndarray):
+                data[key] = value.tolist()
+            elif isinstance(value, np.generic):
+                data[key] = value.item()
+        return data
+
+    @property
+    def value(self):
+        keys = self.base.attributes.get("keys")
+        data = self.base.attributes.get_many(keys)
+        data = dict(zip(keys, data))
+        return Atoms(**data)

aiida_pythonjob-0.1.4/src/aiida_pythonjob/data/data_with_value.py

@@ -0,0 +1,13 @@
+from aiida import orm
+
+
+class Dict(orm.Dict):
+    @property
+    def value(self):
+        return self.get_dict()
+
+
+class List(orm.List):
+    @property
+    def value(self):
+        return self.get_list()

{aiida_pythonjob-0.1.2 → aiida_pythonjob-0.1.4}/src/aiida_pythonjob/data/pickled_data.py

@@ -7,18 +7,6 @@ import cloudpickle
 from aiida import orm
 
 
-class Dict(orm.Dict):
-    @property
-    def value(self):
-        return self.get_dict()
-
-
-class List(orm.List):
-    @property
-    def value(self):
-        return self.get_list()
-
-
 class PickledData(orm.Data):
     """Data to represent a pickled value using cloudpickle."""
 

{aiida_pythonjob-0.1.2 → aiida_pythonjob-0.1.4}/src/aiida_pythonjob/data/serializer.py

@@ -33,12 +33,10 @@ def get_serializer_from_entry_points() -> dict:
         eps.setdefault(key, [])
         eps[key].append(ep)
 
-    # print("Time to load entry points: ", time.time() - ts)
     # check if there are duplicates
     for key, value in eps.items():
         if len(value) > 1:
             if key in serializers:
-                [ep for ep in value if ep.name == serializers[key]]
                 eps[key] = [ep for ep in value if ep.name == serializers[key]]
                 if not eps[key]:
                     raise ValueError(f"Entry point {serializers[key]} not found for {key}")
@@ -105,13 +103,7 @@ def general_serializer(data: Any, check_value=True) -> orm.Node:
                     new_node.store()
                     return new_node
                 except Exception:
-                    # try to serialize the value as a PickledData
-                    try:
-                        new_node = PickledData(data)
-                        new_node.store()
-                        return new_node
-                    except Exception as e:
-                        raise ValueError(f"Error in serializing {ep_key}: {e}")
+                    raise ValueError(f"Error in storing data {ep_key}")
         else:
             # try to serialize the data as a PickledData
             try:

{aiida_pythonjob-0.1.2 → aiida_pythonjob-0.1.4}/src/aiida_pythonjob/launch.py

@@ -1,39 +1,38 @@
+from __future__ import annotations
+
 import inspect
 import os
-from typing import Any, Callable, Dict, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
-from aiida.orm import AbstractCode, Computer, FolderData, List, SinglefileData, Str
+from aiida import orm
 
-from .data.pickled_function import PickledFunction
 from .data.serializer import serialize_to_aiida_nodes
-from .utils import get_or_create_code
+from .utils import build_function_data, get_or_create_code
 
 
 def prepare_pythonjob_inputs(
     function: Optional[Callable[..., Any]] = None,
     function_inputs: Optional[Dict[str, Any]] = None,
-    function_outputs: Optional[Dict[str, Any]] = None,
-    code: Optional[AbstractCode] = None,
+    function_outputs: Optional[List[str | dict]] = None,
+    code: Optional[orm.AbstractCode] = None,
     command_info: Optional[Dict[str, str]] = None,
-    computer: Union[str, Computer] = "localhost",
+    computer: Union[str, orm.Computer] = "localhost",
     metadata: Optional[Dict[str, Any]] = None,
     upload_files: Dict[str, str] = {},
     process_label: Optional[str] = None,
-    pickled_function: Optional[PickledFunction] = None,
+    function_data: dict | None = None,
     **kwargs: Any,
 ) -> Dict[str, Any]:
     pass
     """Prepare the inputs for PythonJob"""
 
-    if function is None and pickled_function is None:
-        raise ValueError("Either function or pickled_function must be provided")
-    if function is not None and pickled_function is not None:
-        raise ValueError("Only one of function or pickled_function should be provided")
-    # if function is a function, convert it to a PickledFunction
+    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 function is a function, inspect it and get the source code
     if function is not None and inspect.isfunction(function):
-        executor = PickledFunction.build_callable(function)
-    if pickled_function is not None:
-        executor = pickled_function
+        function_data = build_function_data(function)
     new_upload_files = {}
     # change the string in the upload files to SingleFileData, or FolderData
     for key, source in upload_files.items():
@@ -42,10 +41,12 @@ def prepare_pythonjob_inputs(
         new_key = key.replace(".", "_dot_")
         if isinstance(source, str):
             if os.path.isfile(source):
-                new_upload_files[new_key] = SinglefileData(file=source)
+                new_upload_files[new_key] = orm.SinglefileData(file=source)
             elif os.path.isdir(source):
-                new_upload_files[new_key] = FolderData(tree=source)
-        elif isinstance(source, (SinglefileData, FolderData)):
+                new_upload_files[new_key] = orm.FolderData(tree=source)
+            else:
+                raise ValueError(f"Invalid upload file path: {source}")
+        elif isinstance(source, (orm.SinglefileData, orm.FolderData)):
             new_upload_files[new_key] = source
         else:
             raise ValueError(f"Invalid upload file type: {type(source)}, {source}")
@@ -54,11 +55,13 @@ def prepare_pythonjob_inputs(
         command_info = command_info or {}
         code = get_or_create_code(computer=computer, **command_info)
     # get the source code of the function
-    function_name = executor["name"]
-    if executor.get("is_pickle", False):
-        function_source_code = executor["import_statements"] + "\n" + executor["source_code_without_decorator"]
+    function_name = function_data["name"]
+    if function_data.get("is_pickle", False):
+        function_source_code = (
+            function_data["import_statements"] + "\n" + function_data["source_code_without_decorator"]
+        )
     else:
-        function_source_code = f"from {executor['module']} import {function_name}"
+        function_source_code = f"from {function_data['module']} import {function_name}"
 
     # serialize the kwargs into AiiDA Data
     function_inputs = function_inputs or {}
@@ -66,12 +69,16 @@ def prepare_pythonjob_inputs(
     # transfer the args to kwargs
     inputs = {
         "process_label": process_label or "PythonJob<{}>".format(function_name),
-        "function_source_code": Str(function_source_code),
-        "function_name": Str(function_name),
+        "function_data": orm.Dict(
+            {
+                "source_code": function_source_code,
+                "name": function_name,
+                "outputs": function_outputs or [],
+            }
+        ),
         "code": code,
         "function_inputs": function_inputs,
         "upload_files": new_upload_files,
-        "function_outputs": List(function_outputs),
         "metadata": metadata or {},
         **kwargs,
     }

{aiida_pythonjob-0.1.2 → aiida_pythonjob-0.1.4}/src/aiida_pythonjob/parsers/pythonjob.py

@@ -22,58 +22,64 @@ class PythonJobParser(Parser):
         """
         import pickle
 
-        function_outputs = self.node.inputs.function_outputs.get_list()
+        function_outputs = self.node.inputs.function_data.get_dict()["outputs"]
         if len(function_outputs) == 0:
             function_outputs = [{"name": "result"}]
         self.output_list = function_outputs
         # first we remove nested outputs, e.g., "add_multiply.add"
         top_level_output_list = [output for output in self.output_list if "." not in output["name"]]
-        exit_code = 0
         try:
             with self.retrieved.base.repository.open("results.pickle", "rb") as handle:
                 results = pickle.load(handle)
                 if isinstance(results, tuple):
                     if len(top_level_output_list) != len(results):
-                        self.exit_codes.ERROR_RESULT_OUTPUT_MISMATCH
+                        return self.exit_codes.ERROR_RESULT_OUTPUT_MISMATCH
                     for i in range(len(top_level_output_list)):
                         top_level_output_list[i]["value"] = self.serialize_output(results[i], top_level_output_list[i])
-                elif isinstance(results, dict) and len(top_level_output_list) > 1:
+                elif isinstance(results, dict):
                     # pop the exit code if it exists
                     exit_code = results.pop("exit_code", 0)
-                    for output in top_level_output_list:
-                        if output.get("required", False):
+                    if exit_code:
+                        if isinstance(exit_code, dict):
+                            exit_code = ExitCode(exit_code["status"], exit_code["message"])
+                        elif isinstance(exit_code, int):
+                            exit_code = ExitCode(exit_code)
+                        return exit_code
+                    if len(top_level_output_list) == 1:
+                        # if output name in results, use it
+                        if top_level_output_list[0]["name"] in results:
+                            top_level_output_list[0]["value"] = self.serialize_output(
+                                results.pop(top_level_output_list[0]["name"]),
+                                top_level_output_list[0],
+                            )
+                            # if there are any remaining results, raise an warning
+                            if len(results) > 0:
+                                self.logger.warning(
+                                    f"Found extra results that are not included in the output: {results.keys()}"
+                                )
+                        # otherwise, we assume the results is the output
+                        else:
+                            top_level_output_list[0]["value"] = self.serialize_output(results, top_level_output_list[0])
+                    elif len(top_level_output_list) > 1:
+                        for output in top_level_output_list:
                             if output["name"] not in results:
-                                self.exit_codes.ERROR_MISSING_OUTPUT
-                        output["value"] = self.serialize_output(results.pop(output["name"]), output)
-                    # if there are any remaining results, raise an warning
-                    if results:
-                        self.logger.warning(
-                            f"Found extra results that are not included in the output: {results.keys()}"
-                        )
-                elif isinstance(results, dict) and len(top_level_output_list) == 1:
-                    exit_code = results.pop("exit_code", 0)
-                    # if output name in results, use it
-                    if top_level_output_list[0]["name"] in results:
-                        top_level_output_list[0]["value"] = self.serialize_output(
-                            results[top_level_output_list[0]["name"]],
-                            top_level_output_list[0],
-                        )
-                    # otherwise, we assume the results is the output
-                    else:
-                        top_level_output_list[0]["value"] = self.serialize_output(results, top_level_output_list[0])
+                                if output.get("required", True):
+                                    return self.exit_codes.ERROR_MISSING_OUTPUT
+                            else:
+                                output["value"] = self.serialize_output(results.pop(output["name"]), output)
+                        # if there are any remaining results, raise an warning
+                        if len(results) > 0:
+                            self.logger.warning(
+                                f"Found extra results that are not included in the output: {results.keys()}"
+                            )
+
                 elif len(top_level_output_list) == 1:
-                    # otherwise, we assume the results is the output
+                    # otherwise it returns a single value, we assume the results is the output
                     top_level_output_list[0]["value"] = self.serialize_output(results, top_level_output_list[0])
                 else:
-                    raise ValueError("The number of results does not match the number of outputs.")
+                    return self.exit_codes.ERROR_RESULT_OUTPUT_MISMATCH
                 for output in top_level_output_list:
                     self.out(output["name"], output["value"])
-                if exit_code:
-                    if isinstance(exit_code, dict):
-                        exit_code = ExitCode(exit_code["status"], exit_code["message"])
-                    elif isinstance(exit_code, int):
-                        exit_code = ExitCode(exit_code)
-                    return exit_code
         except OSError:
             return self.exit_codes.ERROR_READING_OUTPUT_FILE
         except ValueError as exception: