parsl 2024.2.19__tar.gz → 2024.2.26__tar.gz

{parsl-2024.2.19/parsl.egg-info → parsl-2024.2.26}/PKG-INFO

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

{parsl-2024.2.19 → parsl-2024.2.26}/README.rst

@@ -73,7 +73,7 @@ To run the Parsl tutorial notebooks you will need to install Jupyter::
 
 Detailed information about setting up Jupyter with Python is available `here <https://jupyter.readthedocs.io/en/latest/install.html>`_
 
-Note: Parsl uses an opt-in model to collect anonymous usage statistics for reporting and improvement purposes. To understand what stats are collected and enable collection please refer to the `usage tracking guide <http://parsl.readthedocs.io/en/stable/userguide/usage_tracking.html>`__
+Note: Parsl uses an opt-in model to collect usage statistics for reporting and improvement purposes. To understand what stats are collected and enable collection please refer to the `usage tracking guide <http://parsl.readthedocs.io/en/stable/userguide/usage_tracking.html>`__
 
 Documentation
 =============

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/channels/errors.py

@@ -14,11 +14,8 @@ class ChannelError(ParslError):
         self.e = e
         self.hostname = hostname
 
-    def __repr__(self) -> str:
-        return "Hostname:{0}, Reason:{1}".format(self.hostname, self.reason)
-
     def __str__(self) -> str:
-        return self.__repr__()
+        return "Hostname:{0}, Reason:{1}".format(self.hostname, self.reason)
 
 
 class BadHostKeyException(ChannelError):

parsl-2024.2.19/parsl/configs/comet.py → parsl-2024.2.26/parsl/configs/expanse.py

