parsl 2024.3.11__py3-none-any.whl → 2025.1.13__py3-none-any.whl

parsl/providers/lsf/lsf.py

@@ -1,9 +1,8 @@
-import os
-import time
 import logging
 import math
+import os
+import time
 
-from parsl.channels import LocalChannel
 from parsl.jobs.states import JobState, JobStatus
 from parsl.launchers import SingleNodeLauncher
 from parsl.providers.cluster_provider import ClusterProvider
@@ -32,11 +31,6 @@ 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`.
     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.
@@ -71,7 +65,6 @@ class LSFProvider(ClusterProvider, RepresentationMixin):
         :class:`~parsl.launchers.SingleNodeLauncher` (the default),
         :class:`~parsl.launchers.SrunLauncher`, or
         :class:`~parsl.launchers.AprunLauncher`
-    move_files : Optional[Bool]: should files be moved? by default, Parsl will try to move files.
     bsub_redirection: Bool
         Should a redirection symbol "<" be included when submitting jobs, i.e., Bsub < job_script.
     request_by_nodes: Bool
@@ -81,7 +74,6 @@ class LSFProvider(ClusterProvider, RepresentationMixin):
     """
 
     def __init__(self,
-                 channel=LocalChannel(),
                  nodes_per_block=1,
                  cores_per_block=None,
                  cores_per_node=None,
@@ -95,13 +87,11 @@ class LSFProvider(ClusterProvider, RepresentationMixin):
                  project=None,
                  queue=None,
                  cmd_timeout=120,
-                 move_files=True,
                  bsub_redirection=False,
                  request_by_nodes=True,
                  launcher=SingleNodeLauncher()):
         label = 'LSF'
         super().__init__(label,
-                         channel,
                          nodes_per_block,
                          init_blocks,
                          min_blocks,
@@ -115,7 +105,6 @@ class LSFProvider(ClusterProvider, RepresentationMixin):
         self.queue = queue
         self.cores_per_block = cores_per_block
         self.cores_per_node = cores_per_node
-        self.move_files = move_files
         self.bsub_redirection = bsub_redirection
         self.request_by_nodes = request_by_nodes
 
@@ -217,7 +206,7 @@ class LSFProvider(ClusterProvider, RepresentationMixin):
         logger.debug("Requesting one block with {} nodes".format(self.nodes_per_block))
 
         job_config = {}
-        job_config["submit_script_dir"] = self.channel.script_dir
+        job_config["submit_script_dir"] = self.script_dir
         job_config["nodes"] = self.nodes_per_block
         job_config["tasks_per_node"] = tasks_per_node
         job_config["walltime"] = wtime_to_minutes(self.walltime)
@@ -233,17 +222,10 @@ class LSFProvider(ClusterProvider, RepresentationMixin):
         logger.debug("Writing submit script")
         self._write_submit_script(template_string, script_path, job_name, job_config)
 
-        if self.move_files:
-            logger.debug("moving files")
-            channel_script_path = self.channel.push_file(script_path, self.channel.script_dir)
-        else:
-            logger.debug("not moving files")
-            channel_script_path = script_path
-
         if self.bsub_redirection:
-            cmd = "bsub < {0}".format(channel_script_path)
+            cmd = "bsub < {0}".format(script_path)
         else:
-            cmd = "bsub {0}".format(channel_script_path)
+            cmd = "bsub {0}".format(script_path)
         retcode, stdout, stderr = super().execute_wait(cmd)
 
         job_id = None

parsl/providers/pbspro/pbspro.py

@@ -1,15 +1,12 @@
+import json
 import logging
 import os
 import time
-import json
 
-from parsl.channels import LocalChannel
 from parsl.jobs.states import JobState, JobStatus
 from parsl.launchers import SingleNodeLauncher
 from parsl.providers.pbspro.template import template_string
-from parsl.providers import TorqueProvider
-
-from parsl.providers.torque.torque import translate_table
+from parsl.providers.torque.torque import TorqueProvider, translate_table
 
 logger = logging.getLogger(__name__)
 
@@ -19,11 +16,6 @@ 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`.
     account : str
         Account the job will be charged against.
     queue : str
