parsl 2024.10.28__py3-none-any.whl → 2024.11.11__py3-none-any.whl

parsl/monitoring/radios.py

@@ -5,15 +5,9 @@ import socket
 import uuid
 from abc import ABCMeta, abstractmethod
 from multiprocessing.queues import Queue
-from typing import Optional
 
 import zmq
 
-from parsl.serialize import serialize
-
-_db_manager_excepts: Optional[Exception]
-
-
 logger = logging.getLogger(__name__)
 
 
@@ -41,9 +35,8 @@ class FilesystemRadioSender(MonitoringRadioSender):
     the UDP radio, but should be much more reliable.
     """
 
-    def __init__(self, *, monitoring_url: str, source_id: int, timeout: int = 10, run_dir: str):
+    def __init__(self, *, monitoring_url: str, timeout: int = 10, run_dir: str):
         logger.info("filesystem based monitoring channel initializing")
-        self.source_id = source_id
         self.base_path = f"{run_dir}/monitor-fs-radio/"
         self.tmp_path = f"{self.base_path}/tmp"
         self.new_path = f"{self.base_path}/new"
@@ -64,25 +57,22 @@ class FilesystemRadioSender(MonitoringRadioSender):
         # move it into new/, so that a partially written
         # file will never be observed in new/
         with open(tmp_filename, "wb") as f:
-            f.write(serialize(buffer))
+            pickle.dump(buffer, f)
         os.rename(tmp_filename, new_filename)
 
 
 class HTEXRadioSender(MonitoringRadioSender):
 
-    def __init__(self, monitoring_url: str, source_id: int, timeout: int = 10):
+    def __init__(self, monitoring_url: str, timeout: int = 10):
         """
         Parameters
         ----------
 
         monitoring_url : str
             URL of the form <scheme>://<IP>:<PORT>
-        source_id : str
-            String identifier of the source
         timeout : int
             timeout, default=10s
         """
-        self.source_id = source_id
         logger.info("htex-based monitoring channel initialising")
 
     def send(self, message: object) -> None:
@@ -124,21 +114,18 @@ class HTEXRadioSender(MonitoringRadioSender):
 
 class UDPRadioSender(MonitoringRadioSender):
 
-    def __init__(self, monitoring_url: str, source_id: int, timeout: int = 10):
+    def __init__(self, monitoring_url: str, timeout: int = 10):
         """
         Parameters
         ----------
 
         monitoring_url : str
             URL of the form <scheme>://<IP>:<PORT>
-        source_id : str
-            String identifier of the source
         timeout : int
             timeout, default=10s
         """
         self.monitoring_url = monitoring_url
         self.sock_timeout = timeout
-        self.source_id = source_id
         try:
             self.scheme, self.ip, port = (x.strip('/') for x in monitoring_url.split(':'))
             self.port = int(port)

parsl/monitoring/remote.py

@@ -103,14 +103,12 @@ def monitor_wrapper(*,
 def get_radio(radio_mode: str, monitoring_hub_url: str, task_id: int, run_dir: str) -> MonitoringRadioSender:
     radio: MonitoringRadioSender
     if radio_mode == "udp":
-        radio = UDPRadioSender(monitoring_hub_url,
-                               source_id=task_id)
+        radio = UDPRadioSender(monitoring_hub_url)
     elif radio_mode == "htex":
-        radio = HTEXRadioSender(monitoring_hub_url,
-                                source_id=task_id)
+        radio = HTEXRadioSender(monitoring_hub_url)
     elif radio_mode == "filesystem":
         radio = FilesystemRadioSender(monitoring_url=monitoring_hub_url,
-                                      source_id=task_id, run_dir=run_dir)
+                                      run_dir=run_dir)
     else:
         raise RuntimeError(f"Unknown radio mode: {radio_mode}")
     return radio

parsl/providers/__init__.py

@@ -1,7 +1,6 @@
 # Cloud Providers
 from parsl.providers.aws.aws import AWSProvider
 from parsl.providers.azure.azure import AzureProvider
-from parsl.providers.cobalt.cobalt import CobaltProvider
 from parsl.providers.condor.condor import CondorProvider
 from parsl.providers.googlecloud.googlecloud import GoogleCloudProvider
 from parsl.providers.grid_engine.grid_engine import GridEngineProvider
@@ -15,7 +14,6 @@ from parsl.providers.slurm.slurm import SlurmProvider
 from parsl.providers.torque.torque import TorqueProvider
 
 __all__ = ['LocalProvider',
-           'CobaltProvider',
            'CondorProvider',
            'GridEngineProvider',
            'SlurmProvider',

parsl/providers/base.py

@@ -11,7 +11,7 @@ class ExecutionProvider(metaclass=ABCMeta):
     """Execution providers are responsible for managing execution resources
     that have a Local Resource Manager (LRM). For instance, campus clusters
     and supercomputers generally have LRMs (schedulers) such as Slurm,
