parsl 2023.11.13__py3-none-any.whl → 2023.11.20__py3-none-any.whl

parsl/__init__.py

@@ -62,6 +62,7 @@ __all__ = [
     'ThreadPoolExecutor',
     'HighThroughputExecutor',
     'WorkQueueExecutor',
+    'RadicalPilotExecutor',
 
     # monitoring
     'MonitoringHub',

parsl/executors/base.py

@@ -5,8 +5,6 @@ from typing_extensions import Literal, Self
 
 from parsl.jobs.states import JobStatus
 
-import parsl  # noqa F401
-
 
 class ParslExecutor(metaclass=ABCMeta):
     """Executors are abstractions that represent available compute resources

parsl/executors/high_throughput/executor.py

@@ -8,7 +8,7 @@ import datetime
 import pickle
 import warnings
 from multiprocessing import Queue
-from typing import Dict, Sequence  # noqa F401 (used in type annotation)
+from typing import Dict, Sequence
 from typing import List, Optional, Tuple, Union, Callable
 import math
 

parsl/executors/radical/__init__.py

@@ -0,0 +1,4 @@
+from parsl.executors.radical.executor import RadicalPilotExecutor
+from parsl.executors.radical.rpex_resources import ResourceConfig
+
+__all__ = ['RadicalPilotExecutor', 'ResourceConfig']

parsl/executors/radical/executor.py

@@ -0,0 +1,550 @@
+"""RadicalPilotExecutor builds on the RADICAL-Pilot/Parsl
+"""
+import os
+import sys
+import time
+import parsl
+import queue
+import logging
+import inspect
+import requests
+import typeguard
+import threading as mt
+
+from functools import partial
+from typing import Optional, Dict
+from pathlib import Path, PosixPath
+from concurrent.futures import Future
+
+from parsl.app.python import timeout
+from .rpex_resources import ResourceConfig
+from parsl.data_provider.files import File
+from parsl.utils import RepresentationMixin
+from parsl.app.errors import BashExitFailure
+from parsl.executors.base import ParslExecutor
+from parsl.app.errors import RemoteExceptionWrapper
+from parsl.serialize import pack_apply_message, deserialize
+from parsl.serialize.errors import SerializationError, DeserializationError
+
+try:
+    import radical.pilot as rp
+    import radical.utils as ru
+except ImportError:
+    _rp_enabled = False
+else:
+    _rp_enabled = True
+
+
+RPEX = 'RPEX'
+BASH = 'bash'
+PYTHON = 'python'
+
+CWD = os.getcwd()
+PWD = os.path.abspath(os.path.dirname(__file__))
+
+PARSL_RP_RESOURCE_MAP = {'cores': 'ranks',
+                         'disk': 'lfs_per_rank',
+                         'memory': 'mem_per_rank'}
+
+logger = logging.getLogger(__name__)
+
+
+class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
+    """Executor is designed for executing heterogeneous tasks
+       in terms of type/resource.
+
+    The RadicalPilotExecutor system has the following components:
+
+      1. "start"    :creating the RADICAL-executor session and pilot.
+      2. "translate":unwrap/identify/ out of parsl task and construct RP task.
+      3. "submit"   :translating and submitting Parsl tasks to Radical Pilot.
+      4. "shut_down":shutting down the RADICAL-executor components.
+
+    Here is a diagram
+
+    .. code:: python
+
+      ----------------------------------------------------------------------------
+               Parsl Data Flow Kernel        |   Task Translator |  rp.TaskManager
+      ---------------------------------------|-------------------|----------------
+                                             |                   |
+      -> Dep. check ------> Parsl_tasks{} <--+--> Parsl Task     |
+       Data management          +dfk.submit  |        |          |
+                                             |        v          |
+                                             |    RP Task(s) ->  | submit(task)
+      ----------------------------------------------------------------------------
+
+    The RadicalPilotExecutor creates a ``rp.Session``, ``rp.TaskManager``,
+    and ``rp.PilotManager``. The executor receives the parsl apps from the
+    DFK and translates these apps (in-memory) into ``rp.TaskDescription``
+    object to be passed to the ``rp.TaskManager``. This executor has two
+    submission mechanisms:
+
+    1. Default_mode: where the executor submits the tasks directly to
+       RADICAL-Pilot.
+
+    2. Bulk_mode: where the executor accumulates N tasks (functions and
+       executables) and submit them.
+
+    Parameters
+    ----------
+    rpex_cfg : :class: `~parsl.executors.rpex_resources.ResourceConfig`
+        a dataclass specifying resource configuration.
+        Default is ResourceConfig instance.
+
+    label : str
+        Label for this executor instance.
+        Default is "RPEX".
+
+    bulk_mode : bool
+        Enable bulk mode submission and execution. Default is False (stream).
+
+    resource : Optional[str]
+        The resource name of the targeted HPC machine or cluster.
+        Default is local.localhost (user local machine).
+
+    runtime : int
+        The maximum runtime for the entire job in minutes.
+        Default is 30.
+
+    working_dir : str
+        The working dir to be used by the executor.
+
+    rpex_pilot_kwargs: Dict of kwargs that are passed directly to the rp.PilotDescription object.
+
+    For more information: https://radicalpilot.readthedocs.io/en/stable/
+    """
+
+    @typeguard.typechecked
+    def __init__(self,
+                 resource: str,
+                 label: str = RPEX,
+                 bulk_mode: bool = False,
+                 working_dir: Optional[str] = None,
+                 rpex_cfg: Optional[ResourceConfig] = None, **rpex_pilot_kwargs):
+
+        super().__init__()
+        self.pmgr = None
+        self.tmgr = None
+        self.run_dir = '.'
+        self.label = label
+        self.session = None
+        self.resource = resource
+        self._uid = RPEX.lower()
+        self.bulk_mode = bulk_mode
+        self.working_dir = working_dir
+        self.pilot_kwargs = rpex_pilot_kwargs
+        self.future_tasks: Dict[str, Future] = {}
+
+        if rpex_cfg:
+            self.rpex_cfg = rpex_cfg
+        elif not rpex_cfg and 'local' in resource:
+            self.rpex_cfg = ResourceConfig()
+        else:
+            raise ValueError('Resource config file must be '
+                             'specified for a non-local execution')
+
+    def task_state_cb(self, task, state):
+        """
+        Update the state of Parsl Future tasks
+        Based on RP task state callbacks.
+        """
+        if not task.uid.startswith('master'):
+            parsl_task = self.future_tasks[task.uid]
+
+            if state == rp.DONE:
+                if task.description['mode'] in [rp.TASK_EXEC,
+                                                rp.TASK_PROC,
+                                                rp.TASK_EXECUTABLE]:
+                    parsl_task.set_result(int(task.exit_code))
+                else:
+                    # we do not support MPI function output
+                    # serialization. TODO: To be fixed soon.
+                    if not task.description.get('use_mpi'):
+                        result = deserialize(eval(task.return_value))
+                        parsl_task.set_result(result)
+                    else:
+                        parsl_task.set_result(task.return_value)
+
+            elif state == rp.CANCELED:
+                parsl_task.cancel()
+
+            elif state == rp.FAILED:
+                if task.description['mode'] in [rp.TASK_EXEC,
+                                                rp.TASK_EXECUTABLE]:
+                    parsl_task.set_exception(BashExitFailure(task.name,
+                                                             task.exit_code))
+                else:
+                    if task.exception:
+                        # unpack a serialized exception
+                        if not task.description.get('use_mpi') or task.description['mode'] == rp.TASK_PROC:
+                            self._unpack_and_set_parsl_exception(parsl_task, task.exception)
+                        # we do not serialize mpi function exception
+                        else:
+                            parsl_task.set_exception(eval(task.exception))
+                    else:
+                        parsl_task.set_exception('Task failed for an unknown reason')
+
+    def start(self):
+        """Create the Pilot component and pass it.
+        """
+        logger.info("starting RadicalPilotExecutor")
+        logger.info('Parsl: {0}'.format(parsl.__version__))
+        logger.info('RADICAL pilot: {0}'.format(rp.version))
+        self.session = rp.Session(cfg={'base': self.run_dir},
+                                  uid=ru.generate_id('rpex.session',
+                                                     mode=ru.ID_PRIVATE))
+        logger.info("RPEX session is created: {0}".format(self.session.path))
+
+        pd_init = {**self.pilot_kwargs,
+                   'exit_on_error': True,
+                   'resource': self.resource}
+
+        if not self.resource or 'local' in self.resource:
+            # move the agent sandbox to the working dir mainly
+            # for debugging purposes. This will allow parsl
+            # to include the agent sandbox with the ci artifacts.
+            if os.environ.get("LOCAL_SANDBOX"):
+                pd_init['sandbox'] = self.run_dir
+                os.environ["RADICAL_LOG_LVL"] = "DEBUG"
+
+            logger.info("RPEX will be running in the local mode")
+
+        pd = rp.PilotDescription(pd_init)
+        pd.verify()
+
+        self.rpex_cfg = self.rpex_cfg._get_cfg_file(path=self.run_dir)
+        cfg = ru.Config(cfg=ru.read_json(self.rpex_cfg))
+
+        self.master = cfg.master_descr
+        self.n_masters = cfg.n_masters
+
+        tds = list()
+        master_path = '{0}/rpex_master.py'.format(PWD)
+        worker_path = '{0}/rpex_worker.py'.format(PWD)
+
+        for i in range(self.n_masters):
+            td = rp.TaskDescription(self.master)
+            td.mode = rp.RAPTOR_MASTER
+            td.uid = ru.generate_id('master.%(item_counter)06d', ru.ID_CUSTOM,
+                                    ns=self.session.uid)
+            td.ranks = 1
+            td.cores_per_rank = 1
+            td.arguments = [self.rpex_cfg, i]
+            td.input_staging = self._stage_files([File(master_path),
+                                                  File(worker_path),
+                                                  File(self.rpex_cfg)], mode='in')
+            tds.append(td)
+
+        self.pmgr = rp.PilotManager(session=self.session)
+        self.tmgr = rp.TaskManager(session=self.session)
+
+        # submit pilot(s)
+        pilot = self.pmgr.submit_pilots(pd)
+        if not pilot.description.get('cores'):
+            logger.warning('no "cores" per pilot was set, using default resources {0}'.format(pilot.resources))
+
+        self.tmgr.submit_tasks(tds)
+
+        # prepare or use the current env for the agent/pilot side environment
+        if cfg.pilot_env_mode != 'client':
+            logger.info("creating {0} environment for the executor".format(cfg.pilot_env.name))
+            pilot.prepare_env(env_name=cfg.pilot_env.name,
+                              env_spec=cfg.pilot_env.as_dict())
+        else:
+            client_env = sys.prefix
+            logger.info("reusing ({0}) environment for the executor".format(client_env))
+
+        self.tmgr.add_pilots(pilot)
+        self.tmgr.register_callback(self.task_state_cb)
+
+        # create a bulking thread to run the actual task submission
+        # to RP in bulks
+        if self.bulk_mode:
+            self._max_bulk_size = 1024
+            self._max_bulk_time = 3        # seconds
+            self._min_bulk_time = 0.1      # seconds
+
+            self._bulk_queue = queue.Queue()
+            self._bulk_thread = mt.Thread(target=self._bulk_collector)
+
+            self._bulk_thread.daemon = True
+            self._bulk_thread.start()
+
+        return True
+
+    def unwrap(self, func, args):
+        """
+        Unwrap a parsl app and its args for further processing.
+
+        Parameters
+        ----------
+        func : callable
+            The function to be unwrapped.
+
+        args : tuple
+            The arguments associated with the function.
+
+        Returns
+        -------
+        tuple
+            A tuple containing the unwrapped function, adjusted arguments,
+            and task type information.
+        """
+
+        task_type = ''
+
+        while hasattr(func, '__wrapped__'):
+            func = func.__wrapped__
+
+        try:
+            if isinstance(func, partial):
+                try:
+                    task_type = inspect.getsource(func.args[0]).split('\n')[0]
+                    if BASH in task_type:
+                        task_type = BASH
+                        func = func.args[0]
+                    else:
+                        task_type = PYTHON
+
+                except Exception:
+                    logger.exception('unwrap failed')
+
+                    return func, args, task_type
+
+            else:
+                task_type = inspect.getsource(func).split('\n')[0]
+                if PYTHON in task_type:
+                    task_type = PYTHON
+                else:
+                    task_type = ''
+        except Exception as e:
+            raise Exception('failed to obtain task type: {0}'.format(e))
+
+        return func, args, task_type
+
+    def task_translate(self, tid, func, parsl_resource_specification, args, kwargs):
+        """
+        Convert parsl function to RADICAL-Pilot rp.TaskDescription
+        """
+
+        task = rp.TaskDescription()
+        task.name = func.__name__
+
+        if parsl_resource_specification and isinstance(parsl_resource_specification, dict):
+            logger.debug('mapping parsl resource specifications >> rp resource specifications')
+            for key, val in parsl_resource_specification.items():
+                if key not in task.as_dict():
+                    key = PARSL_RP_RESOURCE_MAP.get(key, None)
+                    if not key:
+                        logger.warning('ignoring "{0}" key from task resource specification as it is not supported by RP'.format(key))
+                        continue
+                setattr(task, key, val)
+
+        func, args, task_type = self.unwrap(func, args)
+
+        if BASH in task_type:
+            if callable(func):
+                # if the user specifies the executable mode then we expect the
+                # a code in a file that need to be executed in an isolated env.
+                if parsl_resource_specification.get('mode') == rp.TASK_EXECUTABLE:
+                    # These lines of code are from parsl/app/bash.py
+                    try:
+                        # Execute the func to get the command
+                        bash_app = func(*args, **kwargs)
+                        if not isinstance(bash_app, str):
+                            raise ValueError("Expected a str for bash_app cmd,"
+                                             "got: {0}".format(type(bash_app)))
+                    except AttributeError as e:
+                        raise Exception("failed to obtain bash app cmd") from e
+
+                    task.executable = bash_app
+                    task.mode = rp.TASK_EXECUTABLE
+
+                # This is the default mode where the bash_app will be executed as
+                # as a single core process by RP. For cores > 1 the user must use
+                # above or use MPI functions if their code is Python.
+                else:
+                    task.mode = rp.TASK_PROC
+                    task.raptor_id = 'master.%06d' % (tid % self.n_masters)
+                    task.executable = self._pack_and_apply_message(func, args, kwargs)
+
+        elif PYTHON in task_type or not task_type:
+            task.mode = rp.TASK_FUNCTION
+            task.raptor_id = 'master.%06d' % (tid % self.n_masters)
+            if kwargs.get('walltime'):
+                func = timeout(func, kwargs['walltime'])
+
+            # we process MPI function differently
+            if 'comm' in kwargs:
+                task.function = rp.PythonTask(func, *args, **kwargs)
+            else:
+                task.function = self._pack_and_apply_message(func, args, kwargs)
+
+        task.input_staging = self._stage_files(kwargs.get("inputs", []),
+                                               mode='in')
+        task.output_staging = self._stage_files(kwargs.get("outputs", []),
+                                                mode='out')
+
+        task.input_staging.extend(self._stage_files(list(args), mode='in'))
+
+        self._set_stdout_stderr(task, kwargs)
+
+        try:
+            task.verify()
+        except ru.typeddict.TDKeyError as e:
+            raise Exception(f'{e}. Please check Radical.Pilot TaskDescription documentation')
+
+        return task
+
+    def _pack_and_apply_message(self, func, args, kwargs):
+        try:
+            buffer = pack_apply_message(func, args, kwargs,
+                                        buffer_threshold=1024 * 1024)
+            task_func = rp.utils.serialize_bson(buffer)
+        except TypeError:
+            raise SerializationError(func.__name__)
+
+        return task_func
+
+    def _unpack_and_set_parsl_exception(self, parsl_task, exception):
+        try:
+            s = rp.utils.deserialize_bson(exception)
+            if isinstance(s, RemoteExceptionWrapper):
+                try:
+                    s.reraise()
+                except Exception as e:
+                    parsl_task.set_exception(e)
+            elif isinstance(s, Exception):
+                parsl_task.set_exception(s)
+            else:
+                raise ValueError("Unknown exception-like type received: {}".format(type(s)))
+        except Exception as e:
+            parsl_task.set_exception(
+                DeserializationError("Received exception, but handling also threw an exception: {}".format(e)))
+
+    def _set_stdout_stderr(self, task, kwargs):
+        """
+        set the stdout and stderr of a task
+        """
+        for k in ['stdout', 'stderr']:
+            k_val = kwargs.get(k, '')
+            if k_val:
+                # check the type of the stderr/out
+                if isinstance(k_val, File):
+                    k_val = k_val.filepath
+                elif isinstance(k_val, PosixPath):
+                    k_val = k_val.__str__()
+
+                # if the stderr/out has no path
+                # then we consider it local and
+                # we just set the path to the cwd
+                if '/' not in k_val:
+                    k_val = CWD + '/' + k_val
+
+                # finally set the stderr/out to
+                # the desired name by the user
+                setattr(task, k, k_val)
+                task.sandbox = Path(k_val).parent.__str__()
+
+    def _stage_files(self, files, mode):
+        """
+        a function to stage list of input/output
+        files between two locations.
+        """
+        to_stage = []
+        files = [f for f in files if isinstance(f, File)]
+        for file in files:
+            if mode == 'in':
+                # a workaround RP not supporting
+                # staging https file
+                if file.scheme == 'https':
+                    r = requests.get(file.url)
+                    p = CWD + '/' + file.filename
+                    with open(p, 'wb') as ff:
+                        ff.write(r.content)
+                    file = File(p)
+
+                f = {'source': file.url,
+                     'action': rp.TRANSFER}
+                to_stage.append(f)
+
+            elif mode == 'out':
+                # this indicates that the user
+                # did not provided a specific
+                # output file and RP will stage out
+                # the task.output from pilot://task_folder
+                # to the CWD or file.url
+                if '/' not in file.url:
+                    f = {'source': file.filename,
+                         'target': file.url,
+                         'action': rp.TRANSFER}
+                    to_stage.append(f)
+            else:
+                raise ValueError('unknown staging mode')
+
+        return to_stage
+
+    def _bulk_collector(self):
+
+        bulk = list()
+
+        while True:
+
+            now = time.time()  # time of last submission
+
+            # collect tasks for min bulk time
+            # NOTE: total collect time could actually be max_time + min_time
+            while time.time() - now < self._max_bulk_time:
+
+                try:
+                    task = self._bulk_queue.get(block=True,
+                                                timeout=self._min_bulk_time)
+                except queue.Empty:
+                    task = None
+
+                if task:
+                    bulk.append(task)
+
+                if len(bulk) >= self._max_bulk_size:
+                    break
+
+            if bulk:
+                logger.debug('submit bulk: %d', len(bulk))
+                self.tmgr.submit_tasks(bulk)
+                bulk = list()
+
+    def submit(self, func, resource_specification, *args, **kwargs):
+        """
+        Submits tasks in stream mode or bulks (bulk mode)
+        to RADICAL-Pilot rp.TaskManager.
+        """
+        rp_tid = ru.generate_id('task.%(item_counter)06d', ru.ID_CUSTOM,
+                                ns=self.session.uid)
+        parsl_tid = int(rp_tid.split('task.')[1])
+
+        logger.debug("got Task {0} from parsl-dfk".format(parsl_tid))
+        task = self.task_translate(parsl_tid, func, resource_specification, args, kwargs)
+
+        # assign task id for rp task
+        task.uid = rp_tid
+
+        # set the future with corresponding id
+        self.future_tasks[rp_tid] = Future()
+
+        if self.bulk_mode:
+            # push task to rp submit thread
+            self._bulk_queue.put(task)
+        else:
+            # submit the task to rp
+            logger.debug("put {0} to rp-TMGR".format(rp_tid))
+            self.tmgr.submit_tasks(task)
+
+        return self.future_tasks[rp_tid]
+
+    def shutdown(self, hub=True, targets='all', block=False):
+        """Shutdown the executor, including all RADICAL-Pilot components."""
+        logger.info("RadicalPilotExecutor shutdown")
+        self.session.close(download=True)
+
+        return True

parsl/executors/radical/rpex_master.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+
+import sys
+
+import radical.utils as ru
+import radical.pilot as rp
+
+
+# ------------------------------------------------------------------------------
+#
+if __name__ == '__main__':
+
+    # The purpose of this master is to (a) spawn a set or workers
+    # within the same allocation, (b) to distribute work items to
+    # those workers, and (c) to collect the responses again.
+    cfg_fname = str(sys.argv[1])
+    cfg = ru.Config(cfg=ru.read_json(cfg_fname))
+    cfg.rank = int(sys.argv[2])
+
+    worker_descr = cfg.worker_descr
+    n_workers = cfg.n_workers
+    gpus_per_node = cfg.gpus_per_node
+    cores_per_node = cfg.cores_per_node
+    nodes_per_worker = cfg.nodes_per_worker
+
+    # create a master class instance - this will establish communication
+    # to the pilot agent
+    master = rp.raptor.Master(cfg)
+
+    # insert `n` worker into the agent.  The agent will schedule (place)
+    # those workers and execute them.
+    worker_descr['ranks'] = nodes_per_worker * cores_per_node
+    worker_descr['gpus_per_rank'] = nodes_per_worker * gpus_per_node
+    worker_ids = master.submit_workers(
+                 [rp.TaskDescription(worker_descr) for _ in range(n_workers)])
+
+    # wait for all workers
+    master.wait_workers()
+    master.start()
+    master.join()
+
+# ------------------------------------------------------------------------------

parsl/executors/radical/rpex_resources.py

@@ -0,0 +1,165 @@
+import sys
+import json
+
+from typing import List
+
+_setup_paths: List[str]
+try:
+    import radical.pilot as rp
+    import radical.utils as ru
+except ImportError:
+    _setup_paths = []
+else:
+    _setup_paths = [rp.sdist_path,
+                    ru.sdist_path]
+
+
+MPI = "mpi"
+RP_ENV = "rp"
+CLIENT = "client"
+RPEX_ENV = "ve_rpex"
+MPI_WORKER = "MPIWorker"
+DEFAULT_WORKER = "DefaultWorker"
+
+
+class ResourceConfig:
+    """
+    This ResourceConfig class is an abstraction of the resource
+    configuration of the RAPTOR layer in the RADICAL-Pilot runtime system.
+
+    This class sets up the default configuration values for the executor and
+    allows the user to specify different resource requirements flexibly.
+
+    For more information:
+    https://radicalpilot.readthedocs.io/en/stable/tutorials/raptor.html
+
+    Parameters
+    ----------
+    masters : int
+        The number of masters to be deployed by RAPTOR.
+        Default is 1.
+
+    workers : int
+        The number of workers to be deployed by RAPTOR.
+        Default is 1.
+
+    worker_gpus_per_node : int
+        The number of GPUs a worker will operate on per node.
+        Default is 0.
+
+    worker_cores_per_node : int
+        The number of CPU cores a worker will operate on per node.
+        Default is 4.
+
+    cores_per_master : int
+        The number of cores a master will operate on per node.
+        Default is 1.
+
+    nodes_per_worker : int
+        The number of nodes to be occupied by every worker.
+        Default is 1.
+
+    pilot_env_path : str
+        The path to an exisitng pilot environment.
+        Default is an empty string (RADICAL-Pilot will create one).
+
+    pilot_env_name : str
+        The name of the pilot environment.
+        Default is "ve_rpex".
+
+    pilot_env_pre_exec : list
+        List of commands to be executed before starting the pilot environment.
+        Default is an empty list.
+
+    pilot_env_type : str
+        The type of the pilot environment (e.g., 'venv', 'conda').
+        Default is "venv".
+
+    pilot_env_setup : list
+        List of setup commands/packages for the pilot environment.
+        Default setup includes "parsl", rp.sdist_path, and ru.sdist_path.
+
+    python_v : str
+        The Python version to be used in the pilot environment.
+        Default is determined by the system's Python version.
+
+    worker_type : str
+        The type of worker(s) to be deployed by RAPTOR on the compute
+        resources.
+        Default is "DefaultWorker".
+    """
+
+    masters: int = 1
+    workers: int = 1
+
+    worker_gpus_per_node: int = 0
+    worker_cores_per_node: int = 4
+
+    cores_per_master: int = 1
+    nodes_per_worker: int = 1
+
+    pilot_env_mode: str = CLIENT
+    pilot_env_path: str = ""
+    pilot_env_type: str = "venv"
+    pilot_env_name: str = RP_ENV
+    pilot_env_pre_exec: List[str] = []
+    pilot_env_setup: List[str] = _setup_paths
+
+    python_v: str = f'{sys.version_info[0]}.{sys.version_info[1]}'
+    worker_type: str = DEFAULT_WORKER
+
+    def _get_cfg_file(cls, path=None):
+
+        # Default ENV mode for RP is to reuse
+        # the client side. If this is not the case,
+        # then RP will create a new env named ve_rpex
+        # The user need to make sure that under:
+        # $HOME/.radical/pilot/configs/*_resource.json
+        # that virtenv_mode = local
+        if cls.pilot_env_mode != CLIENT:
+            cls.pilot_env_name = RPEX_ENV
+
+        if MPI in cls.worker_type.lower() and \
+           "mpi4py" not in cls.pilot_env_setup:
+            cls.pilot_env_setup.append("mpi4py")
+
+        cfg = {
+            'n_masters': cls.masters,
+            'n_workers': cls.workers,
+            'gpus_per_node': cls.worker_gpus_per_node,
+            'cores_per_node': cls.worker_cores_per_node,
+            'cores_per_master': cls.cores_per_master,
+            'nodes_per_worker': cls.nodes_per_worker,
+
+            'pilot_env': {
+                "version": cls.python_v,
+                "name": cls.pilot_env_name,
+                "path": cls.pilot_env_path,
+                "type": cls.pilot_env_type,
+                "setup": cls.pilot_env_setup,
+                "pre_exec": cls.pilot_env_pre_exec
+            },
+
+            'pilot_env_mode': cls.pilot_env_mode,
+
+            'master_descr': {
+                "mode": rp.RAPTOR_MASTER,
+                "named_env": cls.pilot_env_name,
+                "executable": "python3 rpex_master.py",
+            },
+
+            'worker_descr': {
+                "mode": rp.RAPTOR_WORKER,
+                "named_env": cls.pilot_env_name,
+                "raptor_file": "./rpex_worker.py",
+                "raptor_class": cls.worker_type if
+                cls.worker_type.lower() != MPI else MPI_WORKER,
+            }}
+
+        # Convert the class instance to a cfg file.
+        config_path = 'rpex.cfg'
+        if path:
+            config_path = path + '/' + config_path
+        with open(config_path, 'w') as f:
+            json.dump(cfg, f, indent=4)
+        return config_path

parsl/executors/radical/rpex_worker.py

@@ -0,0 +1,61 @@
+import sys
+import radical.pilot as rp
+
+import parsl.app.errors as pe
+from parsl.app.bash import remote_side_bash_executor
+from parsl.serialize import unpack_apply_message, serialize
+from parsl.executors.high_throughput.process_worker_pool import execute_task
+
+
+class ParslWorker:
+
+    def _dispatch_func(self, task):
+
+        try:
+            buffer = rp.utils.deserialize_bson(task['description']['function'])
+            result = execute_task(buffer)
+            val = str(serialize(result, buffer_threshold=1000000))
+            exc = (None, None)
+            ret = 0
+            out = None
+            err = None
+        except Exception:
+            val = None
+            exc = (rp.utils.serialize_bson(pe.RemoteExceptionWrapper(*sys.exc_info())), None)
+            ret = 1
+            out = None
+            err = None
+
+        return out, err, ret, val, exc
+
+    def _dispatch_proc(self, task):
+
+        try:
+            buffer = rp.utils.deserialize_bson(task['description']['executable'])
+            func, args, kwargs = unpack_apply_message(buffer, {}, copy=False)
+            ret = remote_side_bash_executor(func, *args, **kwargs)
+            exc = (None, None)
+            val = None
+            out = None
+            err = None
+        except Exception:
+            val = None
+            exc = (rp.utils.serialize_bson(pe.RemoteExceptionWrapper(*sys.exc_info())), None)
+            ret = 1
+            out = None
+            err = None
+
+        return out, err, ret, val, exc
+
+
+class MPIWorker(rp.raptor.MPIWorker):
+    def _dispatch_func(self, task):
+        return super()._dispatch_func(task)
+
+
+class DefaultWorker(rp.raptor.DefaultWorker):
+    def _dispatch_func(self, task):
+        return ParslWorker()._dispatch_func(task)
+
+    def _dispatch_proc(self, task):
+        return ParslWorker()._dispatch_proc(task)

parsl/executors/status_handling.py

@@ -6,7 +6,6 @@ from abc import abstractmethod, abstractproperty
 from concurrent.futures import Future
 from typing import List, Any, Dict, Optional, Tuple, Union, Callable
 
-import parsl  # noqa F401
 from parsl.executors.base import ParslExecutor
 from parsl.executors.errors import BadStateException, ScalingFailed
 from parsl.jobs.states import JobStatus, JobState

parsl/jobs/job_status_poller.py

@@ -1,9 +1,8 @@
 import logging
-import parsl  # noqa F401 (used in string type annotation)
+import parsl
 import time
 import zmq
-from typing import Dict, Sequence
-from typing import List  # noqa F401 (used in type annotation)
+from typing import Dict, List, Sequence
 
 from parsl.jobs.states import JobStatus, JobState
 from parsl.jobs.strategy import Strategy

parsl/tests/configs/local_radical.py

@@ -0,0 +1,20 @@
+import os
+
+from parsl.config import Config
+from parsl.executors.radical import RadicalPilotExecutor
+from parsl.executors.radical import ResourceConfig
+
+
+rpex_cfg = ResourceConfig()
+
+
+def fresh_config():
+
+    return Config(
+            executors=[
+                RadicalPilotExecutor(
+                    label='RPEXBulk',
+                    rpex_cfg=rpex_cfg,
+                    bulk_mode=True,
+                    resource='local.localhost',
+                    runtime=30, cores=4)])

parsl/tests/configs/local_radical_mpi.py

@@ -0,0 +1,20 @@
+import os
+from parsl.config import Config
+
+
+def fresh_config():
+    from parsl.executors.radical import ResourceConfig
+    from parsl.executors.radical import RadicalPilotExecutor
+
+    rpex_cfg = ResourceConfig()
+    rpex_cfg.worker_type = "MPI"
+    rpex_cfg.worker_cores_per_node = 7
+
+    return Config(
+            executors=[
+                RadicalPilotExecutor(
+                    label='RPEXMPI',
+                    rpex_cfg=rpex_cfg,
+                    bulk_mode=True,
+                    resource='local.localhost',
+                    runtime=30, cores=8)])

parsl/tests/test_python_apps/test_garbage_collect.py

@@ -5,7 +5,7 @@ import pytest
 
 import parsl
 from parsl.app.app import python_app
-from parsl.tests.configs.local_threads import fresh_config as local_config  # noqa
+from parsl.tests.configs.local_threads import fresh_config as local_config
 
 
 @python_app

parsl/tests/test_radical/test_mpi_funcs.py

@@ -0,0 +1,27 @@
+import parsl
+import pytest
+
+from parsl.tests.configs.local_radical_mpi import fresh_config as local_config
+
+
+@parsl.python_app
+def test_mpi_func(msg, sleep, comm=None, parsl_resource_specification={}):
+    import time
+    msg = 'hello %d/%d: %s' % (comm.rank, comm.size, msg)
+    time.sleep(sleep)
+    print(msg)
+    return comm.size
+
+
+apps = []
+
+
+@pytest.mark.local
+def test_radical_mpi(n=7):
+    # rank size should be > 1 for the
+    # radical runtime system to run this function in MPI env
+    for i in range(2, n):
+        spec = {'ranks': i}
+        t = test_mpi_func(msg='mpi.func.%06d' % i, sleep=1, comm=None, parsl_resource_specification=spec)
+        apps.append(t)
+    assert [len(app.result()) for app in apps] == list(range(2, n))

parsl/tests/test_regression/test_1606_wait_for_current_tasks.py

@@ -4,7 +4,7 @@ import time
 import pytest
 
 import parsl
-from parsl.tests.configs.local_threads import fresh_config as local_config  # noqa
+from parsl.tests.configs.local_threads import fresh_config as local_config
 
 
 @parsl.python_app

parsl/version.py

@@ -3,4 +3,4 @@
 Year.Month.Day[alpha/beta/..]
 Alphas will be numbered like this -> 2024.12.10a0
 """
-VERSION = '2023.11.13'
+VERSION = '2023.11.20'

{parsl-2023.11.13.dist-info → parsl-2023.11.20.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: parsl
-Version: 2023.11.13
+Version: 2023.11.20
 Summary: Simple data dependent workflows in Python
 Home-page: https://github.com/Parsl/parsl
-Download-URL: https://github.com/Parsl/parsl/archive/2023.11.13.tar.gz
+Download-URL: https://github.com/Parsl/parsl/archive/2023.11.20.tar.gz
 Author: The Parsl Team
 Author-email: parsl@googlegroups.com
 License: Apache 2.0
@@ -53,6 +53,7 @@ Requires-Dist: pyyaml ; extra == 'all'
 Requires-Dist: cffi ; extra == 'all'
 Requires-Dist: jsonschema ; extra == 'all'
 Requires-Dist: proxystore ; extra == 'all'
+Requires-Dist: radical.pilot ; extra == 'all'
 Provides-Extra: aws
 Requires-Dist: boto3 ; extra == 'aws'
 Provides-Extra: azure
@@ -79,6 +80,8 @@ Provides-Extra: oauth_ssh
 Requires-Dist: oauth-ssh >=0.9 ; extra == 'oauth_ssh'
 Provides-Extra: proxystore
 Requires-Dist: proxystore ; extra == 'proxystore'
+Provides-Extra: radical-pilot
+Requires-Dist: radical.pilot ; extra == 'radical-pilot'
 Provides-Extra: visualization
 Requires-Dist: pydot ; extra == 'visualization'
 Requires-Dist: networkx <2.6,>=2.5 ; extra == 'visualization'

{parsl-2023.11.13.dist-info → parsl-2023.11.20.dist-info}/RECORD

@@ -1,4 +1,4 @@
-parsl/__init__.py,sha256=Upt6uQ2ipDF5IV6nZ2angE91MPhxBmo6l75YVi6Mbro,1815
+parsl/__init__.py,sha256=hq8rJmP59wzd9-yxaGcmq5gPpshOopH-Y1K0BkUBNY0,1843
 parsl/addresses.py,sha256=L4RjQ-jGY9RfT-hBpsGw1uCzWaIdrEKxcPWV-TkGJes,4767
 parsl/config.py,sha256=ysUWBfm9bygayHHdItaJbP4oozkHJJmVQVnWCt5igjE,6808
 parsl/errors.py,sha256=SzINzQFZDBDbj9l-DPQznD0TbGkNhHIRAPkcBCogf_A,1019
@@ -7,7 +7,7 @@ parsl/multiprocessing.py,sha256=uY64wcQmWt2rgylQm4lmr3HE8AxwFGeQQj4l1jKnnrY,1970
 parsl/process_loggers.py,sha256=1G3Rfrh5wuZNo2X03grG4kTYPGOxz7hHCyG6L_A3b0A,1137
 parsl/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/utils.py,sha256=_flbNpTu6IXHbzIyE5JkUbOBIK4poc1R1bjBtwJUVdo,11622
-parsl/version.py,sha256=xpF7zP_5i_aMX1CNkBN0gPhAOjA5nZ7j1nKxfeubjG8,131
+parsl/version.py,sha256=BWsiVCPivo19VLVK8LWkn31R3xA4BSgmmc-A9-ilTX4,131
 parsl/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/app/app.py,sha256=wAHchJetgnicT1pn0NJKDeDX0lV3vDFlG8cQd_Ciax4,8522
 parsl/app/bash.py,sha256=bx9x1XFwkOTpZZD3CPwnVL9SyNRDjbUGtOnuGLvxN_8,5396
@@ -70,9 +70,9 @@ parsl/dataflow/rundirs.py,sha256=XKmBZpBEIsGACBhYOkbbs2e5edC0pQegJcSlk4FWeag,115
 parsl/dataflow/states.py,sha256=hV6mfv-y4A6xrujeQglcomnfEs7y3Xm2g6JFwC6dvgQ,2612
 parsl/dataflow/taskrecord.py,sha256=QlsOUacZZq-sU25P-VmA0xDVUktRFEVRmJoWv3Oyzz0,3105
 parsl/executors/__init__.py,sha256=J50N97Nm9YRjz6K0oNXDxUYIsDjL43_tp3LVb2w7n-M,381
-parsl/executors/base.py,sha256=dINuxWwJnd-As238pNwUPQ_PrCj-kMseDqeaMEAUmeA,4367
+parsl/executors/base.py,sha256=DyKzXZztPagh9xQykTUuJRMR9g3i6qkbZi8YpWrIfXM,4340
 parsl/executors/errors.py,sha256=xVswxgi7vmJcUMCeYDAPK8sQT2kHFFROVoOr0dnmcWE,2098
-parsl/executors/status_handling.py,sha256=KSWUEnhC1dkpr94wWsBApsmrvOVn-WRJCoIUUNnsTw4,10966
+parsl/executors/status_handling.py,sha256=GNBYrAhOpHSnmJA0NouK9by_uJxXn8vlPgBhcp0pSFo,10940
 parsl/executors/threads.py,sha256=bMU3JFghm17Lpcua13pr3NgQhkUDDc2mqvF2yJBrVNQ,3353
 parsl/executors/flux/__init__.py,sha256=P9grTTeRPXfqXurFhlSS7XhmE6tTbnCnyQ1f9b-oYHE,136
 parsl/executors/flux/execute_parsl_task.py,sha256=yUG_WjZLcX8LrgPl26mpEBWZhQMlVNbRLGu08yIjdf4,1553
@@ -80,13 +80,18 @@ parsl/executors/flux/executor.py,sha256=tf9xPmWgEsgEjzs89dJ-sMx-QaqRpM1R1crX3tp0
 parsl/executors/flux/flux_instance_manager.py,sha256=tTEOATClm9SwdgLeBRWPC6D55iNDuh0YxqJOw3c3eQ4,2036
 parsl/executors/high_throughput/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/executors/high_throughput/errors.py,sha256=vl69wLuVOplbKxHI9WphEGBExHWkTn5n8T9QhBXuNH0,380
-parsl/executors/high_throughput/executor.py,sha256=583WqjGRa3G5yHe9uElYQecYrok5LB4txwFXe0DCjyA,33845
+parsl/executors/high_throughput/executor.py,sha256=LXKYFoFqtCQ5H-B3_NI-Syncln8NlwcfWF01sd-eQcc,33806
 parsl/executors/high_throughput/interchange.py,sha256=tX_EvQf7WkSKMJG-TNmA-WADjhtKZqviYpM406Td4dA,29334
 parsl/executors/high_throughput/manager_record.py,sha256=T8-JVMfDJU6SJfzJRooD0mO8AHGMXlcn3PBOM0m_vng,366
 parsl/executors/high_throughput/monitoring_info.py,sha256=3gQpwQjjNDEBz0cQqJZB6hRiwLiWwXs83zkQDmbOwxY,297
 parsl/executors/high_throughput/probe.py,sha256=lvnuf-vBv57tHvFh-J51F9sDYBES7jCgs6KYgWvmKRs,2749
 parsl/executors/high_throughput/process_worker_pool.py,sha256=SFDDeDmKmVbP94rKDG9cV1tnO75zoXj4-InakIWCRZk,33032
 parsl/executors/high_throughput/zmq_pipes.py,sha256=3-UrPu4DlXYb6JufjBcENspLd31Qk5URDaZP6IyC6SM,5720
+parsl/executors/radical/__init__.py,sha256=CKbtV2numw5QvgIBq1htMUrt9TqDCIC2zifyf2svTNU,186
+parsl/executors/radical/executor.py,sha256=ZYycq58jXlBlhmIO1355JCK1xIJHkspiy62NN1XiMYQ,20729
+parsl/executors/radical/rpex_master.py,sha256=nMGxYWw3r-8_vZVnEwfB5eCfdTqXkeQDP5yvU0jXgc8,1368
+parsl/executors/radical/rpex_resources.py,sha256=d7QlJYBkWE-lPauetroEGIbA8RyVILA699LG0uNviws,4960
+parsl/executors/radical/rpex_worker.py,sha256=xPkjYdlXc3kjN-95NTMiQ5s-yU3JFDCA3sruPTxF3XU,1834
 parsl/executors/taskvine/__init__.py,sha256=sWIJdvSLgQKul9dlSjIkNat7yBDgU3SrBF3X2yhT86E,293
 parsl/executors/taskvine/errors.py,sha256=MNS_NjpvHjwevQXOjqjSEBFroqEWi-LT1ZEVZ2C5Dx0,652
 parsl/executors/taskvine/exec_parsl_function.py,sha256=oUAKbPWwpbzWwQ47bZQlVDxS8txhnhPsonMf3AOEMGQ,7085
@@ -105,7 +110,7 @@ parsl/executors/workqueue/parsl_coprocess_stub.py,sha256=_bJmpPIgL42qM6bVzeEKt1M
 parsl/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/jobs/error_handlers.py,sha256=WYn69jtWgfEsThCMxkGvJ2qoCfebc4IGd4JEolj2ww8,2279
 parsl/jobs/errors.py,sha256=cpSQXCrlKtuHsQf7usjF-lX8XsDkFnE5kWpmFjiN6OU,178
-parsl/jobs/job_status_poller.py,sha256=RmbBCyEYJXPas6MTMCDQWKy3JG6CiX6gJRQJWBLzpRo,4964
+parsl/jobs/job_status_poller.py,sha256=Q57s6FfWP7LjfUSPAOZ0sT59zpUxnyFNE5BZu-xRNvM,4861
 parsl/jobs/states.py,sha256=olCTMvAGRSDKLxdpH5ZhtwwSLbqDhJPCUJJyTqPkMhk,3809
 parsl/jobs/strategy.py,sha256=9V07D8bydpyxvNNRH89JZa0Pt-bjjowrSmCc5mv6awY,12903
 parsl/launchers/__init__.py,sha256=k8zAB3IBP-brfqXUptKwGkvsIRaXjAJZNBJa2XVtY1A,546
@@ -214,6 +219,8 @@ parsl/tests/configs/htex_local_alternate.py,sha256=6FsizxGFamcY_GhvJL4dHEXkchAAe
 parsl/tests/configs/htex_local_intask_staging.py,sha256=RZfHQbSN_GcAKssxZgMG6uD_VE9l2X1VMZ5eyqpU-d4,860
 parsl/tests/configs/htex_local_rsync_staging.py,sha256=KL76K8gEgbdf5S9RGDStBWrKteEY3B_2HuXVHF2b5xI,914
 parsl/tests/configs/local_adhoc.py,sha256=y91RPFcKFcH--9oljkRywxwy5KgEo6JwxRkFt97YDqM,443
+parsl/tests/configs/local_radical.py,sha256=-fk0vRUsYETBirm_PHSxBxu8qMwUwqidV_HarDxUZpQ,489
+parsl/tests/configs/local_radical_mpi.py,sha256=K6V2HbARujaow5DBAUYSIWt1RaYbt898FCVe7UJ5Ckw,570
 parsl/tests/configs/local_threads.py,sha256=oEnQSlom_JMLFX9_Ln49JAfOP3nSMbw8gTaDJo_NYfo,202
 parsl/tests/configs/local_threads_checkpoint.py,sha256=Ex7CI1Eo6wVRsem9uXTtbVJrkKc_vOYlVvCNa2RLpIo,286
 parsl/tests/configs/local_threads_checkpoint_dfk_exit.py,sha256=ECL1n0uBsXDuW3sLCmjiwe8s3Xd7EFIj5wt446w6bh4,254
@@ -351,7 +358,7 @@ parsl/tests/test_python_apps/test_fail.py,sha256=0Gld8LS6NB0Io1bU82vVR73twkuL5nW
 parsl/tests/test_python_apps/test_fibonacci_iterative.py,sha256=ly2s5HuB9R53Z2FM_zy0WWdOk01iVhgcwSpQyK6ErIY,573
 parsl/tests/test_python_apps/test_fibonacci_recursive.py,sha256=q7LMFcu_pJSNPdz8iY0UiRoIweEWIBGwMjQffHWAuDc,592
 parsl/tests/test_python_apps/test_futures.py,sha256=ye0i4pQz6uPflOOxkJ8BPM1xSphmLthTxaL3OrlY17o,2354
-parsl/tests/test_python_apps/test_garbage_collect.py,sha256=60XA6SuG9jhuIIQuNIy7haS4_MxT1_mdVhkqyAA_aTc,1084
+parsl/tests/test_python_apps/test_garbage_collect.py,sha256=RPntrLuzPkeNbhS7mmqEnHbyOcuV1YVppgZ8BaX-h84,1076
 parsl/tests/test_python_apps/test_import_fail.py,sha256=Vd8IMa_UsbHYkr3IGnS-rgGb6zKxB1tOTqMZY5lc_xY,691
 parsl/tests/test_python_apps/test_join.py,sha256=g4VKJwKdIqDLbuNCkIpjVfME0q4mAci_iQ8wAx3uVUc,2679
 parsl/tests/test_python_apps/test_lifted.py,sha256=WELQv7VueH6I7d6hhMCWQi6s-0sMH8ek_2v4KH0cTFc,3311
@@ -368,9 +375,11 @@ parsl/tests/test_python_apps/test_pipeline.py,sha256=vl5bDAzwW0qoTIarzdkFv7cAuaI
 parsl/tests/test_python_apps/test_simple.py,sha256=LYGjdHvRizTpYzZePPvwKSPwrr2MPuMggYTknHeNhWM,733
 parsl/tests/test_python_apps/test_timeout.py,sha256=uENfT-1DharQkqkeG7a89E-gU1gjE7ATJrBZGUKvZSA,998
 parsl/tests/test_python_apps/test_type5.py,sha256=kUyA1NuFu-DDXsJNNvJLZVyewZBt7QAOhcGm2DWFTQw,777
+parsl/tests/test_radical/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+parsl/tests/test_radical/test_mpi_funcs.py,sha256=vCb5u6fjafEhrPgxwOzUjGXC3O6Yjf3lSYaxUE98pKg,744
 parsl/tests/test_regression/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/tests/test_regression/test_1480.py,sha256=HNhuw7OYkBGMhN--XgKIl2JPHUj_hXlgL74oS3FqWk4,545
-parsl/tests/test_regression/test_1606_wait_for_current_tasks.py,sha256=cmnMtErEosFL6sjgy1bwyheL_gevv7Fj1-Jz6h63GwM,1142
+parsl/tests/test_regression/test_1606_wait_for_current_tasks.py,sha256=frqPtaiVysevj9nCWoQlAeh9K1jQO5zaahr9ev_Mx_0,1134
 parsl/tests/test_regression/test_1653.py,sha256=ki75gl4Sn5nm26r_6qpJOqxrN5UjTWzViVikU0-Ef24,563
 parsl/tests/test_regression/test_221.py,sha256=jOS0EVu_2sbh10eg5hnivPvhNt0my_50vQ7jQYS1Bfg,520
 parsl/tests/test_regression/test_226.py,sha256=9EumcLPJzvbD0IUD6-LmPFbf86gaA1Kj8J8J4P4XdTY,1087
@@ -404,12 +413,12 @@ parsl/tests/test_threads/test_configs.py,sha256=QA9YjIMAtZ2jmkfOWqBzEfzQQcFVCDiz
 parsl/tests/test_threads/test_lazy_errors.py,sha256=nGhYfCMHFZYSy6YJ4gnAmiLl9SfYs0WVnuvj8DXQ9bw,560
 parsl/usage_tracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parsl/usage_tracking/usage.py,sha256=TEuAIm_U_G2ojZxvd0bbVa6gZlU61_mVRa2yJC9mGiI,7555
-parsl-2023.11.13.data/scripts/exec_parsl_function.py,sha256=NtWNeBvRqksej38eRPw8zPBJ1CeW6vgaitve0tfz_qc,7801
-parsl-2023.11.13.data/scripts/parsl_coprocess.py,sha256=2pS8OUjBTtOO__VZy-OhUUhr72dhgRpJBNbwqm0fzn4,5439
-parsl-2023.11.13.data/scripts/process_worker_pool.py,sha256=I-hBCzHA9eiTDjyE5W2uYwLi4A0rnKOBSWpicIcL4g4,33018
-parsl-2023.11.13.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-parsl-2023.11.13.dist-info/METADATA,sha256=1wOX7YXt8TRtNAiMXuGhGhPe0V__VLumpr49LcuAXp4,3686
-parsl-2023.11.13.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-parsl-2023.11.13.dist-info/entry_points.txt,sha256=XqnsWDYoEcLbsMcpnYGKLEnSBmaIe1YoM5YsBdJG2tI,176
-parsl-2023.11.13.dist-info/top_level.txt,sha256=PIheYoUFQtF2icLsgOykgU-Cjuwr2Oi6On2jo5RYgRM,6
-parsl-2023.11.13.dist-info/RECORD,,
+parsl-2023.11.20.data/scripts/exec_parsl_function.py,sha256=NtWNeBvRqksej38eRPw8zPBJ1CeW6vgaitve0tfz_qc,7801
+parsl-2023.11.20.data/scripts/parsl_coprocess.py,sha256=2pS8OUjBTtOO__VZy-OhUUhr72dhgRpJBNbwqm0fzn4,5439
+parsl-2023.11.20.data/scripts/process_worker_pool.py,sha256=I-hBCzHA9eiTDjyE5W2uYwLi4A0rnKOBSWpicIcL4g4,33018
+parsl-2023.11.20.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+parsl-2023.11.20.dist-info/METADATA,sha256=NwTE626WKDg4f2EEkgiSNKby3oWEcznmmnpNiojiw9I,3818
+parsl-2023.11.20.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+parsl-2023.11.20.dist-info/entry_points.txt,sha256=XqnsWDYoEcLbsMcpnYGKLEnSBmaIe1YoM5YsBdJG2tI,176
+parsl-2023.11.20.dist-info/top_level.txt,sha256=PIheYoUFQtF2icLsgOykgU-Cjuwr2Oi6On2jo5RYgRM,6
+parsl-2023.11.20.dist-info/RECORD,,