@@ -56,7 +48,6 @@ class PBSProProvider(TorqueProvider):
         :class:`~parsl.launchers.SingleNodeLauncher`.
     """
     def __init__(self,
-                 channel=LocalChannel(),
                  account=None,
                  queue=None,
                  scheduler_options='',
@@ -71,8 +62,7 @@ class PBSProProvider(TorqueProvider):
                  launcher=SingleNodeLauncher(),
                  walltime="00:20:00",
                  cmd_timeout=120):
-        super().__init__(channel,
-                         account,
+        super().__init__(account,
                          queue,
                          scheduler_options,
                          worker_init,
@@ -164,7 +154,7 @@ class PBSProProvider(TorqueProvider):
         )
 
         job_config = {}
-        job_config["submit_script_dir"] = self.channel.script_dir
+        job_config["submit_script_dir"] = self.script_dir
         job_config["nodes_per_block"] = self.nodes_per_block
         job_config["ncpus"] = self.cpus_per_node
         job_config["walltime"] = self.walltime
@@ -188,15 +178,13 @@ class PBSProProvider(TorqueProvider):
         logger.debug("Writing submit script")
         self._write_submit_script(self.template_string, script_path, job_name, job_config)
 
-        channel_script_path = self.channel.push_file(script_path, self.channel.script_dir)
-
         submit_options = ''
         if self.queue is not None:
             submit_options = '{0} -q {1}'.format(submit_options, self.queue)
         if self.account is not None:
             submit_options = '{0} -A {1}'.format(submit_options, self.account)
 
-        launch_cmd = "qsub {0} {1}".format(submit_options, channel_script_path)
+        launch_cmd = "qsub {0} {1}".format(submit_options, script_path)
         retcode, stdout, stderr = self.execute_wait(launch_cmd)
 
         job_id = None

parsl/providers/slurm/slurm.py

@@ -1,14 +1,12 @@
-import os
-import math
-import time
 import logging
+import math
+import os
 import re
-import typeguard
+import time
+from typing import Any, Dict, Optional
 
-from typing import Optional
+import typeguard
 
-from parsl.channels import LocalChannel
-from parsl.channels.base import Channel
 from parsl.jobs.states import JobState, JobStatus
 from parsl.launchers import SingleNodeLauncher
 from parsl.launchers.base import Launcher
@@ -19,7 +17,25 @@ from parsl.utils import RepresentationMixin, wtime_to_minutes
 
 logger = logging.getLogger(__name__)
 
-translate_table = {
+# From https://slurm.schedmd.com/sacct.html#SECTION_JOB-STATE-CODES
+sacct_translate_table = {
+    'PENDING': JobState.PENDING,
+    'RUNNING': JobState.RUNNING,
+    'CANCELLED': JobState.CANCELLED,
+    'COMPLETED': JobState.COMPLETED,
+    'FAILED': JobState.FAILED,
+    'NODE_FAIL': JobState.FAILED,
+    'BOOT_FAIL': JobState.FAILED,
+    'DEADLINE': JobState.TIMEOUT,
+    'TIMEOUT': JobState.TIMEOUT,
+    'REVOKED': JobState.FAILED,
+    'OUT_OF_MEMORY': JobState.FAILED,
+    'SUSPENDED': JobState.HELD,
+    'PREEMPTED': JobState.TIMEOUT,
+    'REQUEUED': JobState.PENDING
+}
+
+squeue_translate_table = {
     'PD': JobState.PENDING,
     'R': JobState.RUNNING,
     'CA': JobState.CANCELLED,
@@ -37,7 +53,7 @@ translate_table = {
 class SlurmProvider(ClusterProvider, RepresentationMixin):
     """Slurm Execution Provider
 
-    This provider uses sbatch to submit, squeue for status and scancel to cancel
+    This provider uses sbatch to submit, sacct for status and scancel to cancel
     jobs. The sbatch script to be used is created from a template file in this
     same module.
 