@@ -7,11 +7,11 @@ from parsl.executors import HighThroughputExecutor
 config = Config(
     executors=[
         HighThroughputExecutor(
-            label='Comet_HTEX_multinode',
-            worker_logdir_root='YOUR_LOGDIR_ON_COMET',
-            max_workers=2,
+            label='Expanse_CPU_Multinode',
+            max_workers=32,
             provider=SlurmProvider(
-                'debug',
+                'compute',
+                account='YOUR_ALLOCATION_ON_EXPANSE',
                 launcher=SrunLauncher(),
                 # string to prepend to #SBATCH blocks in the submit
                 # script to the scheduler
@@ -19,7 +19,7 @@ config = Config(
                 # Command to be run before starting a worker, such as:
                 # 'module load Anaconda; source activate parsl_env'.
                 worker_init='',
-                walltime='00:10:00',
+                walltime='01:00:00',
                 init_blocks=1,
                 max_blocks=1,
                 nodes_per_block=2,

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/dataflow/dflow.py

@@ -113,7 +113,7 @@ class DataFlowKernel:
             if self.monitoring.logdir is None:
                 self.monitoring.logdir = self.run_dir
             self.hub_address = self.monitoring.hub_address
-            self.hub_interchange_port = self.monitoring.start(self.run_id, self.run_dir)
+            self.hub_interchange_port = self.monitoring.start(self.run_id, self.run_dir, self.config.run_dir)
 
         self.time_began = datetime.datetime.now()
         self.time_completed: Optional[datetime.datetime] = None
@@ -678,10 +678,10 @@ class DataFlowKernel:
             task_record : The task record
 
         Returns:
-            Future that tracks the execution of the submitted executable
+            Future that tracks the execution of the submitted function
         """
         task_id = task_record['id']
-        executable = task_record['func']
+        function = task_record['func']
         args = task_record['args']
         kwargs = task_record['kwargs']
 
@@ -706,17 +706,17 @@ class DataFlowKernel:
 
         if self.monitoring is not None and self.monitoring.resource_monitoring_enabled:
             wrapper_logging_level = logging.DEBUG if self.monitoring.monitoring_debug else logging.INFO
-            (executable, args, kwargs) = self.monitoring.monitor_wrapper(executable, args, kwargs, try_id, task_id,
-                                                                         self.monitoring.monitoring_hub_url,
-                                                                         self.run_id,
-                                                                         wrapper_logging_level,
-                                                                         self.monitoring.resource_monitoring_interval,
-                                                                         executor.radio_mode,
-                                                                         executor.monitor_resources(),
-                                                                         self.run_dir)
+            (function, args, kwargs) = self.monitoring.monitor_wrapper(function, args, kwargs, try_id, task_id,
+                                                                       self.monitoring.monitoring_hub_url,
+                                                                       self.run_id,
+                                                                       wrapper_logging_level,
+                                                                       self.monitoring.resource_monitoring_interval,
+                                                                       executor.radio_mode,
+                                                                       executor.monitor_resources(),
+                                                                       self.run_dir)
 
         with self.submitter_lock:
-            exec_fu = executor.submit(executable, task_record['resource_specification'], *args, **kwargs)
+            exec_fu = executor.submit(function, task_record['resource_specification'], *args, **kwargs)
         self.update_task_state(task_record, States.launched)
 
         self._send_task_log_info(task_record)

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/executors/high_throughput/executor.py

@@ -6,7 +6,7 @@ import threading
 import queue
 import datetime
 import pickle
-from multiprocessing import Queue
+from multiprocessing import Process, Queue
 from typing import Dict, Sequence
 from typing import List, Optional, Tuple, Union, Callable
 import math
@@ -290,6 +290,7 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin):
         self.hub_port = None  # set to the correct hub port in dfk
         self.worker_ports = worker_ports
         self.worker_port_range = worker_port_range
+        self.interchange_proc: Optional[Process] = None
         self.interchange_port_range = interchange_port_range
         self.heartbeat_threshold = heartbeat_threshold
         self.heartbeat_period = heartbeat_period
@@ -766,12 +767,28 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin):
                     )
         return job_status
 
-    def shutdown(self):
+    def shutdown(self, timeout: float = 10.0):
         """Shutdown the executor, including the interchange. This does not
         shut down any workers directly - workers should be terminated by the
         scaling mechanism or by heartbeat timeout.
+
+        Parameters
+        ----------
+
+        timeout : float
+            Amount of time to wait for the Interchange process to terminate before
+            we forcefully kill it.
         """
+        if self.interchange_proc is None:
+            logger.info("HighThroughputExecutor has not started; skipping shutdown")
+            return
 
         logger.info("Attempting HighThroughputExecutor shutdown")
+
         self.interchange_proc.terminate()
+        self.interchange_proc.join(timeout=timeout)
+        if self.interchange_proc.is_alive():
+            logger.info("Unable to terminate Interchange process; sending SIGKILL")
+            self.interchange_proc.kill()
+
         logger.info("Finished HighThroughputExecutor shutdown attempt")

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/jobs/states.py

@@ -47,7 +47,7 @@ class JobState(IntEnum):
     """
 
     def __str__(self) -> str:
-        return self.__class__.__name__ + "." + self.name
+        return f"{self.__class__.__name__}.{self.name}"
 
 
 TERMINAL_STATES = [JobState.CANCELLED, JobState.COMPLETED, JobState.FAILED,
@@ -84,16 +84,16 @@ class JobStatus:
 
     def __repr__(self) -> str:
         if self.message is not None:
-            extra = f"state={self.state} message={self.message}".format(self.state, self.message)
+            extra = f"state={self.state} message={self.message}"
         else:
-            extra = f"state={self.state}".format(self.state)
+            extra = f"state={self.state}"
         return f"<{type(self).__module__}.{type(self).__qualname__} object at {hex(id(self))}, {extra}>"
 
     def __str__(self) -> str:
         if self.message is not None:
-            return "{} ({})".format(self.state, self.message)
+            return f"{self.state} ({self.message})"
         else:
-            return "{}".format(self.state)
+            return f"{self.state}"
 
     @property
     def stdout(self) -> Optional[str]:

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/monitoring/monitoring.py

@@ -84,7 +84,7 @@ class MonitoringHub(RepresentationMixin):
 
                  workflow_name: Optional[str] = None,
                  workflow_version: Optional[str] = None,
-                 logging_endpoint: str = 'sqlite:///runinfo/monitoring.db',
+                 logging_endpoint: Optional[str] = None,
                  logdir: Optional[str] = None,
                  monitoring_debug: bool = False,
                  resource_monitoring_enabled: bool = True,
@@ -118,7 +118,7 @@ class MonitoringHub(RepresentationMixin):
         logging_endpoint : str
              The database connection url for monitoring to log the information.
              These URLs follow RFC-1738, and can include username, password, hostname, database name.
-             Default: 'sqlite:///monitoring.db'
+             Default: sqlite, in the configured run_dir.
         logdir : str
              Parsl log directory paths. Logs and temp files go here. Default: '.'
         monitoring_debug : Bool
@@ -162,11 +162,14 @@ class MonitoringHub(RepresentationMixin):
         self.resource_monitoring_enabled = resource_monitoring_enabled
         self.resource_monitoring_interval = resource_monitoring_interval
 
-    def start(self, run_id: str, run_dir: str) -> int:
+    def start(self, run_id: str, dfk_run_dir: str, config_run_dir: Union[str, os.PathLike]) -> int:
 
         if self.logdir is None:
             self.logdir = "."
 
+        if self.logging_endpoint is None:
+            self.logging_endpoint = f"sqlite:///{os.fspath(config_run_dir)}/monitoring.db"
+
         os.makedirs(self.logdir, exist_ok=True)
 
         # Initialize the ZMQ pipe to the Parsl Client
@@ -231,7 +234,7 @@ class MonitoringHub(RepresentationMixin):
         self.logger.info("Started the router process {} and DBM process {}".format(self.router_proc.pid, self.dbm_proc.pid))
 
         self.filesystem_proc = Process(target=filesystem_receiver,
-                                       args=(self.logdir, self.resource_msgs, run_dir),
+                                       args=(self.logdir, self.resource_msgs, dfk_run_dir),
                                        name="Monitoring-Filesystem-Process",
                                        daemon=True
                                        )

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/multiprocessing.py

@@ -5,17 +5,16 @@ import logging
 import multiprocessing
 import multiprocessing.queues
 import platform
+from multiprocessing.context import ForkProcess as ForkProcessType
 
-from typing import Callable, Type
+from typing import Callable
 
 logger = logging.getLogger(__name__)
 
 ForkContext = multiprocessing.get_context("fork")
 SpawnContext = multiprocessing.get_context("spawn")
 
-# maybe ForkProcess should be: Callable[..., Process] so as to make
-# it clear that it returns a Process always to the type checker?
-ForkProcess: Type = ForkContext.Process
+ForkProcess: Callable[..., ForkProcessType] = ForkContext.Process
 
 
 class MacSafeQueue(multiprocessing.queues.Queue):

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/providers/cobalt/cobalt.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import time
+import warnings
 
 from parsl.providers.errors import ScaleOutFailed
 from parsl.channels import LocalChannel
@@ -24,6 +25,8 @@ translate_table = {
 class CobaltProvider(ClusterProvider, RepresentationMixin):
     """ Cobalt Execution Provider
 
+    WARNING: CobaltProvider is deprecated and will be removed by 2024.04
+
     This provider uses cobalt to submit (qsub), obtain the status of (qstat), and cancel (qdel)
     jobs. Theo script to be used is created from a template file in this
     same module.
@@ -86,6 +89,9 @@ class CobaltProvider(ClusterProvider, RepresentationMixin):
         self.queue = queue
         self.scheduler_options = scheduler_options
         self.worker_init = worker_init
+        warnings.warn("CobaltProvider is deprecated; This will be removed after 2024-04",
+                      DeprecationWarning,
+                      stacklevel=2)
 
     def _status(self):
         """Returns the status list for a list of job_ids

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/providers/pbspro/pbspro.py

@@ -119,13 +119,17 @@ class PBSProProvider(TorqueProvider):
 
                 job_state = job.get('job_state', JobState.UNKNOWN)
                 state = translate_table.get(job_state, JobState.UNKNOWN)
-                self.resources[job_id]['status'] = JobStatus(state)
+                self.resources[job_id]['status'] = JobStatus(state,
+                                                             stdout_path=self.resources[job_id]['job_stdout_path'],
+                                                             stderr_path=self.resources[job_id]['job_stderr_path'])
                 jobs_missing.remove(job_id)
 
         # squeue does not report on jobs that are not running. So we are filling in the
         # blanks for missing jobs, we might lose some information about why the jobs failed.
         for missing_job in jobs_missing:
-            self.resources[missing_job]['status'] = JobStatus(JobState.COMPLETED)
+            self.resources[missing_job]['status'] = JobStatus(JobState.COMPLETED,
+                                                              stdout_path=self.resources[missing_job]['job_stdout_path'],
+                                                              stderr_path=self.resources[missing_job]['job_stderr_path'])
 
     def submit(self, command, tasks_per_node, job_name="parsl"):
         """Submits the command job.
@@ -149,7 +153,11 @@ class PBSProProvider(TorqueProvider):
 
         job_name = "{0}.{1}".format(job_name, time.time())
 
-        script_path = os.path.abspath("{0}/{1}.submit".format(self.script_dir, job_name))
+        assert self.script_dir, "Expected script_dir to be set"
+        script_path = os.path.join(self.script_dir, job_name)
+        script_path = os.path.abspath(script_path)
+        job_stdout_path = script_path + ".stdout"
+        job_stderr_path = script_path + ".stderr"
 
         logger.debug("Requesting {} nodes_per_block, {} tasks_per_node".format(
             self.nodes_per_block, tasks_per_node)
@@ -163,6 +171,8 @@ class PBSProProvider(TorqueProvider):
         job_config["scheduler_options"] = self.scheduler_options
         job_config["worker_init"] = self.worker_init
         job_config["user_script"] = command
+        job_config["job_stdout_path"] = job_stdout_path
+        job_config["job_stderr_path"] = job_stderr_path
 
         # Add a colon to select_options if one isn't included
         if self.select_options and not self.select_options.startswith(":"):
@@ -194,7 +204,11 @@ class PBSProProvider(TorqueProvider):
             for line in stdout.split('\n'):
                 if line.strip():
                     job_id = line.strip()
-                    self.resources[job_id] = {'job_id': job_id, 'status': JobStatus(JobState.PENDING)}
+                    self.resources[job_id] = {'job_id': job_id,
+                                              'status': JobStatus(JobState.PENDING),
+                                              'job_stdout_path': job_stdout_path,
+                                              'job_stderr_path': job_stderr_path,
+                                              }
         else:
             message = "Command '{}' failed with return code {}".format(launch_cmd, retcode)
             if (stdout is not None) and (stderr is not None):

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/providers/pbspro/template.py

@@ -5,8 +5,8 @@ template_string = '''#!/bin/bash
 #PBS -m n
 #PBS -l walltime=$walltime
 #PBS -l select=${nodes_per_block}:ncpus=${ncpus}${select_options}
-#PBS -o ${submit_script_dir}/${jobname}.submit.stdout
-#PBS -e ${submit_script_dir}/${jobname}.submit.stderr
+#PBS -o ${job_stdout_path}
+#PBS -e ${job_stderr_path}
 ${scheduler_options}
 
 ${worker_init}

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/providers/slurm/slurm.py

@@ -188,14 +188,18 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
                 logger.warning(f"Slurm status {slurm_state} is not recognized")
             status = translate_table.get(slurm_state, JobState.UNKNOWN)
             logger.debug("Updating job {} with slurm status {} to parsl state {!s}".format(job_id, slurm_state, status))
-            self.resources[job_id]['status'] = JobStatus(status)
+            self.resources[job_id]['status'] = JobStatus(status,
+                                                         stdout_path=self.resources[job_id]['job_stdout_path'],
+                                                         stderr_path=self.resources[job_id]['job_stderr_path'])
             jobs_missing.remove(job_id)
 
         # squeue does not report on jobs that are not running. So we are filling in the
         # blanks for missing jobs, we might lose some information about why the jobs failed.
         for missing_job in jobs_missing:
             logger.debug("Updating missing job {} to completed status".format(missing_job))
-            self.resources[missing_job]['status'] = JobStatus(JobState.COMPLETED)
+            self.resources[missing_job]['status'] = JobStatus(JobState.COMPLETED,
+                                                              stdout_path=self.resources[missing_job]['job_stdout_path'],
+                                                              stderr_path=self.resources[missing_job]['job_stderr_path'])
 
     def submit(self, command: str, tasks_per_node: int, job_name="parsl.slurm") -> str:
         """Submit the command as a slurm job.
@@ -226,8 +230,11 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
 
         job_name = "{0}.{1}".format(job_name, time.time())
 
-        script_path = "{0}/{1}.submit".format(self.script_dir, job_name)
+        assert self.script_dir, "Expected script_dir to be set"
+        script_path = os.path.join(self.script_dir, job_name)
         script_path = os.path.abspath(script_path)
+        job_stdout_path = script_path + ".stdout"
+        job_stderr_path = script_path + ".stderr"
 
         logger.debug("Requesting one block with {} nodes".format(self.nodes_per_block))
 
@@ -239,6 +246,8 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
         job_config["scheduler_options"] = scheduler_options
         job_config["worker_init"] = worker_init
         job_config["user_script"] = command
+        job_config["job_stdout_path"] = job_stdout_path
+        job_config["job_stderr_path"] = job_stderr_path
 
         # Wrap the command
         job_config["user_script"] = self.launcher(command,
@@ -262,7 +271,11 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
                 match = re.match(self.regex_job_id, line)
                 if match:
                     job_id = match.group("id")
-                    self.resources[job_id] = {'job_id': job_id, 'status': JobStatus(JobState.PENDING)}
+                    self.resources[job_id] = {'job_id': job_id,
+                                              'status': JobStatus(JobState.PENDING),
+                                              'job_stdout_path': job_stdout_path,
+                                              'job_stderr_path': job_stderr_path,
+                                              }
                     return job_id
             else:
                 logger.error("Could not read job ID from submit command standard output.")

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/providers/slurm/template.py

@@ -1,8 +1,8 @@
 template_string = '''#!/bin/bash
 
 #SBATCH --job-name=${jobname}
-#SBATCH --output=${submit_script_dir}/${jobname}.submit.stdout
-#SBATCH --error=${submit_script_dir}/${jobname}.submit.stderr
+#SBATCH --output=${job_stdout_path}
+#SBATCH --error=${job_stderr_path}
 #SBATCH --nodes=${nodes}
 #SBATCH --time=${walltime}
 #SBATCH --ntasks-per-node=${tasks_per_node}

parsl-2024.2.26/parsl/tests/test_htex/test_htex.py

@@ -0,0 +1,109 @@
+import pathlib
+from unittest import mock
+
+import pytest
+
+from parsl import curvezmq
+from parsl import HighThroughputExecutor
+from parsl.multiprocessing import ForkProcess
+
+_MOCK_BASE = "parsl.executors.high_throughput.executor"
+
+
+@pytest.fixture
+def encrypted(request: pytest.FixtureRequest):
+    if hasattr(request, "param"):
+        return request.param
+    return True
+
+
+@pytest.fixture
+def htex(encrypted: bool):
+    htex = HighThroughputExecutor(encrypted=encrypted)
+
+    yield htex
+
+    htex.shutdown()
+
+
+@pytest.mark.local
+@pytest.mark.parametrize("encrypted", (True, False), indirect=True)
+@pytest.mark.parametrize("cert_dir_provided", (True, False))
+def test_htex_start_encrypted(
+    encrypted: bool,
+    cert_dir_provided: bool,
+    htex: HighThroughputExecutor,
+    tmpd_cwd: pathlib.Path,
+):
+    htex.run_dir = str(tmpd_cwd)
+    if cert_dir_provided:
+        provided_base_dir = tmpd_cwd / "provided"
+        provided_base_dir.mkdir()
+        cert_dir = curvezmq.create_certificates(provided_base_dir)
+        htex.cert_dir = cert_dir
+    else:
+        cert_dir = curvezmq.create_certificates(htex.logdir)
+
+    if not encrypted and cert_dir_provided:
+        with pytest.raises(AttributeError) as pyt_e:
+            htex.start()
+        assert "change cert_dir to None" in str(pyt_e.value)
+        return
+
+    htex.start()
+
+    assert htex.encrypted is encrypted
+    if encrypted:
+        assert htex.cert_dir == cert_dir
+        assert htex.outgoing_q.zmq_context.cert_dir == cert_dir
+        assert htex.incoming_q.zmq_context.cert_dir == cert_dir
+        assert htex.command_client.zmq_context.cert_dir == cert_dir
+        assert isinstance(htex.outgoing_q.zmq_context, curvezmq.ClientContext)
+        assert isinstance(htex.incoming_q.zmq_context, curvezmq.ClientContext)
+        assert isinstance(htex.command_client.zmq_context, curvezmq.ClientContext)
+    else:
+        assert htex.cert_dir is None
+        assert htex.outgoing_q.zmq_context.cert_dir is None
+        assert htex.incoming_q.zmq_context.cert_dir is None
+        assert htex.command_client.zmq_context.cert_dir is None
+
+
+@pytest.mark.local
+@pytest.mark.parametrize("started", (True, False))
+@pytest.mark.parametrize("timeout_expires", (True, False))
+@mock.patch(f"{_MOCK_BASE}.logger")
+def test_htex_shutdown(
+    mock_logger: mock.MagicMock,
+    started: bool,
+    timeout_expires: bool,
+    htex: HighThroughputExecutor,
+):
+    mock_ix_proc = mock.Mock(spec=ForkProcess)
+
+    if started:
+        htex.interchange_proc = mock_ix_proc
+        mock_ix_proc.is_alive.return_value = True
+
+    if not timeout_expires:
+        # Simulate termination of the Interchange process
+        def kill_interchange(*args, **kwargs):
+            mock_ix_proc.is_alive.return_value = False
+
+        mock_ix_proc.terminate.side_effect = kill_interchange
+
+    htex.shutdown()
+
+    mock_logs = mock_logger.info.call_args_list
+    if started:
+        assert mock_ix_proc.terminate.called
+        assert mock_ix_proc.join.called
+        assert {"timeout": 10} == mock_ix_proc.join.call_args[1]
+        if timeout_expires:
+            assert "Unable to terminate Interchange" in mock_logs[1][0][0]
+            assert mock_ix_proc.kill.called
+        assert "Attempting" in mock_logs[0][0][0]
+        assert "Finished" in mock_logs[-1][0][0]
+    else:
+        assert not mock_ix_proc.terminate.called
+        assert not mock_ix_proc.join.called
+        assert "has not started" in mock_logs[0][0][0]

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/tests/test_mpi_apps/test_mpi_scheduler.py

@@ -1,6 +1,6 @@
 import logging
 import os
-import mock
+from unittest import mock
 import pytest
 import pickle
 from parsl.executors.high_throughput.mpi_resource_management import TaskScheduler, MPITaskScheduler

parsl-2024.2.26/parsl/tests/test_providers/test_cobalt_deprecation_warning.py

@@ -0,0 +1,16 @@
+import warnings
+import pytest
+from parsl.providers import CobaltProvider
+
+
+@pytest.mark.local
+def test_deprecation_warning():
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+
+        CobaltProvider()
+
+        assert len(w) == 1
+        assert issubclass(w[-1].category, DeprecationWarning)
+        assert "CobaltProvider" in str(w[-1].message)

parsl-2024.2.26/parsl/tests/test_providers/test_pbspro_template.py

@@ -0,0 +1,28 @@
+import random
+
+from unittest import mock
+import pytest
+
+from parsl.channels import LocalChannel
+from parsl.providers import PBSProProvider
+
+
+@pytest.mark.local
+def test_submit_script_basic(tmp_path):
+    """Test slurm resources table"""
+
+    provider = PBSProProvider(
+        queue="debug", channel=LocalChannel(script_dir=tmp_path)
+    )
+    provider.script_dir = tmp_path
+    job_id = str(random.randint(55000, 59000))
+    provider.execute_wait = mock.Mock(spec=PBSProProvider.execute_wait)
+    provider.execute_wait.return_value = (0, job_id, "")
+    result_job_id = provider.submit("test", tasks_per_node=1)
+    assert job_id == result_job_id
+    provider.execute_wait.assert_called()
+    assert job_id in provider.resources
+
+    job_info = provider.resources[job_id]
+    assert "job_stdout_path" in job_info
+    assert "job_stderr_path" in job_info

parsl-2024.2.26/parsl/tests/test_providers/test_slurm_template.py

@@ -0,0 +1,29 @@
+import logging
+import random
+
+from unittest import mock
+import pytest
+
+from parsl.channels import LocalChannel
+from parsl.providers import SlurmProvider
+
+
+@pytest.mark.local
+def test_submit_script_basic(tmp_path):
+    """Test slurm resources table"""
+
+    provider = SlurmProvider(
+        partition="debug", channel=LocalChannel(script_dir=tmp_path)
+    )
+    provider.script_dir = tmp_path
+    job_id = str(random.randint(55000, 59000))
+    provider.execute_wait = mock.MagicMock(spec=SlurmProvider.execute_wait)
+    provider.execute_wait.return_value = (0, f"Submitted batch job {job_id}", "")
+    result_job_id = provider.submit("test", tasks_per_node=1)
+    assert job_id == result_job_id
+    provider.execute_wait.assert_called()
+    assert job_id in provider.resources
+
+    job_info = provider.resources[job_id]
+    assert "job_stdout_path" in job_info
+    assert "job_stderr_path" in job_info

{parsl-2024.2.19 → parsl-2024.2.26}/parsl/tests/test_radical/test_mpi_funcs.py

@@ -16,6 +16,7 @@ def some_mpi_func(msg, sleep, comm=None, parsl_resource_specification={}):
 apps = []
 
 
+@pytest.mark.skip("hangs in CI - waiting for resolution of issue #3029")
 @pytest.mark.local
 @pytest.mark.radical
 def test_radical_mpi(n=7):