executorlib 1.9.3__py3-none-any.whl → 1.9.4__py3-none-any.whl

executorlib/_version.py

@@ -1,5 +1,6 @@
-# file generated by setuptools-scm
+# file generated by vcs-versioning
 # don't change, don't track in version control
+from __future__ import annotations
 
 __all__ = [
     "__version__",
@@ -10,25 +11,14 @@ __all__ = [
     "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_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
 
-__version__ = version = '1.9.3'
-__version_tuple__ = version_tuple = (1, 9, 3)
+__version__ = version = '1.9.4'
+__version_tuple__ = version_tuple = (1, 9, 4)
 
 __commit_id__ = commit_id = None

executorlib/executor/base.py

@@ -25,10 +25,22 @@ class BaseExecutor(FutureExecutor, ABC):
 
     @property
     def max_workers(self) -> Optional[int]:
+        """
+        Return the number of parallel workers configured for this executor.
+
+        Returns:
+            Optional[int]: The maximum number of parallel workers, or None if unconstrained.
+        """
         return self._task_scheduler.max_workers
 
     @max_workers.setter
     def max_workers(self, max_workers: int):
+        """
+        Set the number of parallel workers on the underlying task scheduler.
+
+        Args:
+            max_workers (int): New maximum number of parallel workers.
+        """
         self._task_scheduler.max_workers = max_workers
 
     @property

executorlib/standalone/batched.py

@@ -1,27 +1,39 @@
 from concurrent.futures import Future
 
 
-def batched_futures(lst: list[Future], skip_lst: list[list], n: int) -> list[list]:
+def batched_futures(
+    lst: list[Future], nested_skip_lst: list[Future[list]], n: int
+) -> tuple[bool, list[Future]]:
     """
     Batch n completed future objects. If the number of completed futures is smaller than n and the end of the batch is
-    not reached yet, then an empty list is returned. If n future objects are done, which are not included in the skip_lst
+    not reached yet, then an empty list is returned. If n future objects are done, which are not included in the skip_set
     then they are returned as batch.
 
     Args:
         lst (list): list of all future objects
-        skip_lst (list): list of previous batches of future objects
+        nested_skip_lst (list): list of future objects, which contain the list of future objects ids which should be skipped for the batch
         n (int): batch size
 
     Returns:
         list: results of the batched futures
     """
-    skipped_elements_lst = [item for items in skip_lst for item in items]
+    skip_set = {fid for f in nested_skip_lst for fid in f.result()}
 
     done_lst = []
-    n_expected = min(n, len(lst) - len(skipped_elements_lst))
+    failed_lst = []
+    n_expected = min(n, len(lst) - len(skip_set))
     for v in lst:
-        if v.done() and v.result() not in skipped_elements_lst:
-            done_lst.append(v.result())
-        if len(done_lst) == n_expected:
-            return done_lst
-    return []
+        if id(v) not in skip_set and v.done():
+            if v.exception() is not None:
+                failed_lst.append(v)
+            elif id(v) not in skip_set and v.done():
+                done_lst.append(v)
+                if len(done_lst) == n_expected:
+                    return True, done_lst
+    if (len(lst) - len(skip_set)) == len(failed_lst):
+        return (
+            False,
+            failed_lst[:n_expected],
+        )  # raise the exception only after all futures have failed
+    else:
+        return True, []

executorlib/standalone/command.py

@@ -153,7 +153,7 @@ def generate_slurm_command(
         command_prepend_lst += ["--mpi=" + pmi_mode]
     if num_nodes is not None:
         command_prepend_lst += ["-N", str(num_nodes)]
-    if threads_per_core > 1:
+    if threads_per_core >= 1:
         command_prepend_lst += ["--cpus-per-task=" + str(threads_per_core)]
     if gpus_per_core > 0:
         command_prepend_lst += ["--gpus-per-task=" + str(gpus_per_core)]

executorlib/standalone/hdf.py

@@ -1,3 +1,4 @@
+import contextlib
 import os
 from concurrent.futures import Future
 from time import sleep
@@ -34,10 +35,11 @@ def dump(file_name: Optional[str], data_dict: dict) -> None:
         with h5py.File(file_name_abs, "a") as fname:
             for data_key, data_value in data_dict.items():
                 if data_key in group_dict:
-                    fname.create_dataset(
-                        name="/" + group_dict[data_key],
-                        data=np.void(cloudpickle.dumps(data_value)),
-                    )
+                    with contextlib.suppress(ValueError):
+                        fname.create_dataset(
+                            name="/" + group_dict[data_key],
+                            data=np.void(cloudpickle.dumps(data_value)),
+                        )
 
 
 def load(file_name: str) -> dict:
@@ -171,7 +173,11 @@ def get_cache_files(cache_directory: str) -> list[str]:
     file_lst = []
     cache_directory_abs = os.path.abspath(cache_directory)
     for dirpath, _, filenames in os.walk(cache_directory_abs):
-        file_lst += [os.path.join(dirpath, f) for f in filenames if f.endswith("_o.h5")]
+        file_lst += [
+            os.path.join(dirpath, f)
+            for f in filenames
+            if f.endswith("_o.h5") or f.endswith("_i.h5")
+        ]
     return file_lst
 
 

executorlib/standalone/inputcheck.py

@@ -141,6 +141,16 @@ def check_init_function(
 def check_max_workers_and_cores(
     max_workers: Optional[int], max_cores: Optional[int]
 ) -> None:
+    """
+    Check that neither max_workers nor max_cores is set when using a pysqa-based backend.
+
+    Args:
+        max_workers (int, optional): Maximum number of workers.
+        max_cores (int, optional): Maximum number of cores.
+
+    Raises:
+        ValueError: If max_workers or max_cores is not None.
+    """
     if max_workers is not None:
         raise ValueError(
             "The number of workers cannot be controlled with the pysqa based backend."
@@ -152,6 +162,15 @@ def check_max_workers_and_cores(
 
 
 def check_hostname_localhost(hostname_localhost: Optional[bool]) -> None:
+    """
+    Check that hostname_localhost is not set when using a pysqa-based backend.
+
+    Args:
+        hostname_localhost (bool, optional): Flag to use localhost for ZMQ connections.
+
+    Raises:
+        ValueError: If hostname_localhost is not None.
+    """
     if hostname_localhost is not None:
         raise ValueError(
             "The option to connect to hosts based on their hostname is not available with the pysqa based backend."
@@ -159,6 +178,16 @@ def check_hostname_localhost(hostname_localhost: Optional[bool]) -> None:
 
 
 def check_restart_limit(restart_limit: int, block_allocation: bool = True) -> None:
+    """
+    Check that restart_limit is only used together with block_allocation.
+
+    Args:
+        restart_limit (int): Maximum number of times a worker process may be restarted.
+        block_allocation (bool): Whether block allocation is enabled. Defaults to True.
+
+    Raises:
+        ValueError: If restart_limit is non-zero and block_allocation is False.
+    """
     if not block_allocation and restart_limit != 0:
         raise ValueError(
             "The option to specify a restart limit for worker processes is only available with block_allocation=True."
@@ -166,6 +195,15 @@ def check_restart_limit(restart_limit: int, block_allocation: bool = True) -> No
 
 
 def check_pmi_mode(pmi_mode: Optional[str]) -> None:
+    """
+    Check that pmi_mode is not set on a local workstation without SLURM or flux.
+
+    Args:
+        pmi_mode (str, optional): PMI interface name (e.g. "pmix", "pmi1", "pmi2").
+
+    Raises:
+        ValueError: If pmi_mode is not None.
+    """
     if pmi_mode is not None:
         raise ValueError(
             "The option to specify the pmi mode is not available on a local workstation, it requires SLURM or flux."
@@ -199,7 +237,22 @@ def validate_number_of_cores(
     set_local_cores: bool = False,
 ) -> int:
     """
-    Validate the number of cores and return the appropriate value.
+    Validate the number of cores and return the number of workers to use.
+
+    Precedence: max_cores / cores_per_worker > max_workers > CPU count (with warning).
+
+    Args:
+        max_cores (int, optional): Total number of cores available.
+        max_workers (int, optional): Explicit number of parallel workers.
+        cores_per_worker (int, optional): Number of cores allocated to each worker. Defaults to 1.
+        set_local_cores (bool): When True, fall back to the local CPU count if neither
+            max_cores nor max_workers is given instead of raising an error. Defaults to False.
+
+    Returns:
+        int: Number of parallel workers to use.
+
+    Raises:
+        ValueError: If neither max_cores nor max_workers is set and set_local_cores is False.
     """
     if max_cores is not None and max_workers is None and cores_per_worker is not None:
         return int(max_cores / cores_per_worker)

executorlib/standalone/interactive/arguments.py

@@ -27,10 +27,21 @@ def get_future_objects_from_input(args: tuple, kwargs: dict):
 
     find_future_in_list(lst=args)
     find_future_in_list(lst=kwargs.values())
-    boolean_flag = len([future for future in future_lst if future.done()]) == len(
-        future_lst
-    )
-    return future_lst, boolean_flag
+
+    return future_lst
+
+
+def check_list_of_futures_is_done(future_lst: list[Future]) -> bool:
+    """
+    Check if all future objects in the list of future objects are done
+
+    Args:
+        future_lst (list): list of future objects
+
+    Returns:
+        bool: True if all future objects in the list of future objects are done, False otherwise
+    """
+    return len([future for future in future_lst if future.done()]) == len(future_lst)
 
 
 def get_exception_lst(future_lst: list[Future]) -> list:

executorlib/standalone/interactive/communication.py

@@ -240,6 +240,9 @@ def interface_connect(host: str, port: str) -> tuple[zmq.Context, zmq.Socket]:
     Args:
         host (str): hostname of the host running the SocketInterface instance to connect to.
         port (str): port on the host the SocketInterface instance is running on.
+
+    Returns:
+        Tuple[zmq.Context, zmq.Socket]: The ZMQ context and the connected PAIR socket.
     """
     context = zmq.Context()
     socket = context.socket(zmq.PAIR)
@@ -265,6 +268,9 @@ def interface_receive(socket: Optional[zmq.Socket]) -> dict:
 
     Args:
         socket (zmq.Socket): socket for the connection
+
+    Returns:
+        dict: Deserialized dictionary received from the socket, or an empty dict if socket is None.
     """
     if socket is not None:
         return cloudpickle.loads(socket.recv())

executorlib/standalone/select.py

@@ -3,21 +3,51 @@ from typing import Any, Optional
 
 
 class FutureSelector(Future):
+    """
+    A Future wrapper that returns a single element from a result that is a tuple, list, or dict.
+
+    This is used by split_future() and get_item_from_future() to give callers an individual
+    Future-like object for each output of a function that returns a collection.
+
+    Args:
+        future (Future): The underlying future whose result is a collection.
+        selector (int | str): Index (for sequences) or key (for mappings) used to extract
+            the desired element from the result.
+    """
+
     def __init__(self, future: Future, selector: int | str):
+        """
+        Args:
+            future (Future): The underlying future whose result is a collection.
+            selector (int | str): Index or key used to extract an element from the result.
+        """
         self._future = future
         self._selector = selector
         super().__init__()
 
     def __getattr__(self, attr: str) -> Any:
+        """Delegate attribute access to the wrapped future."""
         return getattr(self._future, attr)
 
     def __setattr__(self, name: str, value: Any):
+        """Set attributes on the wrapped future, except for the two private instance variables."""
         if name in ["_future", "_selector"]:
             super().__setattr__(name, value)
         else:
             setattr(self._future, name, value)
 
     def result(self, timeout: Optional[float] = None) -> Any:
+        """
+        Return the selected element from the underlying future's result.
+
+        Args:
+            timeout (float, optional): Maximum seconds to wait for the result. Defaults to None
+                (wait indefinitely).
+
+        Returns:
+            Any: The element at position/key ``selector`` in the underlying result, or None if
+                the underlying result is None.
+        """
         result = self._future.result(timeout=timeout)
         if result is not None:
             return result[self._selector]

executorlib/standalone/serialize.py

@@ -102,6 +102,18 @@ def _get_hash(binary: bytes) -> str:
 
 
 def _get_function_name(fn: Callable) -> str:
+    """
+    Return a human-readable name for a callable.
+
+    For regular functions and methods the ``__name__`` attribute is used. For callable objects
+    (classes implementing ``__call__``) the class name is extracted from ``__class__``.
+
+    Args:
+        fn (Callable): The callable whose name should be determined.
+
+    Returns:
+        str: A short name string suitable for use as part of a cache key prefix.
+    """
     if hasattr(fn, "__name__"):
         return fn.__name__
     else:

executorlib/standalone/validate.py

@@ -14,6 +14,25 @@ except ImportError:
 
 
 class ResourceDictValidation(BaseModel):
+    """
+    Pydantic (or dataclass fallback) model for validating resource dictionaries passed to task submissions.
+
+    Attributes:
+        cores (int, optional): Number of MPI cores to be used for each function call.
+        threads_per_core (int, optional): Number of OpenMP threads to be used for each function call.
+        gpus_per_core (int, optional): Number of GPUs per worker.
+        cwd (str, optional): Current working directory where the parallel python task is executed.
+        cache_key (str, optional): External cache key to identify tasks on the file system.
+        cache_directory (str, optional): The directory to store cache files.
+        num_nodes (int, optional): Number of compute nodes used for the evaluation.
+        exclusive (bool, optional): Reserve exclusive access to selected compute nodes.
+        error_log_file (str, optional): Path to the error log file.
+        run_time_max (int, optional): Maximum allowed execution time in seconds.
+        priority (int, optional): Queuing system priority for the task.
+        slurm_cmd_args (list[str], optional): Additional command line arguments for the srun call.
+        submission_template (str, optional): Template for queuing system job submission scripts.
+    """
+
     cores: Optional[int] = None
     threads_per_core: Optional[int] = None
     gpus_per_core: Optional[int] = None
@@ -39,6 +58,18 @@ if not HAS_PYDANTIC:
 
 
 def _get_accepted_keys(class_type) -> list[str]:
+    """
+    Return a list of accepted field names from a Pydantic model or dataclass.
+
+    Args:
+        class_type: A Pydantic BaseModel subclass or a dataclass.
+
+    Returns:
+        list[str]: Field names declared on the class.
+
+    Raises:
+        TypeError: If the class type is neither a Pydantic model nor a dataclass.
+    """
     if hasattr(class_type, "model_fields"):
         return list(class_type.model_fields.keys())
     elif hasattr(class_type, "__dataclass_fields__"):
@@ -47,10 +78,32 @@ def _get_accepted_keys(class_type) -> list[str]:
 
 
 def validate_resource_dict(resource_dict: dict) -> None:
+    """
+    Validate a resource dictionary against the declared fields of ResourceDictValidation.
+
+    Args:
+        resource_dict (dict): Dictionary of resource requirements to validate. Unknown keys raise
+            a validation error when pydantic is available.
+
+    Raises:
+        ValidationError: If any key/value pair violates the ResourceDictValidation schema.
+    """
     _ = ResourceDictValidation(**resource_dict)
 
 
 def validate_resource_dict_with_optional_keys(resource_dict: dict) -> None:
+    """
+    Validate a resource dictionary, allowing unknown keys with a warning instead of an error.
+
+    Known keys are validated against ResourceDictValidation. Unknown keys are collected and
+    emitted as a UserWarning so callers can detect unsupported options without hard failure.
+
+    Args:
+        resource_dict (dict): Dictionary of resource requirements to validate.
+
+    Raises:
+        ValidationError: If any known key/value pair violates the ResourceDictValidation schema.
+    """
     accepted_keys = _get_accepted_keys(class_type=ResourceDictValidation)
     optional_lst = [key for key in resource_dict if key not in accepted_keys]
     validate_dict = {

executorlib/task_scheduler/base.py

@@ -15,6 +15,12 @@ from executorlib.standalone.serialize import cloudpickle_register
 
 
 def validate_resource_dict(resource_dict: dict):
+    """
+    No-op resource dict validator used as the default when no validation is required.
+
+    Args:
+        resource_dict (dict): Dictionary of resource requirements (ignored).
+    """
     pass
 
 
@@ -32,7 +38,13 @@ class TaskSchedulerBase(FutureExecutor):
         validator: Callable = validate_resource_dict,
     ):
         """
-        Initialize the ExecutorBase class.
+        Initialize the TaskSchedulerBase.
+
+        Args:
+            max_cores (int, optional): Maximum number of cores available to the scheduler.
+                Tasks requesting more cores than this will be rejected. Defaults to None (unlimited).
+            validator (Callable): Function used to validate per-task resource dicts before
+                submission. Defaults to the no-op validate_resource_dict.
         """
         cloudpickle_register(ind=3)
         self._process_kwargs: dict = {}
@@ -43,10 +55,22 @@ class TaskSchedulerBase(FutureExecutor):
 
     @property
     def max_workers(self) -> Optional[int]:
+        """
+        Return the configured number of parallel workers, or None if unconstrained.
+
+        Returns:
+            Optional[int]: The max_workers value stored in process kwargs, or None.
+        """
         return self._process_kwargs.get("max_workers")
 
     @max_workers.setter
     def max_workers(self, max_workers: int):
+        """
+        Setting max_workers after construction is not supported by the base scheduler.
+
+        Raises:
+            NotImplementedError: Always.
+        """
         raise NotImplementedError("The max_workers setter is not implemented.")
 
     @property

executorlib/task_scheduler/file/shared.py

@@ -91,6 +91,7 @@ def execute_tasks_h5(
     process_dict: dict = {}
     cache_dir_dict: dict = {}
     file_name_dict: dict = {}
+    duplicate_dict: dict = {}
     while True:
         task_dict = None
         with contextlib.suppress(queue.Empty):
@@ -101,6 +102,7 @@ def execute_tasks_h5(
                 cancel_futures=task_dict.get("cancel_futures", False),
                 memory_dict=memory_dict,
                 process_dict=process_dict,
+                duplicate_dict=duplicate_dict,
                 cache_dir_dict=cache_dir_dict,
                 terminate_function=terminate_function,
                 pysqa_config_directory=pysqa_config_directory,
@@ -175,12 +177,17 @@ def execute_tasks_h5(
                     process_dict[task_key] = queue_id
                 memory_dict[task_key] = task_dict["future"]
                 cache_dir_dict[task_key] = cache_directory
+            elif memory_dict[task_key] != task_dict["future"]:
+                if task_key not in duplicate_dict:
+                    duplicate_dict[task_key] = []
+                duplicate_dict[task_key].append(task_dict["future"])
             future_queue.task_done()
         else:
             memory_dict = _refresh_memory_dict(
                 memory_dict=memory_dict,
                 cache_dir_dict=cache_dir_dict,
                 process_dict=process_dict,
+                duplicate_dict=duplicate_dict,
                 terminate_function=terminate_function,
                 pysqa_config_directory=pysqa_config_directory,
                 backend=backend,
@@ -189,7 +196,10 @@ def execute_tasks_h5(
 
 
 def _check_task_output(
-    task_key: str, future_obj: Future, cache_directory: str
+    task_key: str,
+    future_obj: Future,
+    cache_directory: str,
+    duplicate_dict: Optional[dict] = None,
 ) -> Future:
     """
     Check the output of a task and set the result of the future object if available.
@@ -198,7 +208,7 @@ def _check_task_output(
         task_key (str): The key of the task.
         future_obj (Future): The future object associated with the task.
         cache_directory (str): The directory where the HDF5 files are stored.
-
+        duplicate_dict (dict): The dictionary mapping task keys to their associated duplicate future objects.
     Returns:
         Future: The updated future object.
 
@@ -207,11 +217,40 @@ def _check_task_output(
     if not os.path.exists(file_name):
         return future_obj
     exec_flag, no_error_flag, result = get_output(file_name=file_name)
+    _update_future(
+        future_obj=future_obj,
+        exec_flag=exec_flag,
+        no_error_flag=no_error_flag,
+        result=result,
+    )
+    if duplicate_dict is not None and task_key in duplicate_dict:
+        for duplicate_future in duplicate_dict[task_key]:
+            _update_future(
+                future_obj=duplicate_future,
+                exec_flag=exec_flag,
+                no_error_flag=no_error_flag,
+                result=result,
+            )
+        del duplicate_dict[task_key]
+    return future_obj
+
+
+def _update_future(
+    future_obj: Future, exec_flag: bool, no_error_flag: bool, result: Any
+) -> None:
+    """
+    Update the future object with the result of the task execution.
+
+    Args:
+        future_obj (Future): The future object to be updated.
+        exec_flag (bool): Flag indicating whether the task has been executed.
+        no_error_flag (bool): Flag indicating whether the task execution resulted in an error.
+        result (Any): The result of the task execution.
+    """
     if exec_flag and no_error_flag:
         future_obj.set_result(result)
     elif exec_flag:
         future_obj.set_exception(result)
-    return future_obj
 
 
 def _convert_args_and_kwargs(
@@ -281,6 +320,7 @@ def _refresh_memory_dict(
     memory_dict: dict,
     cache_dir_dict: dict,
     process_dict: dict,
+    duplicate_dict: Optional[dict] = None,
     terminate_function: Optional[Callable] = None,
     pysqa_config_directory: Optional[str] = None,
     backend: Optional[str] = None,
@@ -293,6 +333,7 @@ def _refresh_memory_dict(
         memory_dict (dict): dictionary with task keys and future objects
         cache_dir_dict (dict): dictionary with task keys and cache directories
         process_dict (dict): dictionary with task keys and process reference.
+        duplicate_dict (dict): dictionary with task keys and duplicate future objects.
         terminate_function (callable): The function to terminate the tasks.
         pysqa_config_directory (str): path to the pysqa config directory (only for pysqa based backend).
         backend (str): name of the backend used to spawn tasks.
@@ -315,6 +356,7 @@ def _refresh_memory_dict(
             task_key=key,
             future_obj=value,
             cache_directory=cache_dir_dict[key],
+            duplicate_dict=duplicate_dict,
         )
         for key, value in memory_dict.items()
         if not value.done()
@@ -354,6 +396,24 @@ def _cancel_processes(
 def _get_task_input(
     task_resource_dict: dict, executor_kwargs: dict
 ) -> tuple[dict, Optional[str], str, Optional[str]]:
+    """
+    Merge per-task resource requirements with executor defaults and extract scheduling metadata.
+
+    Executor-level kwargs fill in any keys not already present in the per-task resource dict.
+    The special keys ``cache_key``, ``cache_directory``, and ``error_log_file`` are popped from
+    the merged dict and returned separately so callers do not forward them to the backend.
+
+    Args:
+        task_resource_dict (dict): Per-task resource dict from the submitted future, modified in place.
+        executor_kwargs (dict): Executor-level defaults (e.g. cores, cwd, cache_directory).
+
+    Returns:
+        Tuple[dict, Optional[str], str, Optional[str]]:
+            - merged resource dict (without scheduling-only keys)
+            - cache_key (str or None)
+            - cache_directory (str, absolute path)
+            - error_log_file (str or None)
+    """
     task_resource_dict.update(
         {k: v for k, v in executor_kwargs.items() if k not in task_resource_dict}
     )
@@ -364,6 +424,13 @@ def _get_task_input(
 
 
 def _cancel_futures(future_dict: dict):
+    """
+    Cancel all pending futures in the dictionary.
+
+    Args:
+        future_dict (dict): Mapping of task keys to Future objects. Already-done futures are
+            skipped; pending ones are cancelled.
+    """
     for value in future_dict.values():
         if not value.done():
             value.cancel()
@@ -375,17 +442,42 @@ def _shutdown_executor(
     memory_dict: dict,
     process_dict: dict,
     cache_dir_dict: dict,
+    duplicate_dict: Optional[dict] = None,
     terminate_function: Optional[Callable] = None,
     pysqa_config_directory: Optional[str] = None,
     backend: Optional[str] = None,
     refresh_rate: float = 0.01,
 ):
+    """
+    Shut down the file-based executor, optionally waiting for or cancelling pending tasks.
+
+    The four combinations of ``wait`` / ``cancel_futures`` mirror the semantics of
+    concurrent.futures.Executor.shutdown():
+
+    * wait=True, cancel_futures=False  – poll until all tasks finish.
+    * wait=True, cancel_futures=True   – cancel pending futures then wait for running ones.
+    * wait=False, cancel_futures=True  – cancel everything immediately without blocking.
+    * wait=False, cancel_futures=False – detach tasks and mark futures cancelled.
+
+    Args:
+        wait (bool): Whether to block until all outstanding tasks have resolved.
+        cancel_futures (bool): Whether to cancel futures that have not yet started.
+        memory_dict (dict): Mapping of task keys to their Future objects.
+        process_dict (dict): Mapping of task keys to process handles or queue IDs.
+        duplicate_dict (dict): Mapping of task keys to lists of duplicate Future objects.
+        cache_dir_dict (dict): Mapping of task keys to the cache directory for each task.
+        terminate_function (Callable, optional): Function used to terminate running processes.
+        pysqa_config_directory (str, optional): Path to the pysqa config directory.
+        backend (str, optional): Name of the backend ("slurm", "flux", or None for subprocess).
+        refresh_rate (float): Polling interval in seconds when waiting for tasks. Defaults to 0.01.
+    """
     if wait and not cancel_futures:
         while len(memory_dict) > 0:
             memory_dict = _refresh_memory_dict(
                 memory_dict=memory_dict,
                 cache_dir_dict=cache_dir_dict,
                 process_dict=process_dict,
+                duplicate_dict=duplicate_dict,
                 terminate_function=terminate_function,
                 pysqa_config_directory=pysqa_config_directory,
                 backend=backend,
@@ -400,6 +492,7 @@ def _shutdown_executor(
                 memory_dict=memory_dict,
                 cache_dir_dict=cache_dir_dict,
                 process_dict=process_dict,
+                duplicate_dict=duplicate_dict,
                 terminate_function=terminate_function,
                 pysqa_config_directory=pysqa_config_directory,
                 backend=backend,
@@ -418,6 +511,7 @@ def _shutdown_executor(
             memory_dict=memory_dict,
             cache_dir_dict=cache_dir_dict,
             process_dict=process_dict,
+            duplicate_dict=duplicate_dict,
             terminate_function=terminate_function,
             pysqa_config_directory=pysqa_config_directory,
             backend=backend,

executorlib/task_scheduler/interactive/dependency.py

@@ -7,6 +7,7 @@ from typing import Any, Callable, Optional
 from executorlib.standalone.batched import batched_futures
 from executorlib.standalone.interactive.arguments import (
     check_exception_was_raised,
+    check_list_of_futures_is_done,
     get_exception_lst,
     get_future_objects_from_input,
     update_futures_in_input,
@@ -177,6 +178,7 @@ class DependencyTaskScheduler(TaskSchedulerBase):
         future_lst: list[Future] = []
         for _ in range(len(iterable) // n + (1 if len(iterable) % n > 0 else 0)):
             f: Future = Future()
+            f_skip: Future = Future()
             if self._future_queue is not None:
                 self._future_queue.put(
                     {
@@ -184,10 +186,12 @@ class DependencyTaskScheduler(TaskSchedulerBase):
                         "args": (),
                         "kwargs": {"lst": iterable, "n": n, "skip_lst": skip_lst},
                         "future": f,
+                        "future_lst": iterable,
+                        "future_skip": f_skip,
                         "resource_dict": {},
                     }
                 )
-            skip_lst = skip_lst.copy() + [f]  # be careful
+            skip_lst = skip_lst.copy() + [f_skip]  # be careful
             future_lst.append(f)
 
         return future_lst
@@ -247,7 +251,7 @@ def _execute_tasks_with_dependencies(
         executor (TaskSchedulerBase): Executor to execute the tasks with after the dependencies are resolved.
         refresh_rate (float): Set the refresh rate in seconds, how frequently the input queue is checked.
     """
-    wait_lst: list = []
+    future_dependency_lst: list = []
     while True:
         try:
             task_dict = future_queue.get_nowait()
@@ -256,10 +260,10 @@ def _execute_tasks_with_dependencies(
         if (  # shutdown the executor
             task_dict is not None and "shutdown" in task_dict and task_dict["shutdown"]
         ):
-            while len(wait_lst) > 0:
+            while len(future_dependency_lst) > 0:
                 # Check functions in the wait list and execute them if all future objects are now ready
-                wait_lst = _update_waiting_task(
-                    wait_lst=wait_lst,
+                future_dependency_lst = _handle_future_dependencies(
+                    future_dependency_lst=future_dependency_lst,
                     executor_queue=executor_queue,
                     refresh_rate=refresh_rate,
                 )
@@ -267,7 +271,7 @@ def _execute_tasks_with_dependencies(
             future_queue.task_done()
             future_queue.join()
             break
-        if (  # shutdown the executor
+        elif (  # handle internal tasks for getting and setting information about the executor
             task_dict is not None and "internal" in task_dict and task_dict["internal"]
         ):
             if task_dict["task"] == "get_info":
@@ -281,12 +285,24 @@ def _execute_tasks_with_dependencies(
                     task_dict["future"].set_result(False)
                 else:
                     task_dict["future"].set_result(True)
+        elif (  # handle batched function submitted to the executor
+            task_dict is not None
+            and "fn" in task_dict
+            and task_dict["fn"] == "batched"
+            and "future" in task_dict
+        ):
+            future_dependency_lst.append(task_dict)
+            future_queue.task_done()
         elif (  # handle function submitted to the executor
-            task_dict is not None and "fn" in task_dict and "future" in task_dict
+            task_dict is not None
+            and "fn" in task_dict
+            and task_dict["fn"] != "batched"
+            and "future" in task_dict
         ):
-            future_lst, ready_flag = get_future_objects_from_input(
+            future_lst = get_future_objects_from_input(
                 args=task_dict["args"], kwargs=task_dict["kwargs"]
             )
+            ready_flag = check_list_of_futures_is_done(future_lst=future_lst)
             exception_lst = get_exception_lst(future_lst=future_lst)
             if not check_exception_was_raised(future_obj=task_dict["future"]):
                 if len(exception_lst) > 0:
@@ -299,12 +315,12 @@ def _execute_tasks_with_dependencies(
                     executor_queue.put(task_dict)
                 else:  # Otherwise add the function to the wait list
                     task_dict["future_lst"] = future_lst
-                    wait_lst.append(task_dict)
+                    future_dependency_lst.append(task_dict)
             future_queue.task_done()
-        elif len(wait_lst) > 0:
+        elif len(future_dependency_lst) > 0:
             # Check functions in the wait list and execute them if all future objects are now ready
-            wait_lst = _update_waiting_task(
-                wait_lst=wait_lst,
+            future_dependency_lst = _handle_future_dependencies(
+                future_dependency_lst=future_dependency_lst,
                 executor_queue=executor_queue,
                 refresh_rate=refresh_rate,
             )
@@ -313,14 +329,16 @@ def _execute_tasks_with_dependencies(
             sleep(refresh_rate)
 
 
-def _update_waiting_task(
-    wait_lst: list[dict], executor_queue: queue.Queue, refresh_rate: float = 0.01
+def _handle_future_dependencies(
+    future_dependency_lst: list[dict],
+    executor_queue: queue.Queue,
+    refresh_rate: float = 0.01,
 ) -> list:
     """
     Submit the waiting tasks, which future inputs have been completed, to the executor
 
     Args:
-        wait_lst (list): List of waiting tasks
+        future_dependency_lst (list): List of waiting tasks
         executor_queue (Queue): Queue of the internal executor
         refresh_rate (float): Set the refresh rate in seconds, how frequently the input queue is checked.
 
@@ -328,9 +346,9 @@ def _update_waiting_task(
         list: list tasks which future inputs have not been completed
     """
     wait_tmp_lst = []
-    for task_wait_dict in wait_lst:
+    for task_wait_dict in future_dependency_lst:
         exception_lst = get_exception_lst(future_lst=task_wait_dict["future_lst"])
-        if len(exception_lst) > 0:
+        if len(exception_lst) > 0 and task_wait_dict["fn"] != "batched":
             task_wait_dict["future"].set_exception(exception_lst[0])
         elif task_wait_dict["fn"] != "batched" and all(
             future.done() for future in task_wait_dict["future_lst"]
@@ -343,17 +361,21 @@ def _update_waiting_task(
         elif task_wait_dict["fn"] == "batched" and all(
             future.done() for future in task_wait_dict["kwargs"]["skip_lst"]
         ):
-            done_lst = batched_futures(
+            success, done_lst = batched_futures(
                 lst=task_wait_dict["kwargs"]["lst"],
                 n=task_wait_dict["kwargs"]["n"],
-                skip_lst=[f.result() for f in task_wait_dict["kwargs"]["skip_lst"]],
+                nested_skip_lst=task_wait_dict["kwargs"]["skip_lst"],
             )
-            if len(done_lst) == 0:
+            if success and len(done_lst) == 0:
                 wait_tmp_lst.append(task_wait_dict)
+            elif success and len(done_lst) > 0:
+                task_wait_dict["future"].set_result([f.result() for f in done_lst])
+                task_wait_dict["future_skip"].set_result([id(f) for f in done_lst])
             else:
-                task_wait_dict["future"].set_result(done_lst)
+                task_wait_dict["future"].set_exception(done_lst[0].exception())
+                task_wait_dict["future_skip"].set_result([id(f) for f in done_lst])
         else:
             wait_tmp_lst.append(task_wait_dict)
-    if len(wait_lst) == len(wait_tmp_lst):
+    if len(future_dependency_lst) == len(wait_tmp_lst):
         sleep(refresh_rate)
     return wait_tmp_lst

{executorlib-1.9.3.dist-info → executorlib-1.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: executorlib
-Version: 1.9.3
+Version: 1.9.4
 Summary: Up-scale python functions for high performance computing (HPC) with executorlib.
 Project-URL: Homepage, https://github.com/pyiron/executorlib
 Project-URL: Documentation, https://executorlib.readthedocs.io
@@ -36,7 +36,7 @@ License: BSD 3-Clause License
         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.
 License-File: LICENSE
-Keywords: executor,flux-framework,high performance computing,hpc,slurm,task scheduler
+Keywords: concurrent.futures,distributed computing,executor,flux-framework,gpu,high performance computing,hpc,mpi4py,parallel computing,python,scientific computing,slurm,task scheduler
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: BSD License
@@ -52,16 +52,16 @@ Requires-Dist: pyzmq<=27.1.0,>=25.0.0
 Provides-Extra: all
 Requires-Dist: h5py<=3.16.0,>=3.6.0; extra == 'all'
 Requires-Dist: ipython<=9.9.0,>=7.33.0; extra == 'all'
-Requires-Dist: mpi4py<=4.1.1,>=3.1.4; extra == 'all'
+Requires-Dist: mpi4py<=4.1.2,>=3.1.4; extra == 'all'
 Requires-Dist: networkx<=3.6.1,>=2.8.8; extra == 'all'
 Requires-Dist: pydantic<=2.13.4,>=2.5.3; extra == 'all'
 Requires-Dist: pygraphviz<=1.14,>=1.10; extra == 'all'
-Requires-Dist: pysqa==0.4.1; extra == 'all'
+Requires-Dist: pysqa==0.4.2; extra == 'all'
 Provides-Extra: cache
 Requires-Dist: h5py<=3.16.0,>=3.6.0; extra == 'cache'
 Provides-Extra: cluster
 Requires-Dist: h5py<=3.16.0,>=3.6.0; extra == 'cluster'
-Requires-Dist: pysqa==0.4.1; extra == 'cluster'
+Requires-Dist: pysqa==0.4.2; extra == 'cluster'
 Provides-Extra: graph
 Requires-Dist: networkx<=3.6.1,>=2.8.8; extra == 'graph'
 Requires-Dist: pygraphviz<=1.14,>=1.10; extra == 'graph'
@@ -70,7 +70,7 @@ Requires-Dist: ipython<=9.9.0,>=7.33.0; extra == 'graphnotebook'
 Requires-Dist: networkx<=3.6.1,>=2.8.8; extra == 'graphnotebook'
 Requires-Dist: pygraphviz<=1.14,>=1.10; extra == 'graphnotebook'
 Provides-Extra: mpi
-Requires-Dist: mpi4py<=4.1.1,>=3.1.4; extra == 'mpi'
+Requires-Dist: mpi4py<=4.1.2,>=3.1.4; extra == 'mpi'
 Provides-Extra: validation
 Requires-Dist: pydantic<=2.13.4,>=2.5.3; extra == 'validation'
 Description-Content-Type: text/markdown
@@ -96,6 +96,26 @@ Up-scale python functions for high performance computing (HPC) with executorlib.
   machine learning pipelines and simulation workflows executorlib provides optional caching of intermediate results for 
   iterative development in interactive environments like jupyter notebooks.
 
+## Why executorlib?
+executorlib is the lightest path to take *existing* Python functions and scale them across high performance computing
+(HPC) nodes — with per-function-call resource control and native [SLURM](https://slurm.schedmd.com) and
+[flux](http://flux-framework.org) integration — without rewriting your code into a new paradigm. It extends the standard
+library [Executor interface](https://docs.python.org/3/library/concurrent.futures.html#executor-objects) you already
+know, rather than asking you to adopt a new data, actor, or workflow model.
+
+| | executorlib | [Futures](https://docs.python.org/3/library/concurrent.futures.html) | [Dask](https://www.dask.org) | [Parsl](https://parsl-project.org) | [Ray](https://www.ray.io) |
+|---|---|---|---|---|---|
+| Drop-in `Executor` API | ✅ | ✅ | ⚠️ | ⚠️  | ❌ |
+| Per-call resource assignment | ✅ | ❌ | ⚠️ | ✅ | ✅ |
+| Native HPC scheduler (SLURM/flux) | ✅ | ❌ | ⚠️ | ✅ | ⚠️ |
+| MPI-parallel functions | ✅ | ❌ | ⚠️ | ⚠️ | ⚠️ |
+| Caching of results | ✅ | ❌ | ⚠️ | ✅ | ❌ |
+| Setup / learning overhead | Low | Very low | Medium | Medium | Medium |
+
+✅ first-class · ⚠️ possible via add-on/config · ❌ not supported. See the full
+[comparison: when to use which](https://executorlib.readthedocs.io/en/latest/comparison.html) for honest guidance on
+when another tool is the better fit.
+
 ## Examples
 The Python standard library provides the [Executor interface](https://docs.python.org/3/library/concurrent.futures.html#executor-objects)
 with the [ProcessPoolExecutor](https://docs.python.org/3/library/concurrent.futures.html#processpoolexecutor) and the 
@@ -207,6 +227,13 @@ as hierarchical job scheduler within the allocations.
   * [HPC Job Executor](https://executorlib.readthedocs.io/en/latest/installation.html#hpc-job-executor)
   * [Visualisation](https://executorlib.readthedocs.io/en/latest/installation.html#visualisation)
   * [For Developers](https://executorlib.readthedocs.io/en/latest/installation.html#for-developers)
+* [Comparison](https://executorlib.readthedocs.io/en/latest/comparison.html#comparison)
+  * [At a glace](https://executorlib.readthedocs.io/en/latest/comparison.html#at-a-glance)
+  * [Concurrent futures](https://executorlib.readthedocs.io/en/latest/comparison.html#concurrent-futures-the-python-standard-library)
+  * [Dask](https://executorlib.readthedocs.io/en/latest/comparison.html#dask)
+  * [Parsl](https://executorlib.readthedocs.io/en/latest/comparison.html#parsl)
+  * [Ray](https://executorlib.readthedocs.io/en/latest/comparison.html#ray)
+  * [Choose executorlib when](https://executorlib.readthedocs.io/en/latest/comparison.html#choose-executorlib-when)
 * [Single Node Executor](https://executorlib.readthedocs.io/en/latest/1-single-node.html)
   * [Basic Functionality](https://executorlib.readthedocs.io/en/latest/1-single-node.html#basic-functionality)
   * [Parallel Functions](https://executorlib.readthedocs.io/en/latest/1-single-node.html#parallel-functions)

{executorlib-1.9.3.dist-info → executorlib-1.9.4.dist-info}/RECORD

@@ -1,5 +1,5 @@
 executorlib/__init__.py,sha256=IY_DkT706LPIv2_iIe3whrQNGoDzaDFYBvXyUepoZpw,4780
-executorlib/_version.py,sha256=aP_jp8pTg5bC5pvVCuPuBjtAyDTeAfc19YYDbsZTPm8,704
+executorlib/_version.py,sha256=VdLE9NNjOWcm4_Kh_W9w_lFN3bh0oesrwyTL3nQnUKg,520
 executorlib/api.py,sha256=F6ibDJnVcPGxxPe-UScFJHprWHiVsETGhgAvS1T-9ZI,1365
 executorlib/backend/__init__.py,sha256=2b_iwds4VUrJe92nKtQXkoGxkJiXeEDSlbvCRN_-de8,456
 executorlib/backend/cache_parallel.py,sha256=ldb2iYzrhcXJZ0LcH75FpTLO_6F51mleU9JGAilF00k,2020
@@ -7,44 +7,44 @@ executorlib/backend/cache_serial.py,sha256=9T3bAxVivGxvzHnXmvysyEPP4sw--VCwXCn2M
 executorlib/backend/interactive_parallel.py,sha256=HimGnWOdTXInC3o7W4wMUSTTlj6MsMPLJLkcNTaK_SQ,3869
 executorlib/backend/interactive_serial.py,sha256=NxlSX566rQM-pHiy2rQja2rr3lFwdnv0EvIyXk8H7co,2982
 executorlib/executor/__init__.py,sha256=oR2ABLAMYV_TNs1eG-3-MAKHFS7OKB-1KOzCqKNbtWA,310
-executorlib/executor/base.py,sha256=vqNlVCjmQAsFQkSyjZ3gGTyQeN0khu4DkZBactr2Qz0,6559
+executorlib/executor/base.py,sha256=UKJViNoshthAgF2I4FoK0nZT0FL7WgkrzWFYhRiU1H4,6957
 executorlib/executor/flux.py,sha256=g8K1GMfn9KMM4udj3LdmDMahavPBBCOusYVG36W1hAY,40779
 executorlib/executor/single.py,sha256=U-mflJIQSBMS7atK7RQktx87LGkJhLSBbh2Uz9kOLlY,36021
 executorlib/executor/slurm.py,sha256=Prvts9IgDHgCCMYoWpNdeoKMZ4h1ICQ05fkomh25Yl4,38337
 executorlib/standalone/__init__.py,sha256=n_Q4NUFu35Fn0qlWIhmoC_FyUkmFGlWn1cNc_7EscF0,290
-executorlib/standalone/batched.py,sha256=Q2GPy4hPD_t5PflqF-m8ADjcHgeb56eJF31-XbsMMwM,990
-executorlib/standalone/command.py,sha256=_XqVYPrpR7_-DkHrPAbcvMR1gmoS0NjQVJMSfjsowEQ,6547
+executorlib/standalone/batched.py,sha256=o3TtsFJir8nP1O_NZFfW0Q78CoZAFgHMyroWlg520nE,1446
+executorlib/standalone/command.py,sha256=4Xndog84zJdku1ke1DwdUamkWvzRrMz-VDCi5cRXi0M,6548
 executorlib/standalone/error.py,sha256=aaMQoRsoLzLCbYT-E4LZxGM9pm_AhjMesRjVt0d_LDk,714
-executorlib/standalone/hdf.py,sha256=84PPWwW19V5_we2DEYvGkZSiIyN-it2AnQkNpJpwiFU,7462
-executorlib/standalone/inputcheck.py,sha256=ZS5NY-tC4G-8jHmVl_GNF8zakIPqayCj8aQDlM0A37E,8146
+executorlib/standalone/hdf.py,sha256=nE2mTH1U8O7sm2TPJkfRU0uEgWJOhLnYxI6yZord8Eo,7623
+executorlib/standalone/inputcheck.py,sha256=kSWUzqdMOhILYXW4Isumn1EGH3SegxPUMWRkUWfEleU,10041
 executorlib/standalone/queue.py,sha256=KFEBFQXGvcaf5qcuCjT5kaZg7ucWOTGOtrD96tIBlq0,589
 executorlib/standalone/scheduler.py,sha256=LhCuIdaw9BjrP3GerbHUIqwsvxERdtH5JQoeyAqASIU,2325
-executorlib/standalone/select.py,sha256=gn6N0E01qTfGFm8nDNE9bilXXmy4rk1Wb0P7rAk4y54,1770
-executorlib/standalone/serialize.py,sha256=OEXQKYQ3P-pvbLHmOgF86oPgJkzR5vRWmL4gwnJwy94,4292
-executorlib/standalone/validate.py,sha256=R8xCXCL8RpyM1fbufo-6DqrdzvP54zVkcqlJZwBj7Qo,1969
+executorlib/standalone/select.py,sha256=FUSXYbhoc_uP_vPji8L4PcK4b2Gwcai7rXZ5dKRVjZM,3061
+executorlib/standalone/serialize.py,sha256=7DxcuCYZVqLf8wa7EXsN-_8fSpUJqyQ-5G6NT863SgM,4716
+executorlib/standalone/validate.py,sha256=hHG32xomLhbqnqd6Vn4AO05bQ7B3WZ1rngTkMsODwwk,4430
 executorlib/standalone/interactive/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-executorlib/standalone/interactive/arguments.py,sha256=058jZ-4GVZo-YC5sYeZBSbIOzekdaK-PSp65WmA85Dg,2944
+executorlib/standalone/interactive/arguments.py,sha256=iaVXf7Wq9MUOu3WeYSi2t-f8Si_pyAPyykcnq8bf8cY,3239
 executorlib/standalone/interactive/backend.py,sha256=gGgcvER8w75bM_p1uplSsr6yCtBBlOS_6wR1iQNsntc,3006
-executorlib/standalone/interactive/communication.py,sha256=U0eC5rz-uLTlGSPDG_K-ZVkapuzvV2X-NaD1nwwTXxE,10233
+executorlib/standalone/interactive/communication.py,sha256=ZYngnW-myohI5jjF1RDHfMEX8dVDN2Ow6kBjMVkAfxw,10448
 executorlib/standalone/interactive/spawner.py,sha256=4TEPL4iI_rF25kOaW-eqY74jK93LFZ05cYOHUjIuo4M,6384
 executorlib/task_scheduler/__init__.py,sha256=-sw60rfnEvwFiOAONFHpE3izPA9CPtp5cQ7vRetw2Mw,249
-executorlib/task_scheduler/base.py,sha256=aoXxOuOwWDKbGVwWwtnr0KGYBbOQehaACM2h3FdfKcg,8777
+executorlib/task_scheduler/base.py,sha256=A9nQb8FYKbZGjQP1G5ccT75ODbEqqiM0OVybHAxjqzE,9718
 executorlib/task_scheduler/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 executorlib/task_scheduler/file/backend.py,sha256=tojXcYytAsfABugsOMfkx9oAh01do_DcSneVldMfeK0,2876
-executorlib/task_scheduler/file/shared.py,sha256=dxkL3Yjmk-oNsJHw8jo7sVCJUc3sc2hbNWOK_XdlhGM,16703
+executorlib/task_scheduler/file/shared.py,sha256=zRODWHzqZBzrEjmJenBNBwwM2mqMcnNIXpOfTGsyYBo,21128
 executorlib/task_scheduler/file/spawner_pysqa.py,sha256=j7GdUQgo6vZKqbXtdXL3doaCK8InrDdPJOn0kWGY7-4,6032
 executorlib/task_scheduler/file/spawner_subprocess.py,sha256=BejOMi5zLkIVUUywv5hl0YdnXkGujGo4nXMpmmuHq2k,3089
 executorlib/task_scheduler/file/task_scheduler.py,sha256=c57K8d3Sfh4p--xvAy5LsCtTq9GOdymaUeN0h4POyS8,6019
 executorlib/task_scheduler/interactive/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 executorlib/task_scheduler/interactive/blockallocation.py,sha256=HcfrYEuopD7wLUoxuoawRRNdaH4dTsPnFTb7luR7G5Y,17738
-executorlib/task_scheduler/interactive/dependency.py,sha256=fh402wEkXMhKxzFzsUGn1qQgNTB_KgPWIzevI89kLLg,13964
+executorlib/task_scheduler/interactive/dependency.py,sha256=zQMfI6AjeUv3A1qyPzFah2BKYGWgGLRyEIdZ0XTjq1M,15222
 executorlib/task_scheduler/interactive/dependency_plot.py,sha256=iZBZ9UMDeYOMFjD2-kYOxOdKeodj7TuyshI4HbH4XCU,11788
 executorlib/task_scheduler/interactive/onetoone.py,sha256=cTXgTXR9kKzzlx6EfGumMsEm7DUa7BD9JSeBpdPiupI,13312
 executorlib/task_scheduler/interactive/shared.py,sha256=-krntmZFOOE5U0HdFwuU8JZPqZQmPW4-cePDWuvkTgM,6305
 executorlib/task_scheduler/interactive/spawner_flux.py,sha256=M7CPWvzY7MDkplJ4awymh7WbMYwKsDPTKxA2Op9wfNo,7075
 executorlib/task_scheduler/interactive/spawner_pysqa.py,sha256=96NqUfoIBUFd7KjY02dpIL9ZoS_u5beRuNw_1FUKH6Q,10393
 executorlib/task_scheduler/interactive/spawner_slurm.py,sha256=K5mj63PE8FYbkw9WWm4uEjoA5q0HM42z1d2wjAmO5YA,3713
-executorlib-1.9.3.dist-info/METADATA,sha256=b5j4WKJ5jK15yt9zYv25iWAHemSjbiMtD33ubVXSlLI,16071
-executorlib-1.9.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-executorlib-1.9.3.dist-info/licenses/LICENSE,sha256=NkrhccIxPXCbbvp_upyVojt7DNTwZIco3z9wsYpSLqU,1511
-executorlib-1.9.3.dist-info/RECORD,,
+executorlib-1.9.4.dist-info/METADATA,sha256=4augHmAbGQ-7H0r4Zh6vaFvTh-yTwZMSyuLVYsp7-Qo,18249
+executorlib-1.9.4.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+executorlib-1.9.4.dist-info/licenses/LICENSE,sha256=NkrhccIxPXCbbvp_upyVojt7DNTwZIco3z9wsYpSLqU,1511
+executorlib-1.9.4.dist-info/RECORD,,

{executorlib-1.9.3.dist-info → executorlib-1.9.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.29.0
+Generator: hatchling 1.30.1
 Root-Is-Purelib: true
 Tag: py3-none-any