@@ -52,11 +68,9 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
         Slurm queue to place job in. If unspecified or ``None``, no queue slurm directive will be specified.
     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`.
+    clusters : str
+        Slurm cluster name, or comma seperated cluster list, used to choose between different clusters in a federated Slurm instance.
+        If unspecified or ``None``, no slurm directive for clusters will be added.
     nodes_per_block : int
         Nodes to provision per block.
     cores_per_node : int
@@ -92,7 +106,6 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
         :class:`~parsl.launchers.SingleNodeLauncher` (the default),
         :class:`~parsl.launchers.SrunLauncher`, or
         :class:`~parsl.launchers.AprunLauncher`
-    move_files : Optional[Bool]: should files be moved? by default, Parsl will try to move files.
     """
 
     @typeguard.typechecked
@@ -101,7 +114,7 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
                  account: Optional[str] = None,
                  qos: Optional[str] = None,
                  constraint: Optional[str] = None,
-                 channel: Channel = LocalChannel(),
+                 clusters: Optional[str] = None,
                  nodes_per_block: int = 1,
                  cores_per_node: Optional[int] = None,
                  mem_per_node: Optional[int] = None,
@@ -115,11 +128,9 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
                  worker_init: str = '',
                  cmd_timeout: int = 10,
                  exclusive: bool = True,
-                 move_files: bool = True,
                  launcher: Launcher = SingleNodeLauncher()):
         label = 'slurm'
         super().__init__(label,
-                         channel,
                          nodes_per_block,
                          init_blocks,
                          min_blocks,
@@ -133,10 +144,10 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
         self.cores_per_node = cores_per_node
         self.mem_per_node = mem_per_node
         self.exclusive = exclusive
-        self.move_files = move_files
         self.account = account
         self.qos = qos
         self.constraint = constraint
+        self.clusters = clusters
         self.scheduler_options = scheduler_options + '\n'
         if exclusive:
             self.scheduler_options += "#SBATCH --exclusive\n"
@@ -148,9 +159,36 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
             self.scheduler_options += "#SBATCH --qos={}\n".format(qos)
         if constraint:
             self.scheduler_options += "#SBATCH --constraint={}\n".format(constraint)
+        if clusters:
+            self.scheduler_options += "#SBATCH --clusters={}\n".format(clusters)
 
         self.regex_job_id = regex_job_id
         self.worker_init = worker_init + '\n'
+        # Check if sacct works and if not fall back to squeue
+        cmd = "sacct -X"
+        logger.debug("Executing %s", cmd)
+        retcode, stdout, stderr = self.execute_wait(cmd)
+        # If sacct fails it should return retcode=1 stderr="Slurm accounting storage is disabled"
+        logger.debug(f"sacct returned retcode={retcode} stderr={stderr}")
+        if retcode == 0:
+            logger.debug("using sacct to get job status")
+            _cmd = "sacct"
+            # Add clusters option to sacct if provided
+            if self.clusters:
+                _cmd += f" --clusters={self.clusters}"
+            # Using state%20 to get enough characters to not truncate output
+            # of the state. Without output can look like "<job_id>     CANCELLED+"
+            self._cmd = _cmd + " -X --noheader --format=jobid,state%20 --job '{0}'"
+            self._translate_table = sacct_translate_table
+        else:
+            logger.debug(f"sacct failed with retcode={retcode}")
+            logger.debug("falling back to using squeue to get job status")
+            _cmd = "squeue"
+            # Add clusters option to squeue if provided
+            if self.clusters:
+                _cmd += f" --clusters={self.clusters}"
+            self._cmd = _cmd + " --noheader --format='%i %t' --job '{0}'"
+            self._translate_table = squeue_translate_table
 
     def _status(self):
         '''Returns the status list for a list of job_ids
@@ -168,14 +206,14 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
             logger.debug('No active jobs, skipping status update')
             return
 
-        cmd = "squeue --noheader --format='%i %t' --job '{0}'".format(job_id_list)
+        cmd = self._cmd.format(job_id_list)
         logger.debug("Executing %s", cmd)
         retcode, stdout, stderr = self.execute_wait(cmd)
-        logger.debug("squeue returned %s %s", stdout, stderr)
+        logger.debug("sacct/squeue returned %s %s", stdout, stderr)
 
         # Execute_wait failed. Do no update
         if retcode != 0:
-            logger.warning("squeue failed with non-zero exit code {}".format(retcode))
+            logger.warning("sacct/squeue failed with non-zero exit code {}".format(retcode))
             return
 
         jobs_missing = set(self.resources.keys())
@@ -183,23 +221,27 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
             if not line:
                 # Blank line
                 continue
-            job_id, slurm_state = line.split()
-            if slurm_state not in translate_table:
+            # Sacct includes extra information in some outputs
+            # For example "<job_id> CANCELLED by <user_id>"
+            # This splits and ignores anything past the first two unpacked values
+            job_id, slurm_state, *ignore = line.split()
+            if slurm_state not in self._translate_table:
                 logger.warning(f"Slurm status {slurm_state} is not recognized")
-            status = translate_table.get(slurm_state, JobState.UNKNOWN)
+            status = self._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,
                                                          stdout_path=self.resources[job_id]['job_stdout_path'],
                                                          stderr_path=self.resources[job_id]['job_stderr_path'])
             jobs_missing.remove(job_id)
 
+        # sacct can get job info after jobs have completed so this path shouldn't be hit
         # 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,
-                                                              stdout_path=self.resources[missing_job]['job_stdout_path'],
-                                                              stderr_path=self.resources[missing_job]['job_stderr_path'])
+            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.
@@ -238,8 +280,8 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
 
         logger.debug("Requesting one block with {} nodes".format(self.nodes_per_block))
 
-        job_config = {}
-        job_config["submit_script_dir"] = self.channel.script_dir
+        job_config: Dict[str, Any] = {}
+        job_config["submit_script_dir"] = self.script_dir
         job_config["nodes"] = self.nodes_per_block
         job_config["tasks_per_node"] = tasks_per_node
         job_config["walltime"] = wtime_to_minutes(self.walltime)
@@ -257,14 +299,7 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
         logger.debug("Writing submit script")
         self._write_submit_script(template_string, script_path, job_name, job_config)
 
-        if self.move_files:
-            logger.debug("moving files")
-            channel_script_path = self.channel.push_file(script_path, self.channel.script_dir)
-        else:
-            logger.debug("not moving files")
-            channel_script_path = script_path
-
-        retcode, stdout, stderr = self.execute_wait("sbatch {0}".format(channel_script_path))
+        retcode, stdout, stderr = self.execute_wait("sbatch {0}".format(script_path))
 
         if retcode == 0:
             for line in stdout.split('\n'):
@@ -308,7 +343,14 @@ class SlurmProvider(ClusterProvider, RepresentationMixin):
         '''
 
         job_id_list = ' '.join(job_ids)
-        retcode, stdout, stderr = self.execute_wait("scancel {0}".format(job_id_list))
+
+        # Make the command to cancel jobs
+        _cmd = "scancel"
+        if self.clusters:
+            _cmd += f" --clusters={self.clusters}"
+        _cmd += " {0}"
+
+        retcode, stdout, stderr = self.execute_wait(_cmd.format(job_id_list))
         rets = None
         if retcode == 0:
             for jid in job_ids:

parsl/providers/torque/torque.py

@@ -2,11 +2,10 @@ import logging
 import os
 import time
 
-from parsl.channels import LocalChannel
 from parsl.jobs.states import JobState, JobStatus
 from parsl.launchers import AprunLauncher
-from parsl.providers.torque.template import template_string
 from parsl.providers.cluster_provider import ClusterProvider
+from parsl.providers.torque.template import template_string
 from parsl.utils import RepresentationMixin
 
 logger = logging.getLogger(__name__)
@@ -33,11 +32,6 @@ 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`.
     account : str
         Account the job will be charged against.
     queue : str
