executorlib 1.0.0__tar.gz → 1.1.0__tar.gz

{executorlib-1.0.0/executorlib.egg-info → executorlib-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: executorlib
-Version: 1.0.0
+Version: 1.1.0
 Summary: Up-scale python functions for high performance computing (HPC) with executorlib.
 Author-email: Jan Janssen <janssen@lanl.gov>
 License: BSD 3-Clause License
@@ -51,7 +51,7 @@ Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cloudpickle<=3.1.1,>=2.0.0
-Requires-Dist: pyzmq<=26.3.0,>=25.0.0
+Requires-Dist: pyzmq<=26.4.0,>=25.0.0
 Provides-Extra: cache
 Requires-Dist: h5py<=3.13.0,>=3.6.0; extra == "cache"
 Provides-Extra: graph
@@ -232,6 +232,8 @@ as hierarchical job scheduler within the allocations.
   * [Pull Requests](https://executorlib.readthedocs.io/en/latest/4-developer.html#pull-requests)
   * [License](https://executorlib.readthedocs.io/en/latest/4-developer.html#license)
   * [Modules](https://executorlib.readthedocs.io/en/latest/4-developer.html#modules)
+  * [Interface Class Hierarchy](https://executorlib.readthedocs.io/en/latest/4-developer.html#interface-class-hierarchy)
   * [Communication](https://executorlib.readthedocs.io/en/latest/4-developer.html#communication)
+  * [External Libraries](https://executorlib.readthedocs.io/en/latest/4-developer.html#external-libraries)
   * [External Executables](https://executorlib.readthedocs.io/en/latest/4-developer.html#external-executables)
 * [Interface](https://executorlib.readthedocs.io/en/latest/api.html)

{executorlib-1.0.0 → executorlib-1.1.0}/README.md

@@ -156,6 +156,8 @@ as hierarchical job scheduler within the allocations.
   * [Pull Requests](https://executorlib.readthedocs.io/en/latest/4-developer.html#pull-requests)
   * [License](https://executorlib.readthedocs.io/en/latest/4-developer.html#license)
   * [Modules](https://executorlib.readthedocs.io/en/latest/4-developer.html#modules)
+  * [Interface Class Hierarchy](https://executorlib.readthedocs.io/en/latest/4-developer.html#interface-class-hierarchy)
   * [Communication](https://executorlib.readthedocs.io/en/latest/4-developer.html#communication)
+  * [External Libraries](https://executorlib.readthedocs.io/en/latest/4-developer.html#external-libraries)
   * [External Executables](https://executorlib.readthedocs.io/en/latest/4-developer.html#external-executables)
 * [Interface](https://executorlib.readthedocs.io/en/latest/api.html)

{executorlib-1.0.0 → executorlib-1.1.0}/executorlib/__init__.py

@@ -1,15 +1,17 @@
 from executorlib._version import get_versions as _get_versions
-from executorlib.interfaces.flux import (
+from executorlib.executor.flux import (
     FluxClusterExecutor,
     FluxJobExecutor,
 )
-from executorlib.interfaces.single import SingleNodeExecutor
-from executorlib.interfaces.slurm import (
+from executorlib.executor.single import SingleNodeExecutor
+from executorlib.executor.slurm import (
     SlurmClusterExecutor,
     SlurmJobExecutor,
 )
+from executorlib.standalone.cache import get_cache_data
 
 __all__: list[str] = [
+    "get_cache_data",
     "FluxJobExecutor",
     "FluxClusterExecutor",
     "SingleNodeExecutor",
@@ -17,11 +19,4 @@ __all__: list[str] = [
     "SlurmClusterExecutor",
 ]
 
-try:
-    from executorlib.standalone.hdf import get_cache_data
-except ImportError:
-    pass
-else:
-    __all__ += ["get_cache_data"]
-
 __version__ = _get_versions()["version"]

{executorlib-1.0.0 → executorlib-1.1.0}/executorlib/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-03-29T11:38:43+0100",
+ "date": "2025-04-26T14:56:26+0200",
  "dirty": true,
  "error": null,
- "full-revisionid": "5de07acc29643a232dbc50303435a399df53cf3b",
- "version": "1.0.0"
+ "full-revisionid": "093d1fd613b10c43f4ebc4387d2b1c3dbfebf0c0",
+ "version": "1.1.0"
 }
 '''  # END VERSION_JSON
 

{executorlib-1.0.0 → executorlib-1.1.0}/executorlib/backend/cache_parallel.py

@@ -4,7 +4,10 @@ import time
 
 import cloudpickle
 
-from executorlib.cache.backend import backend_load_file, backend_write_file
+from executorlib.task_scheduler.file.backend import (
+    backend_load_file,
+    backend_write_file,
+)
 
 
 def main() -> None:

{executorlib-1.0.0 → executorlib-1.1.0}/executorlib/backend/cache_serial.py

@@ -1,6 +1,6 @@
 import sys
 
-from executorlib.cache.backend import backend_execute_task_in_file
+from executorlib.task_scheduler.file.backend import backend_execute_task_in_file
 
 if __name__ == "__main__":
     backend_execute_task_in_file(file_name=sys.argv[1])

executorlib-1.1.0/executorlib/executor/base.py

@@ -0,0 +1,118 @@
+import queue
+from concurrent.futures import (
+    Executor as FutureExecutor,
+)
+from concurrent.futures import (
+    Future,
+)
+from typing import Callable, Optional
+
+from executorlib.task_scheduler.base import TaskSchedulerBase
+
+
+class ExecutorBase(FutureExecutor):
+    """
+    Interface class for the executor.
+
+    Args:
+        executor (TaskSchedulerBase): internal executor
+    """
+
+    def __init__(self, executor: TaskSchedulerBase):
+        self._task_scheduler = executor
+
+    @property
+    def max_workers(self) -> Optional[int]:
+        return self._task_scheduler.max_workers
+
+    @max_workers.setter
+    def max_workers(self, max_workers: int):
+        self._task_scheduler.max_workers = max_workers
+
+    @property
+    def info(self) -> Optional[dict]:
+        """
+        Get the information about the executor.
+
+        Returns:
+            Optional[dict]: Information about the executor.
+        """
+        return self._task_scheduler.info
+
+    @property
+    def future_queue(self) -> Optional[queue.Queue]:
+        """
+        Get the future queue.
+
+        Returns:
+            queue.Queue: The future queue.
+        """
+        return self._task_scheduler.future_queue
+
+    def submit(  # type: ignore
+        self,
+        fn: Callable,
+        /,
+        *args,
+        resource_dict: Optional[dict] = None,
+        **kwargs,
+    ) -> Future:
+        """
+        Submits a callable to be executed with the given arguments.
+
+        Schedules the callable to be executed as fn(*args, **kwargs) and returns
+        a Future instance representing the execution of the callable.
+
+        Args:
+            fn (callable): function to submit for execution
+            args: arguments for the submitted function
+            kwargs: keyword arguments for the submitted function
+            resource_dict (dict): resource dictionary, which defines the resources used for the execution of the
+                                  function. Example resource dictionary: {
+                                      cores: 1,
+                                      threads_per_core: 1,
+                                      gpus_per_worker: 0,
+                                      oversubscribe: False,
+                                      cwd: None,
+                                      executor: None,
+                                      hostname_localhost: False,
+                                  }
+
+        Returns:
+            Future: A Future representing the given call.
+        """
+        return self._task_scheduler.submit(
+            *([fn] + list(args)), resource_dict=resource_dict, **kwargs
+        )
+
+    def shutdown(self, wait: bool = True, *, cancel_futures: bool = False):
+        """
+        Clean-up the resources associated with the Executor.
+
+        It is safe to call this method several times. Otherwise, no other
+        methods can be called after this one.
+
+        Args:
+            wait (bool): If True then shutdown will not return until all running
+                futures have finished executing and the resources used by the
+                parallel_executors have been reclaimed.
+            cancel_futures (bool): If True then shutdown will cancel all pending
+                futures. Futures that are completed or running will not be
+                cancelled.
+        """
+        self._task_scheduler.shutdown(wait=wait, cancel_futures=cancel_futures)
+
+    def __len__(self) -> int:
+        """
+        Get the length of the executor.
+
+        Returns:
+            int: The length of the executor.
+        """
+        return len(self._task_scheduler)
+
+    def __exit__(self, *args, **kwargs) -> None:
+        """
+        Exit method called when exiting the context manager.
+        """
+        self._task_scheduler.__exit__(*args, **kwargs)

{executorlib-1.0.0/executorlib/interfaces → executorlib-1.1.0/executorlib/executor}/flux.py

@@ -1,9 +1,6 @@
-import contextlib
 from typing import Callable, Optional, Union
 
-from executorlib.interactive.blockallocation import BlockAllocationExecutor
-from executorlib.interactive.dependency import DependencyExecutor
-from executorlib.interactive.onetoone import OneTaskPerProcessExecutor
+from executorlib.executor.base import ExecutorBase
 from executorlib.standalone.inputcheck import (
     check_command_line_argument_lst,
     check_init_function,
@@ -13,15 +10,14 @@ from executorlib.standalone.inputcheck import (
     check_refresh_rate,
     validate_number_of_cores,
 )
-
-with contextlib.suppress(ImportError):
-    from executorlib.interactive.fluxspawner import (
-        FluxPythonSpawner,
-        validate_max_workers,
-    )
+from executorlib.task_scheduler.interactive.blockallocation import (
+    BlockAllocationTaskScheduler,
+)
+from executorlib.task_scheduler.interactive.dependency import DependencyTaskScheduler
+from executorlib.task_scheduler.interactive.onetoone import OneProcessTaskScheduler
 
 
-class FluxJobExecutor:
+class FluxJobExecutor(ExecutorBase):
     """
     The executorlib.Executor leverages either the message passing interface (MPI), the SLURM workload manager or
     preferable the flux framework for distributing python functions within a given resource allocation. In contrast to
@@ -69,7 +65,7 @@ class FluxJobExecutor:
     Examples:
         ```
         >>> import numpy as np
-        >>> from executorlib.interfaces.flux import FluxJobExecutor
+        >>> from executorlib.executor.flux import FluxJobExecutor
         >>>
         >>> def calc(i, j, k):
         >>>     from mpi4py import MPI
@@ -104,27 +100,6 @@ class FluxJobExecutor:
         refresh_rate: float = 0.01,
         plot_dependency_graph: bool = False,
         plot_dependency_graph_filename: Optional[str] = None,
-    ):
-        # Use __new__() instead of __init__(). This function is only implemented to enable auto-completion.
-        pass
-
-    def __new__(
-        cls,
-        max_workers: Optional[int] = None,
-        cache_directory: Optional[str] = None,
-        max_cores: Optional[int] = None,
-        resource_dict: Optional[dict] = None,
-        flux_executor=None,
-        flux_executor_pmi_mode: Optional[str] = None,
-        flux_executor_nesting: bool = False,
-        flux_log_files: bool = False,
-        hostname_localhost: Optional[bool] = None,
-        block_allocation: bool = False,
-        init_function: Optional[Callable] = None,
-        disable_dependencies: bool = False,
-        refresh_rate: float = 0.01,
-        plot_dependency_graph: bool = False,
-        plot_dependency_graph_filename: Optional[str] = None,
     ):
         """
         Instead of returning a executorlib.Executor object this function returns either a executorlib.mpi.PyMPIExecutor,
@@ -186,7 +161,31 @@ class FluxJobExecutor:
             {k: v for k, v in default_resource_dict.items() if k not in resource_dict}
         )
         if not disable_dependencies:
-            return DependencyExecutor(
+            super().__init__(
+                executor=DependencyTaskScheduler(
+                    executor=create_flux_executor(
+                        max_workers=max_workers,
+                        cache_directory=cache_directory,
+                        max_cores=max_cores,
+                        resource_dict=resource_dict,
+                        flux_executor=flux_executor,
+                        flux_executor_pmi_mode=flux_executor_pmi_mode,
+                        flux_executor_nesting=flux_executor_nesting,
+                        flux_log_files=flux_log_files,
+                        hostname_localhost=hostname_localhost,
+                        block_allocation=block_allocation,
+                        init_function=init_function,
+                    ),
+                    max_cores=max_cores,
+                    refresh_rate=refresh_rate,
+                    plot_dependency_graph=plot_dependency_graph,
+                    plot_dependency_graph_filename=plot_dependency_graph_filename,
+                )
+            )
+        else:
+            check_plot_dependency_graph(plot_dependency_graph=plot_dependency_graph)
+            check_refresh_rate(refresh_rate=refresh_rate)
+            super().__init__(
                 executor=create_flux_executor(
                     max_workers=max_workers,
                     cache_directory=cache_directory,
@@ -199,31 +198,11 @@ class FluxJobExecutor:
                     hostname_localhost=hostname_localhost,
                     block_allocation=block_allocation,
                     init_function=init_function,
-                ),
-                max_cores=max_cores,
-                refresh_rate=refresh_rate,
-                plot_dependency_graph=plot_dependency_graph,
-                plot_dependency_graph_filename=plot_dependency_graph_filename,
-            )
-        else:
-            check_plot_dependency_graph(plot_dependency_graph=plot_dependency_graph)
-            check_refresh_rate(refresh_rate=refresh_rate)
-            return create_flux_executor(
-                max_workers=max_workers,
-                cache_directory=cache_directory,
-                max_cores=max_cores,
-                resource_dict=resource_dict,
-                flux_executor=flux_executor,
-                flux_executor_pmi_mode=flux_executor_pmi_mode,
-                flux_executor_nesting=flux_executor_nesting,
-                flux_log_files=flux_log_files,
-                hostname_localhost=hostname_localhost,
-                block_allocation=block_allocation,
-                init_function=init_function,
+                )
             )
 
 
-class FluxClusterExecutor:
+class FluxClusterExecutor(ExecutorBase):
     """
     The executorlib.Executor leverages either the message passing interface (MPI), the SLURM workload manager or
     preferable the flux framework for distributing python functions within a given resource allocation. In contrast to
@@ -267,7 +246,7 @@ class FluxClusterExecutor:
     Examples:
         ```
         >>> import numpy as np
-        >>> from executorlib.interfaces.flux import FluxClusterExecutor
+        >>> from executorlib.executor.flux import FluxClusterExecutor
         >>>
         >>> def calc(i, j, k):
         >>>     from mpi4py import MPI
@@ -299,24 +278,6 @@ class FluxClusterExecutor:
         refresh_rate: float = 0.01,
         plot_dependency_graph: bool = False,
         plot_dependency_graph_filename: Optional[str] = None,
-    ):
-        # Use __new__() instead of __init__(). This function is only implemented to enable auto-completion.
-        pass
-
-    def __new__(
-        cls,
-        max_workers: Optional[int] = None,
-        cache_directory: Optional[str] = None,
-        max_cores: Optional[int] = None,
-        resource_dict: Optional[dict] = None,
-        pysqa_config_directory: Optional[str] = None,
-        hostname_localhost: Optional[bool] = None,
-        block_allocation: bool = False,
-        init_function: Optional[Callable] = None,
-        disable_dependencies: bool = False,
-        refresh_rate: float = 0.01,
-        plot_dependency_graph: bool = False,
-        plot_dependency_graph_filename: Optional[str] = None,
     ):
         """
         Instead of returning a executorlib.Executor object this function returns either a executorlib.mpi.PyMPIExecutor,
@@ -375,43 +336,49 @@ class FluxClusterExecutor:
             {k: v for k, v in default_resource_dict.items() if k not in resource_dict}
         )
         if not plot_dependency_graph:
-            from executorlib.cache.executor import create_file_executor
-
-            return create_file_executor(
-                max_workers=max_workers,
-                backend="flux_submission",
-                max_cores=max_cores,
-                cache_directory=cache_directory,
-                resource_dict=resource_dict,
-                flux_executor=None,
-                flux_executor_pmi_mode=None,
-                flux_executor_nesting=False,
-                flux_log_files=False,
-                pysqa_config_directory=pysqa_config_directory,
-                hostname_localhost=hostname_localhost,
-                block_allocation=block_allocation,
-                init_function=init_function,
-                disable_dependencies=disable_dependencies,
+            from executorlib.task_scheduler.file.task_scheduler import (
+                create_file_executor,
             )
-        else:
-            return DependencyExecutor(
-                executor=create_flux_executor(
+
+            super().__init__(
+                executor=create_file_executor(
                     max_workers=max_workers,
-                    cache_directory=cache_directory,
+                    backend="flux_submission",
                     max_cores=max_cores,
+                    cache_directory=cache_directory,
                     resource_dict=resource_dict,
                     flux_executor=None,
                     flux_executor_pmi_mode=None,
                     flux_executor_nesting=False,
                     flux_log_files=False,
+                    pysqa_config_directory=pysqa_config_directory,
                     hostname_localhost=hostname_localhost,
                     block_allocation=block_allocation,
                     init_function=init_function,
-                ),
-                max_cores=max_cores,
-                refresh_rate=refresh_rate,
-                plot_dependency_graph=plot_dependency_graph,
-                plot_dependency_graph_filename=plot_dependency_graph_filename,
+                    disable_dependencies=disable_dependencies,
+                )
+            )
+        else:
+            super().__init__(
+                executor=DependencyTaskScheduler(
+                    executor=create_flux_executor(
+                        max_workers=max_workers,
+                        cache_directory=cache_directory,
+                        max_cores=max_cores,
+                        resource_dict=resource_dict,
+                        flux_executor=None,
+                        flux_executor_pmi_mode=None,
+                        flux_executor_nesting=False,
+                        flux_log_files=False,
+                        hostname_localhost=hostname_localhost,
+                        block_allocation=block_allocation,
+                        init_function=init_function,
+                    ),
+                    max_cores=max_cores,
+                    refresh_rate=refresh_rate,
+                    plot_dependency_graph=plot_dependency_graph,
+                    plot_dependency_graph_filename=plot_dependency_graph_filename,
+                )
             )
 
 
@@ -427,7 +394,7 @@ def create_flux_executor(
     hostname_localhost: Optional[bool] = None,
     block_allocation: bool = False,
     init_function: Optional[Callable] = None,
-) -> Union[OneTaskPerProcessExecutor, BlockAllocationExecutor]:
+) -> Union[OneProcessTaskScheduler, BlockAllocationTaskScheduler]:
     """
     Create a flux executor
 
@@ -466,6 +433,11 @@ def create_flux_executor(
     Returns:
         InteractiveStepExecutor/ InteractiveExecutor
     """
+    from executorlib.task_scheduler.interactive.fluxspawner import (
+        FluxPythonSpawner,
+        validate_max_workers,
+    )
+
     if resource_dict is None:
         resource_dict = {}
     cores_per_worker = resource_dict.get("cores", 1)
@@ -498,13 +470,13 @@ def create_flux_executor(
             cores=cores_per_worker,
             threads_per_core=resource_dict.get("threads_per_core", 1),
         )
-        return BlockAllocationExecutor(
+        return BlockAllocationTaskScheduler(
             max_workers=max_workers,
             executor_kwargs=resource_dict,
             spawner=FluxPythonSpawner,
         )
     else:
-        return OneTaskPerProcessExecutor(
+        return OneProcessTaskScheduler(
             max_cores=max_cores,
             max_workers=max_workers,
             executor_kwargs=resource_dict,

{executorlib-1.0.0/executorlib/interfaces → executorlib-1.1.0/executorlib/executor}/single.py

@@ -1,8 +1,6 @@
 from typing import Callable, Optional, Union
 
-from executorlib.interactive.blockallocation import BlockAllocationExecutor
-from executorlib.interactive.dependency import DependencyExecutor
-from executorlib.interactive.onetoone import OneTaskPerProcessExecutor
+from executorlib.executor.base import ExecutorBase
 from executorlib.standalone.inputcheck import (
     check_command_line_argument_lst,
     check_gpus_per_worker,
@@ -12,9 +10,14 @@ from executorlib.standalone.inputcheck import (
     validate_number_of_cores,
 )
 from executorlib.standalone.interactive.spawner import MpiExecSpawner
+from executorlib.task_scheduler.interactive.blockallocation import (
+    BlockAllocationTaskScheduler,
+)
+from executorlib.task_scheduler.interactive.dependency import DependencyTaskScheduler
+from executorlib.task_scheduler.interactive.onetoone import OneProcessTaskScheduler
 
 
-class SingleNodeExecutor:
+class SingleNodeExecutor(ExecutorBase):
     """
     The executorlib.Executor leverages either the message passing interface (MPI), the SLURM workload manager or
     preferable the flux framework for distributing python functions within a given resource allocation. In contrast to
@@ -57,7 +60,7 @@ class SingleNodeExecutor:
     Examples:
         ```
         >>> import numpy as np
-        >>> from executorlib.interfaces.single import SingleNodeExecutor
+        >>> from executorlib.executor.single import SingleNodeExecutor
         >>>
         >>> def calc(i, j, k):
         >>>     from mpi4py import MPI
@@ -88,23 +91,6 @@ class SingleNodeExecutor:
         refresh_rate: float = 0.01,
         plot_dependency_graph: bool = False,
         plot_dependency_graph_filename: Optional[str] = None,
-    ):
-        # Use __new__() instead of __init__(). This function is only implemented to enable auto-completion.
-        pass
-
-    def __new__(
-        cls,
-        max_workers: Optional[int] = None,
-        cache_directory: Optional[str] = None,
-        max_cores: Optional[int] = None,
-        resource_dict: Optional[dict] = None,
-        hostname_localhost: Optional[bool] = None,
-        block_allocation: bool = False,
-        init_function: Optional[Callable] = None,
-        disable_dependencies: bool = False,
-        refresh_rate: float = 0.01,
-        plot_dependency_graph: bool = False,
-        plot_dependency_graph_filename: Optional[str] = None,
     ):
         """
         Instead of returning a executorlib.Executor object this function returns either a executorlib.mpi.PyMPIExecutor,
@@ -162,7 +148,27 @@ class SingleNodeExecutor:
             {k: v for k, v in default_resource_dict.items() if k not in resource_dict}
         )
         if not disable_dependencies:
-            return DependencyExecutor(
+            super().__init__(
+                executor=DependencyTaskScheduler(
+                    executor=create_single_node_executor(
+                        max_workers=max_workers,
+                        cache_directory=cache_directory,
+                        max_cores=max_cores,
+                        resource_dict=resource_dict,
+                        hostname_localhost=hostname_localhost,
+                        block_allocation=block_allocation,
+                        init_function=init_function,
+                    ),
+                    max_cores=max_cores,
+                    refresh_rate=refresh_rate,
+                    plot_dependency_graph=plot_dependency_graph,
+                    plot_dependency_graph_filename=plot_dependency_graph_filename,
+                )
+            )
+        else:
+            check_plot_dependency_graph(plot_dependency_graph=plot_dependency_graph)
+            check_refresh_rate(refresh_rate=refresh_rate)
+            super().__init__(
                 executor=create_single_node_executor(
                     max_workers=max_workers,
                     cache_directory=cache_directory,
@@ -171,23 +177,7 @@ class SingleNodeExecutor:
                     hostname_localhost=hostname_localhost,
                     block_allocation=block_allocation,
                     init_function=init_function,
-                ),
-                max_cores=max_cores,
-                refresh_rate=refresh_rate,
-                plot_dependency_graph=plot_dependency_graph,
-                plot_dependency_graph_filename=plot_dependency_graph_filename,
-            )
-        else:
-            check_plot_dependency_graph(plot_dependency_graph=plot_dependency_graph)
-            check_refresh_rate(refresh_rate=refresh_rate)
-            return create_single_node_executor(
-                max_workers=max_workers,
-                cache_directory=cache_directory,
-                max_cores=max_cores,
-                resource_dict=resource_dict,
-                hostname_localhost=hostname_localhost,
-                block_allocation=block_allocation,
-                init_function=init_function,
+                )
             )
 
 
@@ -199,7 +189,7 @@ def create_single_node_executor(
     hostname_localhost: Optional[bool] = None,
     block_allocation: bool = False,
     init_function: Optional[Callable] = None,
-) -> Union[OneTaskPerProcessExecutor, BlockAllocationExecutor]:
+) -> Union[OneProcessTaskScheduler, BlockAllocationTaskScheduler]:
     """
     Create a single node executor
 
@@ -253,7 +243,7 @@ def create_single_node_executor(
         del resource_dict["slurm_cmd_args"]
     if block_allocation:
         resource_dict["init_function"] = init_function
-        return BlockAllocationExecutor(
+        return BlockAllocationTaskScheduler(
             max_workers=validate_number_of_cores(
                 max_cores=max_cores,
                 max_workers=max_workers,
@@ -264,7 +254,7 @@ def create_single_node_executor(
             spawner=MpiExecSpawner,
         )
     else:
-        return OneTaskPerProcessExecutor(
+        return OneProcessTaskScheduler(
             max_cores=max_cores,
             max_workers=max_workers,
             executor_kwargs=resource_dict,