-    Torque/PBS, Condor and Cobalt. Clouds, on the other hand, have API
+    Torque/PBS, and Condor. Clouds, on the other hand, have API
     interfaces that allow much more fine-grained composition of an execution
     environment. An execution provider abstracts these types of resources and
     provides a single uniform interface to them.

parsl/providers/cluster_provider.py

@@ -18,10 +18,7 @@ class ClusterProvider(ExecutionProvider):
       label : str
         Label for this provider.
       channel : Channel
-        Channel for accessing this provider. Possible channels include
-        :class:`~parsl.channels.LocalChannel` (the default),
-        :class:`~parsl.channels.SSHChannel`, or
-        :class:`~parsl.channels.SSHInteractiveLoginChannel`.
+        Channel for accessing this provider.
       walltime : str
         Walltime requested per block in HH:MM:SS.
       launcher : Launcher

parsl/providers/condor/condor.py

@@ -37,10 +37,7 @@ class CondorProvider(RepresentationMixin, ClusterProvider):
     Parameters
     ----------
     channel : Channel
-        Channel for accessing this provider. Possible channels include
-        :class:`~parsl.channels.LocalChannel` (the default),
-        :class:`~parsl.channels.SSHChannel`, or
-        :class:`~parsl.channels.SSHInteractiveLoginChannel`.
+        Channel for accessing this provider.
     nodes_per_block : int
         Nodes to provision per block.
     cores_per_slot : int

parsl/providers/grid_engine/grid_engine.py

@@ -37,10 +37,7 @@ class GridEngineProvider(ClusterProvider, RepresentationMixin):
     Parameters
     ----------
     channel : Channel
-        Channel for accessing this provider. Possible channels include
-        :class:`~parsl.channels.LocalChannel` (the default),
-        :class:`~parsl.channels.SSHChannel`, or
-        :class:`~parsl.channels.SSHInteractiveLoginChannel`.
+        Channel for accessing this provider.
     nodes_per_block : int
         Nodes to provision per block.
     min_blocks : int

parsl/providers/lsf/lsf.py

@@ -33,10 +33,7 @@ class LSFProvider(ClusterProvider, RepresentationMixin):
     Parameters
     ----------
     channel : Channel
-        Channel for accessing this provider. Possible channels include
-        :class:`~parsl.channels.LocalChannel` (the default),
-        :class:`~parsl.channels.SSHChannel`, or
-        :class:`~parsl.channels.SSHInteractiveLoginChannel`.
+        Channel for accessing this provider.
     nodes_per_block : int
         Nodes to provision per block.
         When request_by_nodes is False, it is computed by cores_per_block / cores_per_node.

parsl/providers/pbspro/pbspro.py

@@ -18,10 +18,7 @@ class PBSProProvider(TorqueProvider):
     Parameters
     ----------
     channel : Channel
-        Channel for accessing this provider. Possible channels include
-        :class:`~parsl.channels.LocalChannel` (the default),
-        :class:`~parsl.channels.SSHChannel`, or
-        :class:`~parsl.channels.SSHInteractiveLoginChannel`.
+        Channel for accessing this provider.
     account : str
         Account the job will be charged against.
     queue : str

parsl/providers/slurm/slurm.py

@@ -71,10 +71,7 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
     constraint : str
         Slurm job constraint, often used to choose cpu or gpu type. If unspecified or ``None``, no constraint slurm directive will be added.
     channel : Channel