@@ -68,7 +62,6 @@ class TorqueProvider(ClusterProvider, RepresentationMixin):
 
     """
     def __init__(self,
-                 channel=LocalChannel(),
                  account=None,
                  queue=None,
                  scheduler_options='',
@@ -83,7 +76,6 @@ class TorqueProvider(ClusterProvider, RepresentationMixin):
                  cmd_timeout=120):
         label = 'torque'
         super().__init__(label,
-                         channel,
                          nodes_per_block,
                          init_blocks,
                          min_blocks,
@@ -173,8 +165,7 @@ class TorqueProvider(ClusterProvider, RepresentationMixin):
                      tasks_per_node)
 
         job_config = {}
-        # TODO : script_path might need to change to accommodate script dir set via channels
-        job_config["submit_script_dir"] = self.channel.script_dir
+        job_config["submit_script_dir"] = self.script_dir
         job_config["nodes"] = self.nodes_per_block
         job_config["task_blocks"] = self.nodes_per_block * tasks_per_node
         job_config["nodes_per_block"] = self.nodes_per_block
@@ -192,15 +183,13 @@ class TorqueProvider(ClusterProvider, RepresentationMixin):
         logger.debug("Writing submit script")
         self._write_submit_script(self.template_string, script_path, job_name, job_config)
 
-        channel_script_path = self.channel.push_file(script_path, self.channel.script_dir)
-
         submit_options = ''
         if self.queue is not None:
             submit_options = '{0} -q {1}'.format(submit_options, self.queue)
         if self.account is not None:
             submit_options = '{0} -A {1}'.format(submit_options, self.account)
 
-        launch_cmd = "qsub {0} {1}".format(submit_options, channel_script_path)
+        launch_cmd = "qsub {0} {1}".format(submit_options, script_path)
         retcode, stdout, stderr = self.execute_wait(launch_cmd)
 
         job_id = None

parsl/serialize/__init__.py

@@ -1,6 +1,11 @@
-from parsl.serialize.facade import (serialize, deserialize, pack_apply_message,
-                                    unpack_apply_message, unpack_res_spec_apply_message,
-                                    pack_res_spec_apply_message)
+from parsl.serialize.facade import (
+    deserialize,
+    pack_apply_message,
+    pack_res_spec_apply_message,
+    serialize,
+    unpack_apply_message,
+    unpack_res_spec_apply_message,
+)
 
 __all__ = ['serialize',
            'deserialize',

parsl/serialize/base.py

@@ -1,7 +1,6 @@
+import logging
 from abc import abstractmethod
 from functools import cached_property
-import logging
-
 from typing import Any
 
 logger = logging.getLogger(__name__)

parsl/serialize/concretes.py

@@ -1,13 +1,14 @@
-import dill
 import functools
-import pickle
 import logging
+import pickle
 
-logger = logging.getLogger(__name__)
-from parsl.serialize.base import SerializerBase
+import dill
 
+logger = logging.getLogger(__name__)
 from typing import Any
 
+from parsl.serialize.base import SerializerBase
+
 
 class PickleSerializer(SerializerBase):
     """ Pickle serialization covers most python objects, with some notable exceptions:

parsl/serialize/facade.py

@@ -87,16 +87,16 @@ def pack_res_spec_apply_message(func: Any, args: Any, kwargs: Any, resource_spec
     return pack_apply_message(func, args, (kwargs, resource_specification), buffer_threshold=buffer_threshold)
 
 
-def unpack_apply_message(packed_buffer: bytes, user_ns: Any = None, copy: Any = False) -> List[Any]:
+def unpack_apply_message(packed_buffer: bytes) -> List[Any]:
     """ Unpack and deserialize function and parameters
     """
     return [deserialize(buf) for buf in unpack_buffers(packed_buffer)]
 
 
-def unpack_res_spec_apply_message(packed_buffer: bytes, user_ns: Any = None, copy: Any = False) -> List[Any]:
+def unpack_res_spec_apply_message(packed_buffer: bytes) -> List[Any]:
     """ Unpack and deserialize function, parameters, and resource_specification
     """
-    func, args, (kwargs, resource_spec) = unpack_apply_message(packed_buffer, user_ns=user_ns, copy=copy)
+    func, args, (kwargs, resource_spec) = unpack_apply_message(packed_buffer)
     return [func, args, kwargs, resource_spec]
 
 

parsl/serialize/proxystore.py

@@ -1,10 +1,11 @@
-import dill
 import io
 import typing as t
 
-from parsl.serialize.base import SerializerBase
+import dill
 from proxystore.store import Store
 
+from parsl.serialize.base import SerializerBase
+
 
 class ProxyStoreDeepPickler(dill.Pickler):
     """This class extends dill so that certain objects will be stored into

parsl/tests/__init__.py

@@ -1,5 +1,5 @@
-from parsl.dataflow.memoization import id_for_memo
 from parsl.data_provider.files import File
+from parsl.dataflow.memoization import id_for_memo
 
 
 @id_for_memo.register(File)

parsl/tests/configs/azure_single_node.py

@@ -1,13 +1,12 @@
 """Config for Azure"""
-from parsl.providers import AzureProvider
+import getpass
 
 from parsl.config import Config
-from parsl.executors import HighThroughputExecutor
-from parsl.data_provider.http import HTTPInTaskStaging
 from parsl.data_provider.ftp import FTPInTaskStaging
+from parsl.data_provider.http import HTTPInTaskStaging
 from parsl.data_provider.rsync import RSyncStaging
-
-import getpass
+from parsl.executors import HighThroughputExecutor
+from parsl.providers import AzureProvider
 
 # If you are a developer running tests, make sure to update parsl/tests/configs/user_opts.py
 # If you are a user copying-and-pasting this as an example, make sure to either

parsl/tests/configs/bridges.py

@@ -1,7 +1,8 @@
 from parsl.config import Config
-from parsl.providers import SlurmProvider
-from parsl.launchers import SrunLauncher
 from parsl.executors import HighThroughputExecutor
+from parsl.launchers import SrunLauncher
+from parsl.providers import SlurmProvider
+
 from .user_opts import user_opts
 
 

parsl/tests/configs/cc_in2p3.py

@@ -1,7 +1,6 @@
 from parsl.config import Config
-from parsl.channels import LocalChannel
-from parsl.providers import GridEngineProvider
 from parsl.executors import HighThroughputExecutor
+from parsl.providers import GridEngineProvider
 
 from .user_opts import user_opts
 
@@ -14,7 +13,6 @@ def fresh_config():
                 max_workers_per_node=1,
                 encrypted=True,
                 provider=GridEngineProvider(
-                    channel=LocalChannel(),
                     nodes_per_block=2,
                     init_blocks=2,
                     max_blocks=2,

parsl/tests/configs/comet.py

@@ -1,7 +1,8 @@
 from parsl.config import Config
+from parsl.executors import HighThroughputExecutor
 from parsl.launchers import SrunLauncher
 from parsl.providers import SlurmProvider
-from parsl.executors import HighThroughputExecutor
+
 from .user_opts import user_opts
 
 

parsl/tests/configs/ec2_single_node.py

@@ -11,10 +11,9 @@ Block {Min:0, init:1, Max:1}
 ==================
 
 """
-from parsl.providers import AWSProvider
-
 from parsl.config import Config
 from parsl.executors import HighThroughputExecutor
+from parsl.providers import AWSProvider
 
 # If you are a developer running tests, make sure to update parsl/tests/configs/user_opts.py
 # If you are a user copying-and-pasting this as an example, make sure to either

parsl/tests/configs/ec2_spot.py

@@ -1,7 +1,6 @@
-from parsl.providers import AWSProvider
-
 from parsl.config import Config
 from parsl.executors import HighThroughputExecutor
+from parsl.providers import AWSProvider
 
 # If you are a developer running tests, make sure to update parsl/tests/configs/user_opts.py
 # If you are a user copying-and-pasting this as an example, make sure to either

parsl/tests/configs/flux_local.py

@@ -0,0 +1,11 @@
+from parsl.config import Config
+from parsl.executors import FluxExecutor
+
+
+def fresh_config():
+    return Config(
+        executors=[FluxExecutor()],
+    )
+
+
+config = fresh_config()