parsl 2024.7.1__tar.gz → 2024.7.8__tar.gz

{parsl-2024.7.1/parsl.egg-info → parsl-2024.7.8}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: parsl
-Version: 2024.7.1
+Version: 2024.7.8
 Summary: Simple data dependent workflows in Python
 Home-page: https://github.com/Parsl/parsl
-Download-URL: https://github.com/Parsl/parsl/archive/2024.07.01.tar.gz
+Download-URL: https://github.com/Parsl/parsl/archive/2024.07.08.tar.gz
 Author: The Parsl Team
 Author-email: parsl@googlegroups.com
 License: Apache 2.0

{parsl-2024.7.1 → parsl-2024.7.8}/parsl/app/app.py

@@ -66,6 +66,10 @@ class AppBase(metaclass=ABCMeta):
             self.kwargs['walltime'] = params['walltime'].default
         if 'parsl_resource_specification' in params:
             self.kwargs['parsl_resource_specification'] = params['parsl_resource_specification'].default
+        if 'outputs' in params:
+            self.kwargs['outputs'] = params['outputs'].default
+        if 'inputs' in params:
+            self.kwargs['inputs'] = params['inputs'].default
 
     @abstractmethod
     def __call__(self, *args: Any, **kwargs: Any) -> AppFuture:

{parsl-2024.7.1 → parsl-2024.7.8}/parsl/channels/ssh/ssh.py

@@ -227,8 +227,20 @@ class SSHChannel(Channel, RepresentationMixin):
 
     def close(self) -> None:
         if self._is_connected():
+            transport = self.ssh_client.get_transport()
             self.ssh_client.close()
 
+            # ssh_client.close calls transport.close, but transport.close does
+            # not always wait for the transport thread to be stopped. See impl
+            # of Transport.close in paramiko and issue
+            # https://github.com/paramiko/paramiko/issues/520
+            logger.debug("Waiting for transport thread to stop")
+            transport.join(30)
+            if transport.is_alive():
+                logger.warning("SSH transport thread did not shut down")
+            else:
+                logger.debug("SSH transport thread stopped")
+
     def isdir(self, path):
         """Return true if the path refers to an existing directory.
 

{parsl-2024.7.1 → parsl-2024.7.8}/parsl/executors/high_throughput/executor.py

@@ -56,6 +56,8 @@ DEFAULT_LAUNCH_CMD = ("process_worker_pool.py {debug} {max_workers_per_node} "
                       "--mpi-launcher={mpi_launcher} "
                       "--available-accelerators {accelerators}")
 
+DEFAULT_INTERCHANGE_LAUNCH_CMD = "interchange.py"
+
 GENERAL_HTEX_PARAM_DOCS = """provider : :class:`~parsl.providers.base.ExecutionProvider`
        Provider to access computation resources. Can be one of :class:`~parsl.providers.aws.aws.EC2Provider`,
         :class:`~parsl.providers.cobalt.cobalt.Cobalt`,