-        Channel for accessing this provider. Possible channels include
-        :class:`~parsl.channels.LocalChannel` (the default),
-        :class:`~parsl.channels.SSHChannel`, or
-        :class:`~parsl.channels.SSHInteractiveLoginChannel`.
+        Channel for accessing this provider.
     nodes_per_block : int
         Nodes to provision per block.
     cores_per_node : int

parsl/providers/torque/torque.py

@@ -34,10 +34,7 @@ class TorqueProvider(ClusterProvider, RepresentationMixin):
     Parameters
     ----------
     channel : Channel
-        Channel for accessing this provider. Possible channels include
-        :class:`~parsl.channels.LocalChannel` (the default),
-        :class:`~parsl.channels.SSHChannel`, or
-        :class:`~parsl.channels.SSHInteractiveLoginChannel`.
+        Channel for accessing this provider.
     account : str
         Account the job will be charged against.
     queue : str

parsl/tests/configs/user_opts.py

@@ -135,13 +135,6 @@ user_opts = {
     #     # For example:
     #     'remote_writeable': 'globus://af7bda53-6d04-11e5-ba46-22000b92c6ec/home/bzc/'
     # },
-    # 'adhoc': {
-    #    # This specifies configuration parameters when testing an ad-hoc SSH based cluster
-    #    'username': 'fixme', # username on remote systems
-    #    'remote_hostnames': ['hostname1', 'hostname2'], # addresses of remote systems
-    #    'worker_init': 'init commands',  # worker_init for remote systems
-    #    'script_dir': "/path"  # script directory on remote systems
-    # }
     #
 }  # type: Dict[str, Any]
 

parsl/tests/conftest.py

@@ -143,10 +143,6 @@ def pytest_configure(config):
         'markers',
         'staging_required: Marks tests that require a staging provider, when there is no sharedFS'
     )
-    config.addinivalue_line(
-        'markers',
-        'sshd_required: Marks tests that require a SSHD'
-    )
     config.addinivalue_line(
         'markers',
         'multiple_cores_required: Marks tests that require multiple cores, such as htex affinity'
@@ -163,6 +159,10 @@ def pytest_configure(config):
         'markers',
         'executor_supports_std_stream_tuples: Marks tests that require tuple support for stdout/stderr'
     )
+    config.addinivalue_line(
+        'markers',
+        'shared_fs: Marks tests that require a shared_fs between the workers are the test client'
+    )
 
 
 @pytest.fixture(autouse=True, scope='session')

parsl/tests/site_tests/site_config_selector.py

@@ -7,12 +7,7 @@ def fresh_config():
     hostname = os.getenv('PARSL_HOSTNAME', platform.uname().node)
     print("Loading config for {}".format(hostname))
 
-    if 'thetalogin' in hostname:
-        from parsl.tests.configs.theta import fresh_config
-        config = fresh_config()
-        print("Loading Theta config")
-
-    elif 'frontera' in hostname:
+    if 'frontera' in hostname:
         print("Loading Frontera config")
         from parsl.tests.configs.frontera import fresh_config
         config = fresh_config()

parsl/tests/test_bash_apps/test_basic.py

@@ -24,6 +24,7 @@ def foo(x, y, z=10, stdout=None, label=None):
     return f"echo {x} {y} {z}"
 
 
+@pytest.mark.shared_fs
 def test_command_format_1(tmpd_cwd):
     """Testing command format for BashApps"""
 
@@ -38,6 +39,7 @@ def test_command_format_1(tmpd_cwd):
     assert so_content == "1 4 10"
 
 
+@pytest.mark.shared_fs
 def test_auto_log_filename_format(caplog):
     """Testing auto log filename format for BashApps
     """
@@ -66,6 +68,7 @@ def test_auto_log_filename_format(caplog):
         assert record.levelno < logging.ERROR
 
 
+@pytest.mark.shared_fs
 def test_parallel_for(tmpd_cwd, n=3):
     """Testing a simple parallel for loop"""
     outdir = tmpd_cwd / "outputs/test_parallel"

parsl/tests/test_bash_apps/test_error_codes.py

@@ -58,6 +58,7 @@ test_matrix = {
 whitelist = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'configs', '*threads*')
 
 
+@pytest.mark.shared_fs
 def test_div_0(test_fn=div_0):
     err_code = test_matrix[test_fn]['exit_code']
     f = test_fn()
