executorlib 0.0.1__tar.gz → 0.0.3__tar.gz

{executorlib-0.0.1/executorlib.egg-info → executorlib-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: executorlib
-Version: 0.0.1
+Version: 0.0.3
 Summary: Scale serial and MPI-parallel python functions over hundreds of compute nodes all from within a jupyter notebook or serial python process.
 Author-email: Jan Janssen <janssen@lanl.gov>
 License: BSD 3-Clause License
@@ -50,19 +50,16 @@ Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cloudpickle<=3.0.0,>=2.0.0
-Requires-Dist: pyzmq<=26.0.3,>=25.0.0
-Provides-Extra: conda
-Requires-Dist: conda_subprocess<=0.0.4,>=0.0.3; extra == "conda"
+Requires-Dist: pyzmq<=26.2.0,>=25.0.0
 Provides-Extra: mpi
-Requires-Dist: mpi4py<=3.1.6,>=3.1.4; extra == "mpi"
+Requires-Dist: mpi4py<=4.0.0,>=3.1.4; extra == "mpi"
 Provides-Extra: hdf
 Requires-Dist: h5py<=3.11.0,>=3.6.0; extra == "hdf"
-Requires-Dist: h5io<=0.2.3,>=0.2.1; extra == "hdf"
 Provides-Extra: graph
-Requires-Dist: pygraphviz<=1.13,>=1.10; extra == "graph"
-Requires-Dist: matplotlib<=3.9.1,>=3.5.3; extra == "graph"
+Requires-Dist: pygraphviz<=1.14,>=1.10; extra == "graph"
+Requires-Dist: matplotlib<=3.9.2,>=3.5.3; extra == "graph"
 Requires-Dist: networkx<=3.3,>=2.8.8; extra == "graph"
-Requires-Dist: ipython<=8.26.0,>=7.33.0; extra == "graph"
+Requires-Dist: ipython<=8.27.0,>=7.33.0; extra == "graph"
 
 # executorlib
 [![Unittests](https://github.com/pyiron/executorlib/actions/workflows/unittest-openmpi.yml/badge.svg)](https://github.com/pyiron/executorlib/actions/workflows/unittest-openmpi.yml)

{executorlib-0.0.1 → executorlib-0.0.3}/executorlib/__init__.py

@@ -40,15 +40,17 @@ class Executor:
         max_workers (int): for backwards compatibility with the standard library, max_workers also defines the number of
                            cores which can be used in parallel - just like the max_cores parameter. Using max_cores is
                            recommended, as computers have a limited number of compute cores.
+        backend (str): Switch between the different backends "flux", "local" or "slurm". The default is "local".
         max_cores (int): defines the number cores which can be used in parallel
         cores_per_worker (int): number of MPI cores to be used for each function call
         threads_per_core (int): number of OpenMP threads to be used for each function call
         gpus_per_worker (int): number of GPUs per worker - defaults to 0
-        oversubscribe (bool): adds the `--oversubscribe` command line flag (OpenMPI and SLURM only) - default False
         cwd (str/None): current working directory where the parallel python task is executed
-        conda_environment_name (str): name of the conda environment to initialize
-        conda_environment_path (str): path of the conda environment to initialize
-        executor (flux.job.FluxExecutor): Flux Python interface to submit the workers to flux
+        openmpi_oversubscribe (bool): adds the `--oversubscribe` command line flag (OpenMPI and SLURM only) - default False
+        slurm_cmd_args (list): Additional command line arguments for the srun call (SLURM only)
+        flux_executor (flux.job.FluxExecutor): Flux Python interface to submit the workers to flux
+        flux_executor_pmi_mode (str): PMI interface to use (OpenMPI v5 requires pmix) default is None (Flux only)
+        flux_executor_nesting (bool): Provide hierarchically nested Flux job scheduler inside the submitted function.
         hostname_localhost (boolean): use localhost instead of the hostname to establish the zmq connection. In the
                                       context of an HPC cluster this essential to be able to communicate to an
                                       Executor running on a different compute node within the same allocation. And
@@ -56,15 +58,11 @@ class Executor:
                                       points to the same address as localhost. Still MacOS >= 12 seems to disable
                                       this look up for security reasons. So on MacOS it is required to set this
                                       option to true
-        backend (str): Switch between the different backends "flux", "local" or "slurm". Alternatively, when "auto"
-                       is selected (the default) the available backend is determined automatically.
         block_allocation (boolean): To accelerate the submission of a series of python functions with the same resource
                                     requirements, executorlib supports block allocation. In this case all resources have
                                     to be defined on the executor, rather than during the submission of the individual
                                     function.
         init_function (None): optional function to preset arguments for functions which are submitted later
-        command_line_argument_lst (list): Additional command line arguments for the srun call (SLURM only)
-        pmi (str): PMI interface to use (OpenMPI v5 requires pmix) default is None (Flux only)
         disable_dependencies (boolean): Disable resolving future objects during the submission.
         refresh_rate (float): Set the refresh rate in seconds, how frequently the input queue is checked.
         plot_dependency_graph (bool): Plot the dependencies of multiple future objects without executing them. For
@@ -94,21 +92,20 @@ class Executor:
     def __init__(
         self,
         max_workers: int = 1,
+        backend: str = "local",
         max_cores: int = 1,
         cores_per_worker: int = 1,
         threads_per_core: int = 1,
         gpus_per_worker: int = 0,
-        oversubscribe: bool = False,
         cwd: Optional[str] = None,
-        conda_environment_name: Optional[str] = None,
-        conda_environment_path: Optional[str] = None,
-        executor=None,
+        openmpi_oversubscribe: bool = False,
+        slurm_cmd_args: list[str] = [],
+        flux_executor=None,
+        flux_executor_pmi_mode: Optional[str] = None,
+        flux_executor_nesting: bool = False,
         hostname_localhost: bool = False,
-        backend: str = "auto",
         block_allocation: bool = True,
         init_function: Optional[callable] = None,
-        command_line_argument_lst: list[str] = [],
-        pmi: Optional[str] = None,
         disable_dependencies: bool = False,
         refresh_rate: float = 0.01,
         plot_dependency_graph: bool = False,
@@ -119,21 +116,20 @@ class Executor:
     def __new__(
         cls,
         max_workers: int = 1,
+        backend: str = "local",
         max_cores: int = 1,
         cores_per_worker: int = 1,
         threads_per_core: int = 1,
         gpus_per_worker: int = 0,
-        oversubscribe: bool = False,
         cwd: Optional[str] = None,
-        conda_environment_name: Optional[str] = None,
-        conda_environment_path: Optional[str] = None,
-        executor=None,
+        openmpi_oversubscribe: bool = False,
+        slurm_cmd_args: list[str] = [],
+        flux_executor=None,
+        flux_executor_pmi_mode: Optional[str] = None,
+        flux_executor_nesting: bool = False,
         hostname_localhost: bool = False,
-        backend: str = "auto",
-        block_allocation: bool = False,
+        block_allocation: bool = True,
         init_function: Optional[callable] = None,
-        command_line_argument_lst: list[str] = [],
-        pmi: Optional[str] = None,
         disable_dependencies: bool = False,
         refresh_rate: float = 0.01,
         plot_dependency_graph: bool = False,
@@ -150,15 +146,17 @@ class Executor:
             max_workers (int): for backwards compatibility with the standard library, max_workers also defines the
                                number of cores which can be used in parallel - just like the max_cores parameter. Using
                                max_cores is recommended, as computers have a limited number of compute cores.
+            backend (str): Switch between the different backends "flux", "local" or "slurm". The default is "local".
             max_cores (int): defines the number cores which can be used in parallel
             cores_per_worker (int): number of MPI cores to be used for each function call
             threads_per_core (int): number of OpenMP threads to be used for each function call
             gpus_per_worker (int): number of GPUs per worker - defaults to 0
-            oversubscribe (bool): adds the `--oversubscribe` command line flag (OpenMPI and SLURM only) - default False
+            openmpi_oversubscribe (bool): adds the `--oversubscribe` command line flag (OpenMPI and SLURM only) - default False
+            slurm_cmd_args (list): Additional command line arguments for the srun call (SLURM only)
             cwd (str/None): current working directory where the parallel python task is executed
-            conda_environment_name (str): name of the conda environment to initialize
-            conda_environment_path (str): path of the conda environment to initialize
-            executor (flux.job.FluxExecutor): Flux Python interface to submit the workers to flux
+            flux_executor (flux.job.FluxExecutor): Flux Python interface to submit the workers to flux
+            flux_executor_pmi_mode (str): PMI interface to use (OpenMPI v5 requires pmix) default is None (Flux only)
+            flux_executor_nesting (bool): Provide hierarchically nested Flux job scheduler inside the submitted function.
             hostname_localhost (boolean): use localhost instead of the hostname to establish the zmq connection. In the
                                       context of an HPC cluster this essential to be able to communicate to an
                                       Executor running on a different compute node within the same allocation. And
@@ -166,15 +164,11 @@ class Executor:
                                       points to the same address as localhost. Still MacOS >= 12 seems to disable
                                       this look up for security reasons. So on MacOS it is required to set this
                                       option to true
-            backend (str): Switch between the different backends "flux", "local" or "slurm". Alternatively, when "auto"
-                           is selected (the default) the available backend is determined automatically.
             block_allocation (boolean): To accelerate the submission of a series of python functions with the same
                                         resource requirements, executorlib supports block allocation. In this case all
                                         resources have to be defined on the executor, rather than during the submission
                                         of the individual function.
             init_function (None): optional function to preset arguments for functions which are submitted later
-            command_line_argument_lst (list): Additional command line arguments for the srun call (SLURM only)
-            pmi (str): PMI interface to use (OpenMPI v5 requires pmix) default is None (Flux only)
             disable_dependencies (boolean): Disable resolving future objects during the submission.
             refresh_rate (float): Set the refresh rate in seconds, how frequently the input queue is checked.
             plot_dependency_graph (bool): Plot the dependencies of multiple future objects without executing them. For
@@ -184,21 +178,20 @@ class Executor:
         if not disable_dependencies:
             return ExecutorWithDependencies(
                 max_workers=max_workers,
+                backend=backend,
                 max_cores=max_cores,
                 cores_per_worker=cores_per_worker,
                 threads_per_core=threads_per_core,
                 gpus_per_worker=gpus_per_worker,
-                oversubscribe=oversubscribe,
                 cwd=cwd,
-                conda_environment_name=conda_environment_name,
-                conda_environment_path=conda_environment_path,
-                executor=executor,
+                openmpi_oversubscribe=openmpi_oversubscribe,
+                slurm_cmd_args=slurm_cmd_args,
+                flux_executor=flux_executor,
+                flux_executor_pmi_mode=flux_executor_pmi_mode,
+                flux_executor_nesting=flux_executor_nesting,
                 hostname_localhost=hostname_localhost,
-                backend=backend,
                 block_allocation=block_allocation,
                 init_function=init_function,
-                command_line_argument_lst=command_line_argument_lst,
-                pmi=pmi,
                 refresh_rate=refresh_rate,
                 plot_dependency_graph=plot_dependency_graph,
             )
@@ -207,19 +200,18 @@ class Executor:
             _check_refresh_rate(refresh_rate=refresh_rate)
             return create_executor(
                 max_workers=max_workers,
+                backend=backend,
                 max_cores=max_cores,
                 cores_per_worker=cores_per_worker,
                 threads_per_core=threads_per_core,
                 gpus_per_worker=gpus_per_worker,
-                oversubscribe=oversubscribe,
                 cwd=cwd,
-                conda_environment_name=conda_environment_name,
-                conda_environment_path=conda_environment_path,
-                executor=executor,
+                openmpi_oversubscribe=openmpi_oversubscribe,
+                slurm_cmd_args=slurm_cmd_args,
+                flux_executor=flux_executor,
+                flux_executor_pmi_mode=flux_executor_pmi_mode,
+                flux_executor_nesting=flux_executor_nesting,
                 hostname_localhost=hostname_localhost,
-                backend=backend,
                 block_allocation=block_allocation,
                 init_function=init_function,
-                command_line_argument_lst=command_line_argument_lst,
-                pmi=pmi,
             )

{executorlib-0.0.1 → executorlib-0.0.3}/executorlib/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-07-14T21:06:50+0200",
+ "date": "2024-10-01T11:57:02+0200",
  "dirty": true,
  "error": null,
- "full-revisionid": "0a84450d76b7081b62a9d948bac56f905d013b5d",
- "version": "0.0.1"
+ "full-revisionid": "aea7b11eb2b5399d4a943914aee3107f64d7f6cf",
+ "version": "0.0.3"
 }
 '''  # END VERSION_JSON
 

{executorlib-0.0.1 → executorlib-0.0.3}/executorlib/backend/cache_parallel.py

@@ -6,7 +6,21 @@ import cloudpickle
 from executorlib.cache.shared import backend_load_file, backend_write_file
 
 
-def main():
+def main() -> None:
+    """
+    Main function for executing the cache_parallel script.
+
+    This function uses MPI (Message Passing Interface) to distribute the execution of a function
+    across multiple processes. It loads a file, broadcasts the data to all processes, executes
+    the function, gathers the results (if there are multiple processes), and writes the output
+    to a file.
+
+    Args:
+        None
+
+    Returns:
+        None
+    """
     from mpi4py import MPI
 
     MPI.pickle.__init__(

{executorlib-0.0.1 → executorlib-0.0.3}/executorlib/backend/interactive_parallel.py

@@ -13,7 +13,15 @@ from executorlib.shared.communication import (
 )
 
 
-def main():
+def main() -> None:
+    """
+    Entry point of the program.
+
+    This function initializes MPI, sets up the necessary communication, and executes the requested functions.
+
+    Returns:
+        None
+    """
     from mpi4py import MPI
 
     MPI.pickle.__init__(

{executorlib-0.0.1 → executorlib-0.0.3}/executorlib/backend/interactive_serial.py

@@ -1,6 +1,6 @@
 import sys
 from os.path import abspath
-from typing import Optional
+from typing import List, Optional
 
 from executorlib.interactive.backend import call_funct, parse_arguments
 from executorlib.shared.communication import (
@@ -11,7 +11,16 @@ from executorlib.shared.communication import (
 )
 
 
-def main(argument_lst: Optional[list[str]] = None):
+def main(argument_lst: Optional[List[str]] = None):
+    """
+    The main function of the program.
+
+    Args:
+        argument_lst (Optional[List[str]]): List of command line arguments. If None, sys.argv will be used.
+
+    Returns:
+        None
+    """
     if argument_lst is None:
         argument_lst = sys.argv
     argument_dict = parse_arguments(argument_lst=argument_lst)

{executorlib-0.0.1 → executorlib-0.0.3}/executorlib/cache/executor.py

@@ -12,6 +12,14 @@ class FileExecutor(ExecutorBase):
         execute_function: callable = execute_in_subprocess,
         cores_per_worker: int = 1,
     ):
+        """
+        Initialize the FileExecutor.
+
+        Args:
+            cache_directory (str, optional): The directory to store cache files. Defaults to "cache".
+            execute_function (callable, optional): The function to execute tasks. Defaults to execute_in_subprocess.
+            cores_per_worker (int, optional): The number of CPU cores per worker. Defaults to 1.
+        """
         super().__init__()
         cache_directory_path = os.path.abspath(cache_directory)
         os.makedirs(cache_directory_path, exist_ok=True)

{executorlib-0.0.1 → executorlib-0.0.3}/executorlib/cache/hdf.py

@@ -1,12 +1,11 @@
 from typing import Tuple
 
 import cloudpickle
-import h5io
 import h5py
 import numpy as np
 
 
-def dump(file_name: str, data_dict: dict):
+def dump(file_name: str, data_dict: dict) -> None:
     """
     Dump data dictionary into HDF5 file
 
@@ -23,11 +22,9 @@ def dump(file_name: str, data_dict: dict):
     with h5py.File(file_name, "a") as fname:
         for data_key, data_value in data_dict.items():
             if data_key in group_dict.keys():
-                h5io.write_hdf5(
-                    fname=fname,
+                fname.create_dataset(
+                    name="/" + group_dict[data_key],
                     data=np.void(cloudpickle.dumps(data_value)),
-                    overwrite="update",
-                    title=group_dict[data_key],
                 )
 
 
@@ -44,21 +41,15 @@ def load(file_name: str) -> dict:
     with h5py.File(file_name, "r") as hdf:
         data_dict = {}
         if "function" in hdf:
-            data_dict["fn"] = cloudpickle.loads(
-                h5io.read_hdf5(fname=hdf, title="function", slash="ignore")
-            )
+            data_dict["fn"] = cloudpickle.loads(np.void(hdf["/function"]))
         else:
-            raise TypeError
+            raise TypeError("Function not found in HDF5 file.")
         if "input_args" in hdf:
-            data_dict["args"] = cloudpickle.loads(
-                h5io.read_hdf5(fname=hdf, title="input_args", slash="ignore")
-            )
+            data_dict["args"] = cloudpickle.loads(np.void(hdf["/input_args"]))
         else:
             data_dict["args"] = ()
         if "input_kwargs" in hdf:
-            data_dict["kwargs"] = cloudpickle.loads(
-                h5io.read_hdf5(fname=hdf, title="input_kwargs", slash="ignore")
-            )
+            data_dict["kwargs"] = cloudpickle.loads(np.void(hdf["/input_kwargs"]))
         else:
             data_dict["kwargs"] = {}
         return data_dict
@@ -72,12 +63,10 @@ def get_output(file_name: str) -> Tuple[bool, object]:
         file_name (str): file name of the HDF5 file as absolute path
 
     Returns:
-        (bool, object): boolean flag if output is available and the output object itself
+        Tuple[bool, object]: boolean flag indicating if output is available and the output object itself
     """
     with h5py.File(file_name, "r") as hdf:
         if "output" in hdf:
-            return True, cloudpickle.loads(
-                h5io.read_hdf5(fname=hdf, title="output", slash="ignore")
-            )
+            return True, cloudpickle.loads(np.void(hdf["/output"]))
         else:
             return False, None

{executorlib-0.0.1 → executorlib-0.0.3}/executorlib/cache/shared.py

@@ -6,7 +6,7 @@ import re
 import subprocess
 import sys
 from concurrent.futures import Future
-from typing import Tuple
+from typing import Any, Tuple
 
 import cloudpickle
 
@@ -16,20 +16,51 @@ from executorlib.shared.executor import get_command_path
 
 class FutureItem:
     def __init__(self, file_name: str):
+        """
+        Initialize a FutureItem object.
+
+        Args:
+            file_name (str): The name of the file.
+
+        """
         self._file_name = file_name
 
-    def result(self):
+    def result(self) -> str:
+        """
+        Get the result of the future item.
+
+        Returns:
+            str: The result of the future item.
+
+        """
         exec_flag, result = get_output(file_name=self._file_name)
         if exec_flag:
             return result
         else:
             return self.result()
 
-    def done(self):
+    def done(self) -> bool:
+        """
+        Check if the future item is done.
+
+        Returns:
+            bool: True if the future item is done, False otherwise.
+
+        """
         return get_output(file_name=self._file_name)[0]
 
 
 def backend_load_file(file_name: str) -> dict:
+    """
+    Load the data from an HDF5 file and convert FutureItem objects to their results.
+
+    Args:
+        file_name (str): The name of the HDF5 file.
+
+    Returns:
+        dict: The loaded data from the file.
+
+    """
     apply_dict = load(file_name=file_name)
     apply_dict["args"] = [
         arg if not isinstance(arg, FutureItem) else arg.result()
@@ -42,7 +73,18 @@ def backend_load_file(file_name: str) -> dict:
     return apply_dict
 
 
-def backend_write_file(file_name: str, output):
+def backend_write_file(file_name: str, output: Any) -> None:
+    """
+    Write the output to an HDF5 file.
+
+    Args:
+        file_name (str): The name of the HDF5 file.
+        output (Any): The output to be written.
+
+    Returns:
+        None
+
+    """
     file_name_out = os.path.splitext(file_name)[0]
     os.rename(file_name, file_name_out + ".h5ready")
     dump(file_name=file_name_out + ".h5ready", data_dict={"output": output})
@@ -52,6 +94,17 @@ def backend_write_file(file_name: str, output):
 def execute_in_subprocess(
     command: list, task_dependent_lst: list = []
 ) -> subprocess.Popen:
+    """
+    Execute a command in a subprocess.
+
+    Args:
+        command (list): The command to be executed.
+        task_dependent_lst (list, optional): A list of subprocesses that the current subprocess depends on. Defaults to [].
+
+    Returns:
+        subprocess.Popen: The subprocess object.
+
+    """
     while len(task_dependent_lst) > 0:
         task_dependent_lst = [
             task for task in task_dependent_lst if task.poll() is None
@@ -64,7 +117,20 @@ def execute_tasks_h5(
     cache_directory: str,
     cores_per_worker: int,
     execute_function: callable,
-):
+) -> None:
+    """
+    Execute tasks stored in a queue using HDF5 files.
+
+    Args:
+        future_queue (queue.Queue): The queue containing the tasks.
+        cache_directory (str): The directory to store the HDF5 files.
+        cores_per_worker (int): The number of cores per worker.
+        execute_function (callable): The function to execute the tasks.
+
+    Returns:
+        None
+
+    """
     memory_dict, process_dict, file_name_dict = {}, {}, {}
     while True:
         task_dict = None
@@ -117,12 +183,15 @@ def execute_tasks_h5(
             }
 
 
-def execute_task_in_file(file_name: str):
+def execute_task_in_file(file_name: str) -> None:
     """
-    Execute the task stored in a given HDF5 file
+    Execute the task stored in a given HDF5 file.
 
     Args:
-        file_name (str): file name of the HDF5 file as absolute path
+        file_name (str): The file name of the HDF5 file as an absolute path.
+
+    Returns:
+        None
     """
     apply_dict = backend_load_file(file_name=file_name)
     result = apply_dict["fn"].__call__(*apply_dict["args"], **apply_dict["kwargs"])
@@ -135,9 +204,11 @@ def execute_task_in_file(file_name: str):
 def _get_execute_command(file_name: str, cores: int = 1) -> list:
     """
     Get command to call backend as a list of two strings
+
     Args:
-        file_name (str):
-        cores (int): Number of cores used to execute the task, if it is greater than one use interactive_parallel.py else interactive_serial.py
+        file_name (str): The name of the file.
+        cores (int, optional): Number of cores used to execute the task. Defaults to 1.
+
     Returns:
         list[str]: List of strings containing the python executable path and the backend script to execute
     """
@@ -157,13 +228,35 @@ def _get_execute_command(file_name: str, cores: int = 1) -> list:
     return command_lst
 
 
-def _get_hash(binary: bytes):
+def _get_hash(binary: bytes) -> str:
+    """
+    Get the hash of a binary.
+
+    Args:
+        binary (bytes): The binary to be hashed.
+
+    Returns:
+        str: The hash of the binary.
+
+    """
     # Remove specification of jupyter kernel from hash to be deterministic
     binary_no_ipykernel = re.sub(b"(?<=/ipykernel_)(.*)(?=/)", b"", binary)
     return str(hashlib.md5(binary_no_ipykernel).hexdigest())
 
 
-def _serialize_funct_h5(fn: callable, *args, **kwargs):
+def _serialize_funct_h5(fn: callable, *args: Any, **kwargs: Any) -> Tuple[str, dict]:
+    """
+    Serialize a function and its arguments and keyword arguments into an HDF5 file.
+
+    Args:
+        fn (callable): The function to be serialized.
+        *args (Any): The arguments of the function.
+        **kwargs (Any): The keyword arguments of the function.
+
+    Returns:
+        Tuple[str, dict]: A tuple containing the task key and the serialized data.
+
+    """
     binary_all = cloudpickle.dumps({"fn": fn, "args": args, "kwargs": kwargs})
     task_key = fn.__name__ + _get_hash(binary=binary_all)
     data = {"fn": fn, "args": args, "kwargs": kwargs}
@@ -173,6 +266,18 @@ def _serialize_funct_h5(fn: callable, *args, **kwargs):
 def _check_task_output(
     task_key: str, future_obj: Future, cache_directory: str
 ) -> Future:
+    """
+    Check the output of a task and set the result of the future object if available.
+
+    Args:
+        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.
+
+    Returns:
+        Future: The updated future object.
+
+    """
     file_name = os.path.join(cache_directory, task_key + ".h5out")
     if not os.path.exists(file_name):
         return future_obj
@@ -184,7 +289,19 @@ def _check_task_output(
 
 def _convert_args_and_kwargs(
     task_dict: dict, memory_dict: dict, file_name_dict: dict
-) -> Tuple:
+) -> Tuple[list, dict, list]:
+    """
+    Convert the arguments and keyword arguments in a task dictionary to the appropriate types.
+
+    Args:
+        task_dict (dict): The task dictionary containing the arguments and keyword arguments.
+        memory_dict (dict): The dictionary mapping future objects to their associated task keys.
+        file_name_dict (dict): The dictionary mapping task keys to their corresponding file names.
+
+    Returns:
+        Tuple[list, dict, list]: A tuple containing the converted arguments, converted keyword arguments, and a list of future wait keys.
+
+    """
     task_args = []
     task_kwargs = {}
     future_wait_key_lst = []