@@ -76,6 +78,10 @@ GENERAL_HTEX_PARAM_DOCS = """provider : :class:`~parsl.providers.base.ExecutionP
         cores_per_worker, nodes_per_block, heartbeat_period ,heartbeat_threshold, logdir). For example:
         launch_cmd="process_worker_pool.py {debug} -c {cores_per_worker} --task_url={task_url} --result_url={result_url}"
 
+    interchange_launch_cmd : str
+        Custom command line string to launch the interchange process from the executor. If undefined,
+        the executor will use the default "interchange.py" command.
+
     address : string
         An address to connect to the main Parsl process which is reachable from the network in which
         workers will be running. This field expects an IPv4 address (xxx.xxx.xxx.xxx).
@@ -231,6 +237,7 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
                  label: str = 'HighThroughputExecutor',
                  provider: ExecutionProvider = LocalProvider(),
                  launch_cmd: Optional[str] = None,
+                 interchange_launch_cmd: Optional[str] = None,
                  address: Optional[str] = None,
                  worker_ports: Optional[Tuple[int, int]] = None,
                  worker_port_range: Optional[Tuple[int, int]] = (54000, 55000),
@@ -329,6 +336,10 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
             launch_cmd = DEFAULT_LAUNCH_CMD
         self.launch_cmd = launch_cmd
 
+        if not interchange_launch_cmd:
+            interchange_launch_cmd = DEFAULT_INTERCHANGE_LAUNCH_CMD
+        self.interchange_launch_cmd = interchange_launch_cmd
+
     radio_mode = "htex"
 
     def _warn_deprecated(self, old: str, new: str):
@@ -544,7 +555,7 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
 
         config_pickle = pickle.dumps(interchange_config)
 
-        self.interchange_proc = subprocess.Popen(b"interchange.py", stdin=subprocess.PIPE)
+        self.interchange_proc = subprocess.Popen(self.interchange_launch_cmd.encode("utf-8"), stdin=subprocess.PIPE)
         stdin = self.interchange_proc.stdin
         assert stdin is not None, "Popen should have created an IO object (vs default None) because of PIPE mode"
 

{parsl-2024.7.1 → parsl-2024.7.8}/parsl/executors/high_throughput/mpi_executor.py

@@ -38,6 +38,7 @@ class MPIExecutor(HighThroughputExecutor):
                  label: str = 'MPIExecutor',
                  provider: ExecutionProvider = LocalProvider(),
                  launch_cmd: Optional[str] = None,
+                 interchange_launch_cmd: Optional[str] = None,
                  address: Optional[str] = None,
                  worker_ports: Optional[Tuple[int, int]] = None,
                  worker_port_range: Optional[Tuple[int, int]] = (54000, 55000),
@@ -66,6 +67,7 @@ class MPIExecutor(HighThroughputExecutor):
             label=label,
             provider=provider,
             launch_cmd=launch_cmd,
+            interchange_launch_cmd=interchange_launch_cmd,
             address=address,
             worker_ports=worker_ports,
             worker_port_range=worker_port_range,

{parsl-2024.7.1 → parsl-2024.7.8}/parsl/executors/radical/executor.py

@@ -9,7 +9,7 @@ import threading as mt
 import time
 from concurrent.futures import Future
 from functools import partial
-from pathlib import Path, PosixPath
+from pathlib import PosixPath
 from typing import Dict, Optional
 
 import requests
@@ -24,7 +24,7 @@ from parsl.serialize import deserialize, pack_res_spec_apply_message
 from parsl.serialize.errors import DeserializationError, SerializationError
 from parsl.utils import RepresentationMixin
 
-from .rpex_resources import ResourceConfig
+from .rpex_resources import CLIENT, MPI, ResourceConfig
 
 try:
     import radical.pilot as rp
@@ -59,7 +59,7 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
           ``rp.PilotManager`` and ``rp.TaskManager``.
       2. "translate": Unwrap, identify, and parse Parsl ``apps`` into ``rp.TaskDescription``.
       3. "submit": Submit Parsl apps to ``rp.TaskManager``.
-      4. "shut_down": Shut down the RADICAL-Pilot runtime and all associated components.
+      4. "shutdown": Shut down the RADICAL-Pilot runtime and all associated components.
 
     Here is a diagram
 
@@ -138,19 +138,26 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
         self.future_tasks: Dict[str, Future] = {}
 
         if rpex_cfg:
-            self.rpex_cfg = rpex_cfg
+            self.rpex_cfg = rpex_cfg.get_config()
         elif not rpex_cfg and 'local' in resource:
-            self.rpex_cfg = ResourceConfig()
+            self.rpex_cfg = ResourceConfig().get_config()
         else:
-            raise ValueError('Resource config file must be '
-                             'specified for a non-local execution')
+            raise ValueError('Resource config must be '
+                             'specified for a non-local resources')
 
     def task_state_cb(self, task, state):
         """
         Update the state of Parsl Future apps
         Based on RP task state callbacks.
         """
-        if not task.uid.startswith('master'):
+        # check the Master/Worker state
+        if task.mode in [rp.RAPTOR_MASTER, rp.RAPTOR_WORKER]:
+            if state == rp.FAILED:
+                exception = RuntimeError(f'{task.uid} failed with internal error: {task.stderr}')
+                self._fail_all_tasks(exception)
+
+        # check all other tasks state
+        else:
             parsl_task = self.future_tasks[task.uid]
 
             if state == rp.DONE:
@@ -186,6 +193,23 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
                     else:
                         parsl_task.set_exception('Task failed for an unknown reason')
 
+    def _fail_all_tasks(self, exception):
+        """
+        Fail all outstanding tasks with the given exception.
+
+        This method iterates through all outstanding tasks in the
+        `_future_tasks` dictionary, which have not yet completed,
+        and sets the provided exception as their result, indicating
+        a failure.
+
+        Parameters:
+        - exception: The exception to be set as the result for all
+                     outstanding tasks.
+        """
+        for fut_task in self.future_tasks.values():
+            if not fut_task.done():
+                fut_task.set_exception(exception)
+
     def start(self):
         """Create the Pilot component and pass it.
         """
@@ -202,63 +226,62 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
                    '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")
+            os.environ["RADICAL_LOG_LVL"] = "DEBUG"
+            logger.info("RPEX will be running in 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))
+        # start RP's main components TMGR, PMGR and Pilot
+        self.tmgr = rp.TaskManager(session=self.session)
+        self.pmgr = rp.PilotManager(session=self.session)
+        self.pilot = self.pmgr.submit_pilots(pd)
 
-        self.master = cfg.master_descr
-        self.n_masters = cfg.n_masters
+        if not self.pilot.description.get('cores') or not self.pilot.description.get('nodes'):
+            logger.warning('no "cores/nodes" per pilot were set, using default resources')
+
+        self.tmgr.add_pilots(self.pilot)
+        self.tmgr.register_callback(self.task_state_cb)
 
-        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,
+        self.masters = []
+
+        logger.info(f'Starting {self.rpex_cfg.n_masters} masters and {self.rpex_cfg.n_workers} workers for each master')
+
+        # create N masters
+        for _ in range(self.rpex_cfg.n_masters):
+            md = rp.TaskDescription(self.rpex_cfg.master_descr)
+            md.uid = ru.generate_id('rpex.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 the master to the TMGR
+            master = self.tmgr.submit_raptors(md)[0]
+            self.masters.append(master)
 
-        # 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))
+            workers = []
+            # create N workers for each master and submit them to the TMGR
+            for _ in range(self.rpex_cfg.n_workers):
+                wd = rp.TaskDescription(self.rpex_cfg.worker_descr)
+                wd.uid = ru.generate_id('rpex.worker.%(item_counter)06d', ru.ID_CUSTOM,
+                                        ns=self.session.uid)
+                wd.raptor_id = master.uid
+                wd.input_staging = self._stage_files([File(worker_path)], mode='in')
+                workers.append(wd)
 
-        self.tmgr.submit_tasks(tds)
+            self.tmgr.submit_workers(workers)
+
+        self.select_master = self._cyclic_master_selector()
 
         # 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())
+        if self.rpex_cfg.pilot_env_mode != CLIENT:
+            logger.info("creating {0} environment for the executor".format(self.rpex_cfg.pilot_env.name))
+            self.pilot.prepare_env(env_name=self.rpex_cfg.pilot_env.name,
+                                   env_spec=self.rpex_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:
@@ -272,8 +295,21 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
             self._bulk_thread.daemon = True
             self._bulk_thread.start()
 
+            logger.info('bulk mode is on, submitting tasks in bulks')
+
         return True
 
+    def _cyclic_master_selector(self):
+        """
+        Balance tasks submission across N masters and N workers
+        """
+        current_master = 0
+        masters_uids = [m.uid for m in self.masters]
+
+        while True:
+            yield masters_uids[current_master]
+            current_master = (current_master + 1) % len(self.masters)
+
     def unwrap(self, func, args):
         """
         Unwrap a Parsl app and its args for further processing.