@@ -73,6 +74,7 @@ def test_div_0(test_fn=div_0):
     os.remove('std.out')
 
 
+@pytest.mark.shared_fs
 def test_bash_misuse(test_fn=bash_misuse):
     err_code = test_matrix[test_fn]['exit_code']
     f = test_fn()
@@ -87,6 +89,7 @@ def test_bash_misuse(test_fn=bash_misuse):
     os.remove('std.out')
 
 
+@pytest.mark.shared_fs
 def test_command_not_found(test_fn=command_not_found):
     err_code = test_matrix[test_fn]['exit_code']
     f = test_fn()
@@ -103,6 +106,7 @@ def test_command_not_found(test_fn=command_not_found):
     return True
 
 
+@pytest.mark.shared_fs
 def test_not_executable(test_fn=not_executable):
     err_code = test_matrix[test_fn]['exit_code']
     f = test_fn()

parsl/tests/test_bash_apps/test_kwarg_storage.py

@@ -8,6 +8,7 @@ def foo(z=2, stdout=None):
     return f"echo {z}"
 
 
+@pytest.mark.shared_fs
 def test_command_format_1(tmpd_cwd):
     """Testing command format for BashApps
     """

parsl/tests/test_bash_apps/test_memoize.py

@@ -9,9 +9,7 @@ def fail_on_presence(outputs=()):
     return 'if [ -f {0} ] ; then exit 1 ; else touch {0}; fi'.format(outputs[0])
 
 
-# This test is an oddity that requires a shared-FS and simply
-# won't work if there's a staging provider.
-# @pytest.mark.sharedFS_required
+@pytest.mark.shared_fs
 def test_bash_memoization(tmpd_cwd, n=2):
     """Testing bash memoization
     """
@@ -29,9 +27,7 @@ def fail_on_presence_kw(outputs=(), foo=None):
     return 'if [ -f {0} ] ; then exit 1 ; else touch {0}; fi'.format(outputs[0])
 
 
-# This test is an oddity that requires a shared-FS and simply
-# won't work if there's a staging provider.
-# @pytest.mark.sharedFS_required
+@pytest.mark.shared_fs
 def test_bash_memoization_keywords(tmpd_cwd, n=2):
     """Testing bash memoization
     """

parsl/tests/test_bash_apps/test_memoize_ignore_args.py

@@ -1,5 +1,7 @@
 import os
 
+import pytest
+
 import parsl
 from parsl.app.app import bash_app
 
@@ -21,6 +23,7 @@ def no_checkpoint_stdout_app_ignore_args(stdout=None):
     return "echo X"
 
 
+@pytest.mark.shared_fs
 def test_memo_stdout(tmpd_cwd):
     path_x = tmpd_cwd / "test.memo.stdout.x"
 

parsl/tests/test_bash_apps/test_memoize_ignore_args_regr.py

@@ -29,6 +29,7 @@ def no_checkpoint_stdout_app(stdout=None):
     return "echo X"
 
 
+@pytest.mark.shared_fs
 def test_memo_stdout(tmpd_cwd):
     assert const_list_x == const_list_x_arg
 

parsl/tests/test_bash_apps/test_multiline.py