@@ -364,22 +400,25 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
 
                 # 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.
+                # task.mode=rp.TASK_EXECUTABLE (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.raptor_id = next(self.select_master)
                     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)
+            task.raptor_id = next(self.select_master)
             if kwargs.get('walltime'):
                 func = timeout(func, kwargs['walltime'])
 
-            # we process MPI function differently
-            if 'comm' in kwargs:
+            # Check how to serialize the function object
+            if MPI in self.rpex_cfg.worker_type.lower():
+                task.use_mpi = True
                 task.function = rp.PythonTask(func, *args, **kwargs)
             else:
+                task.use_mpi = False
                 task.function = self._pack_and_apply_message(func, args, kwargs)
 
         task.input_staging = self._stage_files(kwargs.get("inputs", []),
@@ -394,7 +433,7 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
         try:
             task.verify()
         except ru.typeddict.TDKeyError as e:
-            raise Exception(f'{e}. Please check Radical.Pilot TaskDescription documentation')
+            raise Exception(f'{e}. Please check: https://radicalpilot.readthedocs.io/en/stable/ documentation')
 
         return task
 
@@ -413,7 +452,11 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
 
     def _unpack_and_set_parsl_exception(self, parsl_task, exception):
         try:
-            s = rp.utils.deserialize_bson(exception)
+            try:
+                s = rp.utils.deserialize_bson(exception)
+            except Exception:
+                s = exception
+
             if isinstance(s, RemoteExceptionWrapper):
                 try:
                     s.reraise()
@@ -421,6 +464,8 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
                     parsl_task.set_exception(e)
             elif isinstance(s, Exception):
                 parsl_task.set_exception(s)
+            elif isinstance(s, str):
+                parsl_task.set_exception(eval(s))
             else:
                 raise ValueError("Unknown exception-like type received: {}".format(type(s)))
         except Exception as e:
@@ -440,16 +485,10 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
                 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
+                # set the stderr/out to the desired
+                # name by the user
                 setattr(task, k, k_val)
-                task.sandbox = Path(k_val).parent.__str__()
+                task.sandbox = CWD
 
     def _stage_files(self, files, mode):
         """
@@ -477,7 +516,7 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
                 # this indicates that the user
                 # did not provided a specific
                 # output file and RP will stage out
-                # the task.output from pilot://task_folder
+                # the task.stdout from pilot://task_folder
                 # to the CWD or file.url
                 if '/' not in file.url:
                     f = {'source': file.filename,
@@ -548,7 +587,8 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
 
     def shutdown(self, hub=True, targets='all', block=False):
         """Shutdown the executor, including all RADICAL-Pilot components."""
-        logger.info("RadicalPilotExecutor shutdown")
+        logger.info("RadicalPilotExecutor is terminating...")
         self.session.close(download=True)
+        logger.info("RadicalPilotExecutor is terminated.")
 
         return True

{parsl-2024.7.1 → parsl-2024.7.8}/parsl/executors/radical/rpex_resources.py

@@ -5,6 +5,7 @@ from typing import List
 _setup_paths: List[str] = []
 try:
     import radical.pilot as rp
+    import radical.utils as ru
 except ImportError:
     pass
 
@@ -103,7 +104,7 @@ class ResourceConfig:
     python_v: str = f'{sys.version_info[0]}.{sys.version_info[1]}'
     worker_type: str = DEFAULT_WORKER
 
-    def _get_cfg_file(cls, path=None):
+    def get_config(cls, path=None):
 
         # Default ENV mode for RP is to reuse
         # the client side. If this is not the case,
@@ -121,6 +122,7 @@ class ResourceConfig:
         cfg = {
             'n_masters': cls.masters,
             'n_workers': cls.workers,
+            'worker_type': cls.worker_type,
             'gpus_per_node': cls.worker_gpus_per_node,
             'cores_per_node': cls.worker_cores_per_node,
             'cores_per_master': cls.cores_per_master,
@@ -138,9 +140,10 @@ class ResourceConfig:
             'pilot_env_mode': cls.pilot_env_mode,
 
             'master_descr': {
+                "ranks": 1,
+                "cores_per_rank": 1,
                 "mode": rp.RAPTOR_MASTER,
                 "named_env": cls.pilot_env_name,
-                "executable": "python3 rpex_master.py",
             },
 
             'worker_descr': {
@@ -149,12 +152,16 @@ class ResourceConfig:
                 "raptor_file": "./rpex_worker.py",
                 "raptor_class": cls.worker_type if
                 cls.worker_type.lower() != MPI else MPI_WORKER,
+                "ranks": cls.nodes_per_worker * cls.worker_cores_per_node,
+                "gpus_per_rank": cls.nodes_per_worker * cls.worker_gpus_per_node,
             }}
 
-        # Convert the class instance to a cfg file.
-        config_path = 'rpex.cfg'
+        # Convert the class instance to a Json file or a Config dict.
         if path:
+            config_path = 'rpex.cfg'
             config_path = path + '/' + config_path
-        with open(config_path, 'w') as f:
-            json.dump(cfg, f, indent=4)
-        return config_path
+            with open(config_path, 'w') as f:
+                json.dump(cfg, f, indent=4)
+        else:
+            config_obj = ru.Config(from_dict=cfg)
+            return config_obj

{parsl-2024.7.1 → parsl-2024.7.8}/parsl/providers/kubernetes/kube.py

@@ -168,10 +168,9 @@ class KubernetesProvider(ExecutionProvider, RepresentationMixin):
              - tasks_per_node (int) : command invocations to be launched per node
 
         Kwargs:
-             - job_name (String): Name for job, must be unique
+             - job_name (String): Name for job
 
         Returns:
-             - None: At capacity, cannot provision more
              - job_id: (string) Identifier for the job
         """
 
@@ -187,7 +186,7 @@ class KubernetesProvider(ExecutionProvider, RepresentationMixin):
         formatted_cmd = template_string.format(command=cmd_string,
                                                worker_init=self.worker_init)
 
-        logger.debug("Pod name :{}".format(pod_name))
+        logger.debug("Pod name: %s", pod_name)
         self._create_pod(image=self.image,
                          pod_name=pod_name,
                          job_name=job_name,

parsl-2024.7.8/parsl/tests/test_bash_apps/test_inputs_default.py

@@ -0,0 +1,25 @@
+import pytest
+
+from parsl import AUTO_LOGNAME, Config, bash_app, python_app
+from parsl.executors import ThreadPoolExecutor
+
+
+def local_config():
+    return Config(executors=[ThreadPoolExecutor()])
+
+
+@pytest.mark.local
+def test_default_inputs():
+    @python_app
+    def identity(inp):
+        return inp
+
+    @bash_app
+    def sum_inputs(inputs=[identity(1), identity(2)], stdout=AUTO_LOGNAME):
+        calc = sum(inputs)
+        return f"echo {calc}"
+
+    fut = sum_inputs()
+    fut.result()
+    with open(fut.stdout, 'r') as f:
+        assert int(f.read()) == 3

{parsl-2024.7.1 → parsl-2024.7.8}/parsl/tests/test_htex/test_htex.py

@@ -136,3 +136,16 @@ def test_max_workers_per_node():
 
     # Ensure max_workers_per_node takes precedence
     assert htex.max_workers_per_node == htex.max_workers == 1
+
+
+@pytest.mark.local
+def test_htex_launch_cmd():
+    htex = HighThroughputExecutor()
+    assert htex.launch_cmd.startswith("process_worker_pool.py")
+    assert htex.interchange_launch_cmd == "interchange.py"
+
+    launch_cmd = "custom-launch-cmd"
+    ix_launch_cmd = "custom-ix-launch-cmd"
+    htex = HighThroughputExecutor(launch_cmd=launch_cmd, interchange_launch_cmd=ix_launch_cmd)
+    assert htex.launch_cmd == launch_cmd
+    assert htex.interchange_launch_cmd == ix_launch_cmd

{parsl-2024.7.1 → parsl-2024.7.8}/parsl/tests/test_providers/test_local_provider.py

@@ -92,19 +92,24 @@ def test_ssh_channel():
                 # already exist, so create it here.
                 pathlib.Path('{}/known.hosts'.format(config_dir)).touch(mode=0o600)
                 script_dir = tempfile.mkdtemp()
-                p = LocalProvider(channel=SSHChannel('127.0.0.1', port=server_port,
-                                                     script_dir=remote_script_dir,
-                                                     host_keys_filename='{}/known.hosts'.format(config_dir),
-                                                     key_filename=priv_key),
-                                  launcher=SingleNodeLauncher(debug=False))
-                p.script_dir = script_dir
-                _run_tests(p)
+                channel = SSHChannel('127.0.0.1', port=server_port,
+                                     script_dir=remote_script_dir,
+                                     host_keys_filename='{}/known.hosts'.format(config_dir),
+                                     key_filename=priv_key)
+                try:
+                    p = LocalProvider(channel=channel,
+                                      launcher=SingleNodeLauncher(debug=False))
+                    p.script_dir = script_dir
+                    _run_tests(p)
+                finally:
+                    channel.close()
         finally:
             _stop_sshd(sshd_thread)
 
 
 def _stop_sshd(sshd_thread):
     sshd_thread.stop()
+    sshd_thread.join()
 
 
 class SSHDThread(threading.Thread):

parsl-2024.7.8/parsl/tests/test_python_apps/test_inputs_default.py

@@ -0,0 +1,22 @@
+import pytest
+
+import parsl
+from parsl import python_app
+from parsl.executors.threads import ThreadPoolExecutor
+
+
+def local_config():
+    return parsl.Config(executors=[ThreadPoolExecutor()])
+
+
+@pytest.mark.local
+def test_default_inputs():
+    @python_app
+    def identity(inp):
+        return inp
+
+    @python_app
+    def add_inputs(inputs=[identity(1), identity(2)]):
+        return sum(inputs)
+
+    assert add_inputs().result() == 3

{parsl-2024.7.1 → parsl-2024.7.8}/parsl/version.py

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

{parsl-2024.7.1 → parsl-2024.7.8/parsl.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: parsl
-Version: 2024.7.1
+Version: 2024.7.8
 Summary: Simple data dependent workflows in Python
 Home-page: https://github.com/Parsl/parsl
-Download-URL: https://github.com/Parsl/parsl/archive/2024.07.01.tar.gz
+Download-URL: https://github.com/Parsl/parsl/archive/2024.07.08.tar.gz
 Author: The Parsl Team
 Author-email: parsl@googlegroups.com
 License: Apache 2.0

{parsl-2024.7.1 → parsl-2024.7.8}/parsl.egg-info/SOURCES.txt

@@ -103,7 +103,6 @@ parsl/executors/high_throughput/process_worker_pool.py
 parsl/executors/high_throughput/zmq_pipes.py
 parsl/executors/radical/__init__.py
 parsl/executors/radical/executor.py
-parsl/executors/radical/rpex_master.py
 parsl/executors/radical/rpex_resources.py
 parsl/executors/radical/rpex_worker.py
 parsl/executors/taskvine/__init__.py
@@ -309,6 +308,7 @@ parsl/tests/test_bash_apps/__init__.py
 parsl/tests/test_bash_apps/test_apptimeout.py
 parsl/tests/test_bash_apps/test_basic.py
 parsl/tests/test_bash_apps/test_error_codes.py
+parsl/tests/test_bash_apps/test_inputs_default.py
 parsl/tests/test_bash_apps/test_keyword_overlaps.py
 parsl/tests/test_bash_apps/test_kwarg_storage.py
 parsl/tests/test_bash_apps/test_memoize.py
@@ -400,6 +400,7 @@ parsl/tests/test_python_apps/test_fibonacci_recursive.py
 parsl/tests/test_python_apps/test_futures.py
 parsl/tests/test_python_apps/test_garbage_collect.py
 parsl/tests/test_python_apps/test_import_fail.py
+parsl/tests/test_python_apps/test_inputs_default.py
 parsl/tests/test_python_apps/test_join.py
 parsl/tests/test_python_apps/test_lifted.py
 parsl/tests/test_python_apps/test_mapred.py