@@ -14,6 +14,7 @@ def multiline(inputs=(), outputs=(), stderr=None, stdout=None):
     """.format(inputs=inputs, outputs=outputs)
 
 
+@pytest.mark.shared_fs
 def test_multiline(tmpd_cwd):
     so, se = tmpd_cwd / "std.out", tmpd_cwd / "std.err"
     f = multiline(

parsl/tests/test_bash_apps/test_stdout.py

@@ -91,6 +91,7 @@ def test_bad_stderr_file():
 
 
 @pytest.mark.executor_supports_std_stream_tuples
+@pytest.mark.shared_fs
 def test_stdout_truncate(tmpd_cwd, caplog):
     """Testing truncation of prior content of stdout"""
 
@@ -110,6 +111,7 @@ def test_stdout_truncate(tmpd_cwd, caplog):
         assert record.levelno < logging.ERROR
 
 
+@pytest.mark.shared_fs
 def test_stdout_append(tmpd_cwd, caplog):
     """Testing appending to prior content of stdout (default open() mode)"""
 

parsl/tests/test_channels/test_local_channel.py

@@ -17,22 +17,3 @@ def test_env():
 
     x = [s for s in stdout if s.startswith("HOME=")]
     assert x, "HOME not found"
-
-
-@pytest.mark.local
-def test_env_mod():
-    ''' Testing for env update at execute time.
-    '''
-
-    lc = LocalChannel()
-    rc, stdout, stderr = lc.execute_wait("env", 1, {'TEST_ENV': 'fooo'})
-
-    stdout = stdout.split('\n')
-    x = [s for s in stdout if s.startswith("PATH=")]
-    assert x, "PATH not found"
-
-    x = [s for s in stdout if s.startswith("HOME=")]
-    assert x, "HOME not found"
-
-    x = [s for s in stdout if s.startswith("TEST_ENV=fooo")]
-    assert x, "User set env missing"

parsl/tests/test_docs/test_from_slides.py

@@ -1,5 +1,7 @@
 import os
 
+import pytest
+
 from parsl.app.app import bash_app, python_app
 from parsl.data_provider.files import File
 
@@ -15,6 +17,7 @@ def cat(inputs=[]):
         return f.readlines()
 
 
+@pytest.mark.staging_required
 def test_slides():
     """Testing code snippet from slides """
 

parsl/tests/test_docs/test_kwargs.py

@@ -1,6 +1,8 @@
 """Functions used to explain kwargs"""
 from pathlib import Path
 
+import pytest
+
 from parsl import File, python_app
 
 
@@ -19,6 +21,7 @@ def test_inputs():
     assert reduce_future.result() == 6
 
 
+@pytest.mark.shared_fs
 def test_outputs(tmpd_cwd):
     @python_app()
     def write_app(message, outputs=()):

parsl/tests/test_monitoring/test_basic.py

@@ -42,6 +42,18 @@ def htex_udp_config():
     return c
 
 
+def htex_filesystem_config():
+    """This config will force filesystem radio"""
+    from parsl.tests.configs.htex_local_alternate import fresh_config
+    c = fresh_config()
+    assert len(c.executors) == 1
+
+    assert c.executors[0].radio_mode == "htex", "precondition: htex has a radio mode attribute, configured for htex radio"
+    c.executors[0].radio_mode = "filesystem"
+
+    return c
+
+
 def workqueue_config():
     from parsl.tests.configs.workqueue_ex import fresh_config
     c = fresh_config()
@@ -61,7 +73,7 @@ def taskvine_config():
 
 
 @pytest.mark.local
-@pytest.mark.parametrize("fresh_config", [htex_config, htex_udp_config, workqueue_config, taskvine_config])
+@pytest.mark.parametrize("fresh_config", [htex_config, htex_filesystem_config, htex_udp_config, workqueue_config, taskvine_config])
 def test_row_counts(tmpd_cwd, fresh_config):
     # this is imported here rather than at module level because
     # it isn't available in a plain parsl install, so this module

parsl/tests/test_providers/test_local_provider.py

@@ -12,7 +12,6 @@ import time
 import pytest
 
 from parsl.channels import LocalChannel
-from parsl.channels.ssh.ssh import DeprecatedSSHChannel
 from parsl.jobs.states import JobState
 from parsl.launchers import SingleNodeLauncher
 from parsl.providers import LocalProvider
@@ -69,140 +68,6 @@ def test_local_channel():
         _run_tests(p)
 
 
-SSHD_CONFIG = """
-Port {port}
-ListenAddress 127.0.0.1
-HostKey {hostkey}
-AuthorizedKeysFile {connpubkey}
-AuthenticationMethods publickey
-StrictModes no
-Subsystem sftp {sftp_path}
-"""
-
-
-# It would probably be better, when more formalized site testing comes into existence, to
-# use a site-testing provided server/configuration instead of the current scheme
-@pytest.mark.local
-@pytest.mark.sshd_required
-def test_ssh_channel():
-    with tempfile.TemporaryDirectory() as config_dir:
-        sshd_thread, priv_key, server_port = _start_sshd(config_dir)
-        try:
-            with tempfile.TemporaryDirectory() as remote_script_dir:
-                # The SSH library fails to add the new host key to the file if the file does not
-                # already exist, so create it here.
-                pathlib.Path('{}/known.hosts'.format(config_dir)).touch(mode=0o600)
-                script_dir = tempfile.mkdtemp()
-                channel = DeprecatedSSHChannel('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):
-    def __init__(self, config_file):
-        threading.Thread.__init__(self, daemon=True)
-        self.config_file = config_file
-        self.stop_flag = False
-        self.error = None
-
-    def run(self):
-        try:
-            # sshd needs to be run with an absolute path, hence the call to which()
-            sshpath = shutil.which('sshd')
-            assert sshpath is not None, "can find sshd executable"
-            p = subprocess.Popen([sshpath, '-D', '-f', self.config_file],
-                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            while True:
-                ec = p.poll()
-                if self.stop_flag:
-                    p.terminate()
-                    break
-                elif ec is None:
-                    time.sleep(0.1)
-                elif ec == 0:
-                    self.error = Exception('sshd exited prematurely: {}{}'.format(p.stdout.read(),
-                                                                                  p.stderr.read()))
-                    break
-                else:
-                    self.error = Exception('sshd failed: {}{}'.format(p.stdout.read(),
-                                                                      p.stderr.read()))
-                    break
-        except Exception as ex:
-            logger.exception("SSHDThread exception from run loop")
-            self.error = ex
-
-    def stop(self):
-        self.stop_flag = True
-
-
-def _start_sshd(config_dir: str):
-    server_config, priv_key, port = _init_sshd(config_dir)
-    sshd_thread = SSHDThread(server_config)
-    sshd_thread.start()
-    time.sleep(1.0)
-    if not sshd_thread.is_alive():
-        raise Exception('Failed to start sshd: {}'.format(sshd_thread.error))
-    return sshd_thread, priv_key, port
-
-
-def _init_sshd(config_dir):
-    hostkey = '{}/hostkey'.format(config_dir)
-    connkey = '{}/connkey'.format(config_dir)
-    os.system('ssh-keygen -b 2048 -t rsa -q -N "" -f {}'.format(hostkey))
-    os.system('ssh-keygen -b 2048 -t rsa -q -N "" -f {}'.format(connkey))
-    port = _find_free_port(22222)
-    server_config_str = SSHD_CONFIG.format(port=port, hostkey=hostkey,
-                                           connpubkey='{}.pub'.format(connkey),
-                                           sftp_path=_get_system_sftp_path())
-    server_config = '{}/sshd_config'.format(config_dir)
-    with open(server_config, 'w') as f:
-        f.write(server_config_str)
-    return server_config, connkey, port
-
-
-def _get_system_sftp_path():
-    try:
-        with open('/etc/ssh/sshd_config') as f:
-            line = f.readline()
-            while line:
-                tokens = line.split()
-                if tokens[0] == 'Subsystem' and tokens[1] == 'sftp':
-                    return tokens[2]
-                line = f.readline()
-    except Exception:
-        pass
-    return '/usr/lib/openssh/sftp-server'
-
-
-def _find_free_port(start: int):
-    port = start
-    while port < 65535:
-        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        try:
-            s.bind(('127.0.0.1', port))
-            s.close()
-            return port
-        except Exception:
-            pass
-        port += random.randint(1, 20)
-    raise Exception('Could not find free port')
-
-
 def _run(p: LocalProvider, command: str, np: int = 1):
     id = p.submit(command, np)
     return _wait(p, id)

parsl/tests/test_providers/test_pbspro_template.py

@@ -12,9 +12,10 @@ def test_submit_script_basic(tmp_path):
     """Test slurm resources table"""
 
     provider = PBSProProvider(
-        queue="debug", channel=LocalChannel(script_dir=tmp_path)
+        queue="debug", channel=LocalChannel()
     )
     provider.script_dir = tmp_path
+    provider.channel.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, "")

parsl/tests/test_providers/test_slurm_template.py

@@ -13,9 +13,10 @@ def test_submit_script_basic(tmp_path):
     """Test slurm resources table"""
 
     provider = SlurmProvider(
-        partition="debug", channel=LocalChannel(script_dir=tmp_path)
+        partition="debug", channel=LocalChannel()
     )
     provider.script_dir = tmp_path
+    provider.channel.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}", "")