parsl 2024.5.13__py3-none-any.whl → 2024.5.27__py3-none-any.whl

parsl/executors/high_throughput/interchange.py

@@ -74,7 +74,7 @@ class Interchange:
                  worker_ports: Optional[Tuple[int, int]] = None,
                  worker_port_range: Tuple[int, int] = (54000, 55000),
                  hub_address: Optional[str] = None,
-                 hub_port: Optional[int] = None,
+                 hub_zmq_port: Optional[int] = None,
                  heartbeat_threshold: int = 60,
                  logdir: str = ".",
                  logging_level: int = logging.INFO,
@@ -105,7 +105,7 @@ class Interchange:
              The IP address at which the interchange can send info about managers to when monitoring is enabled.
              Default: None (meaning monitoring disabled)
 
-        hub_port : str
+        hub_zmq_port : str
              The port at which the interchange can send info about managers to when monitoring is enabled.
              Default: None (meaning monitoring disabled)
 
@@ -151,7 +151,7 @@ class Interchange:
         logger.info("Connected to client")
 
         self.hub_address = hub_address
-        self.hub_port = hub_port
+        self.hub_zmq_port = hub_zmq_port
 
         self.pending_task_queue: queue.Queue[Any] = queue.Queue(maxsize=10 ** 6)
         self.count = 0
@@ -244,12 +244,12 @@ class Interchange:
             logger.debug(f"Fetched {task_counter} tasks so far")
 
     def _create_monitoring_channel(self) -> Optional[zmq.Socket]:
-        if self.hub_address and self.hub_port:
+        if self.hub_address and self.hub_zmq_port:
             logger.info("Connecting to MonitoringHub")
             # This is a one-off because monitoring is unencrypted
             hub_channel = zmq.Context().socket(zmq.DEALER)
             hub_channel.set_hwm(0)
-            hub_channel.connect("tcp://{}:{}".format(self.hub_address, self.hub_port))
+            hub_channel.connect("tcp://{}:{}".format(self.hub_address, self.hub_zmq_port))
             logger.info("Connected to MonitoringHub")
             return hub_channel
         else:
@@ -329,6 +329,7 @@ class Interchange:
                     reply = None
 
                 else:
+                    logger.error(f"Received unknown command: {command_req}")
                     reply = None
 
                 logger.debug("Reply: {}".format(reply))

parsl/executors/high_throughput/mpi_executor.py

@@ -0,0 +1,85 @@
+"""A simplified interface for HTEx when running in MPI mode"""
+from typing import Optional, Tuple, List, Union, Callable, Dict
+
+import typeguard
+
+from parsl.data_provider.staging import Staging
+from parsl.executors.high_throughput.executor import HighThroughputExecutor, GENERAL_HTEX_PARAM_DOCS
+from parsl.executors.status_handling import BlockProviderExecutor
+from parsl.jobs.states import JobStatus
+from parsl.providers import LocalProvider
+from parsl.providers.base import ExecutionProvider
+
+
+class MPIExecutor(HighThroughputExecutor):
+    __doc__ = f"""A version of :class:`~parsl.HighThroughputExecutor` tuned for executing multi-node (e.g., MPI) tasks.
+
+    The Provider _must_ use the :class:`~parsl.launchers.SimpleLauncher`,
+    which places a single pool of workers on the first node of a block.
+    Each worker can then make system calls which use an MPI launcher (e.g., ``mpirun``, ``srun``)
+    to spawn multi-node tasks.
+
+    Specify the maximum number of multi-node tasks to run at once using ``max_workers_per_block``.
+    The value should be less than or equal to the ``nodes_per_block`` in the Provider.
+
+    Parameters
+    ----------
+    max_workers_per_block: int
+        Maximum number of MPI applications to run at once per block
+
+    {GENERAL_HTEX_PARAM_DOCS}
+    """
+
+    @typeguard.typechecked
+    def __init__(self,
+                 label: str = 'MPIExecutor',
+                 provider: ExecutionProvider = LocalProvider(),
+                 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),
+                 interchange_port_range: Optional[Tuple[int, int]] = (55000, 56000),
+                 storage_access: Optional[List[Staging]] = None,
+                 working_dir: Optional[str] = None,
+                 worker_debug: bool = False,
+                 max_workers_per_block: int = 1,
+                 prefetch_capacity: int = 0,
+                 heartbeat_threshold: int = 120,
+                 heartbeat_period: int = 30,
+                 drain_period: Optional[int] = None,
+                 poll_period: int = 10,
+                 address_probe_timeout: Optional[int] = None,
+                 worker_logdir_root: Optional[str] = None,
+                 mpi_launcher: str = "mpiexec",
+                 block_error_handler: Union[bool, Callable[[BlockProviderExecutor, Dict[str, JobStatus]], None]] = True,
+                 encrypted: bool = False):
+        super().__init__(
+            # Hard-coded settings
+            cores_per_worker=1e-9,  # Ensures there will be at least an absurd number of workers
+            enable_mpi_mode=True,
+            max_workers_per_node=max_workers_per_block,
+
+            # Everything else
+            label=label,
+            provider=provider,
+            launch_cmd=launch_cmd,
+            address=address,
+            worker_ports=worker_ports,
+            worker_port_range=worker_port_range,
+            interchange_port_range=interchange_port_range,
+            storage_access=storage_access,
+            working_dir=working_dir,
+            worker_debug=worker_debug,
+            prefetch_capacity=prefetch_capacity,
+            heartbeat_threshold=heartbeat_threshold,
+            heartbeat_period=heartbeat_period,
+            drain_period=drain_period,
+            poll_period=poll_period,
+            address_probe_timeout=address_probe_timeout,
+            worker_logdir_root=worker_logdir_root,
+            mpi_launcher=mpi_launcher,
+            block_error_handler=block_error_handler,
+            encrypted=encrypted
+        )
+
+        self.max_workers_per_block = max_workers_per_block

parsl/executors/high_throughput/mpi_prefix_composer.py

@@ -8,8 +8,18 @@ VALID_LAUNCHERS = ('srun',
                    'mpiexec')
 
 
+class MissingResourceSpecification(Exception):
+    """Exception raised when input is  not supplied a resource specification"""
+
+    def __init__(self, reason: str):
+        self.reason = reason
+
+    def __str__(self):
+        return f"Missing resource specification: {self.reason}"
+
+
 class InvalidResourceSpecification(Exception):
-    """Exception raised when Invalid keys are supplied via resource specification"""
+    """Exception raised when Invalid input is supplied via resource specification"""
 
     def __init__(self, invalid_keys: Set[str]):
         self.invalid_keys = invalid_keys
@@ -18,13 +28,19 @@ class InvalidResourceSpecification(Exception):
         return f"Invalid resource specification options supplied: {self.invalid_keys}"
 
 
-def validate_resource_spec(resource_spec: Dict[str, str]):
+def validate_resource_spec(resource_spec: Dict[str, str], is_mpi_enabled: bool):
     """Basic validation of keys in the resource_spec
 
     Raises: InvalidResourceSpecification if the resource_spec
         is invalid (e.g, contains invalid keys)
     """
     user_keys = set(resource_spec.keys())
+
+    # empty resource_spec when mpi_mode is set causes parsl to hang
+    # ref issue #3427
+    if is_mpi_enabled and len(user_keys) == 0:
+        raise MissingResourceSpecification('MPI mode requires optional parsl_resource_specification keyword argument to be configured')
+
     legal_keys = set(("ranks_per_node",
                       "num_nodes",
                       "num_ranks",

parsl/executors/high_throughput/mpi_resource_management.py

@@ -208,8 +208,11 @@ class MPITaskScheduler(TaskScheduler):
         """Return result and relinquish provisioned nodes"""
         result_pkl = self.pending_result_q.get(block, timeout=timeout)
         result_dict = pickle.loads(result_pkl)
+        # TODO (wardlt): If the task did not request nodes, it won't be in `self._map_tasks_to_nodes`.
+        #  Causes Parsl to hang. See Issue #3427
         if result_dict["type"] == "result":
             task_id = result_dict["task_id"]
+            assert task_id in self._map_tasks_to_nodes, "You are about to experience issue #3427"
             nodes_to_reallocate = self._map_tasks_to_nodes[task_id]
             self._return_nodes(nodes_to_reallocate)
             self._schedule_backlog_tasks()

parsl/executors/high_throughput/zmq_pipes.py

@@ -3,8 +3,11 @@
 import zmq
 import logging
 import threading
+import time
 
 from parsl import curvezmq
+from parsl.errors import InternalConsistencyError
+from parsl.executors.high_throughput.errors import CommandClientBadError, CommandClientTimeoutError
 
 logger = logging.getLogger(__name__)
 
@@ -31,6 +34,7 @@ class CommandClient:
         self.port = None
         self.create_socket_and_bind()
         self._lock = threading.Lock()
+        self.ok = True
 
     def create_socket_and_bind(self):
         """ Creates socket and binds to a port.
@@ -46,7 +50,7 @@ class CommandClient:
         else:
             self.zmq_socket.bind("tcp://{}:{}".format(self.ip_address, self.port))
 
-    def run(self, message, max_retries=3):
+    def run(self, message, max_retries=3, timeout_s=None):
         """ This function needs to be fast at the same time aware of the possibility of
         ZMQ pipes overflowing.
 
@@ -54,13 +58,43 @@ class CommandClient:
         in ZMQ sockets reaching a broken state once there are ~10k tasks in flight.
         This issue can be magnified if each the serialized buffer itself is larger.
         """
+        if not self.ok:
+            raise CommandClientBadError()
+
+        start_time_s = time.monotonic()
+
         reply = '__PARSL_ZMQ_PIPES_MAGIC__'
         with self._lock:
             for _ in range(max_retries):
                 try:
                     logger.debug("Sending command client command")
+
+                    if timeout_s is not None:
+                        remaining_time_s = start_time_s + timeout_s - time.monotonic()
+                        poll_result = self.zmq_socket.poll(timeout=remaining_time_s * 1000, flags=zmq.POLLOUT)
+                        if poll_result == zmq.POLLOUT:
+                            pass  # this is OK, so continue
+                        elif poll_result == 0:
+                            raise CommandClientTimeoutError("Waiting for command channel to be ready for a command")
+                        else:
+                            raise InternalConsistencyError(f"ZMQ poll returned unexpected value: {poll_result}")
+
                     self.zmq_socket.send_pyobj(message, copy=True)
-                    logger.debug("Waiting for command client response")
+
+                    if timeout_s is not None:
+                        logger.debug("Polling for command client response or timeout")
+                        remaining_time_s = start_time_s + timeout_s - time.monotonic()
+                        poll_result = self.zmq_socket.poll(timeout=remaining_time_s * 1000, flags=zmq.POLLIN)
+                        if poll_result == zmq.POLLIN:
+                            pass  # this is OK, so continue
+                        elif poll_result == 0:
+                            logger.error("Command timed-out - command client is now bad forever")
+                            self.ok = False
+                            raise CommandClientTimeoutError("Waiting for a reply from command channel")
+                        else:
+                            raise InternalConsistencyError(f"ZMQ poll returned unexpected value: {poll_result}")
+
+                    logger.debug("Receiving command client response")
                     reply = self.zmq_socket.recv_pyobj()
                     logger.debug("Received command client response")
                 except zmq.ZMQError:

parsl/executors/radical/rpex_resources.py

@@ -3,15 +3,11 @@ import json
 
 from typing import List
 
-_setup_paths: List[str]
+_setup_paths: List[str] = []
 try:
     import radical.pilot as rp
-    import radical.utils as ru
 except ImportError:
-    _setup_paths = []
-else:
-    _setup_paths = [rp.sdist_path,
-                    ru.sdist_path]
+    pass
 
 
 MPI = "mpi"
@@ -77,7 +73,7 @@ class ResourceConfig:
 
     pilot_env_setup : list
         List of setup commands/packages for the pilot environment.
-        Default setup includes "parsl", rp.sdist_path, and ru.sdist_path.
+        Default is an empty list.
 
     python_v : str
         The Python version to be used in the pilot environment.

parsl/monitoring/remote.py

@@ -96,6 +96,22 @@ def monitor_wrapper(*,
     return (wrapped, args, new_kwargs)
 
 
+def get_radio(radio_mode: str, monitoring_hub_url: str, task_id: int, run_dir: str) -> MonitoringRadio:
+    radio: MonitoringRadio
+    if radio_mode == "udp":
+        radio = UDPRadio(monitoring_hub_url,
+                         source_id=task_id)
+    elif radio_mode == "htex":
+        radio = HTEXRadio(monitoring_hub_url,
+                          source_id=task_id)
+    elif radio_mode == "filesystem":
+        radio = FilesystemRadio(monitoring_url=monitoring_hub_url,
+                                source_id=task_id, run_dir=run_dir)
+    else:
+        raise RuntimeError(f"Unknown radio mode: {radio_mode}")
+    return radio
+
+
 @wrap_with_logs
 def send_first_message(try_id: int,
                        task_id: int,
@@ -122,18 +138,7 @@ def send_first_last_message(try_id: int,
     import platform
     import os
 
-    radio: MonitoringRadio
-    if radio_mode == "udp":
-        radio = UDPRadio(monitoring_hub_url,
-                         source_id=task_id)
-    elif radio_mode == "htex":
-        radio = HTEXRadio(monitoring_hub_url,
-                          source_id=task_id)
-    elif radio_mode == "filesystem":
-        radio = FilesystemRadio(monitoring_url=monitoring_hub_url,
-                                source_id=task_id, run_dir=run_dir)
-    else:
-        raise RuntimeError(f"Unknown radio mode: {radio_mode}")
+    radio = get_radio(radio_mode, monitoring_hub_url, task_id, run_dir)
 
     msg = (MessageType.RESOURCE_INFO,
            {'run_id': run_id,
@@ -178,18 +183,7 @@ def monitor(pid: int,
 
     setproctitle("parsl: task resource monitor")
 
-    radio: MonitoringRadio
-    if radio_mode == "udp":
-        radio = UDPRadio(monitoring_hub_url,
-                         source_id=task_id)
-    elif radio_mode == "htex":
-        radio = HTEXRadio(monitoring_hub_url,
-                          source_id=task_id)
-    elif radio_mode == "filesystem":
-        radio = FilesystemRadio(monitoring_url=monitoring_hub_url,
-                                source_id=task_id, run_dir=run_dir)
-    else:
-        raise RuntimeError(f"Unknown radio mode: {radio_mode}")
+    radio = get_radio(radio_mode, monitoring_hub_url, task_id, run_dir)
 
     logging.debug("start of monitor")
 

parsl/providers/local/local.py

@@ -206,7 +206,7 @@ class LocalProvider(ExecutionProvider, RepresentationMixin):
         script_path = "{0}/{1}.sh".format(self.script_dir, job_name)
         script_path = os.path.abspath(script_path)
 
-        wrap_command = self.worker_init + f'\nexport JOBNAME=${job_name}\n' + self.launcher(command, tasks_per_node, self.nodes_per_block)
+        wrap_command = self.worker_init + f'\nexport JOBNAME={job_name}\n' + self.launcher(command, tasks_per_node, self.nodes_per_block)
 
         self._write_submit_script(wrap_command, script_path)
 

parsl/tests/conftest.py

@@ -201,7 +201,7 @@ def load_dfk_session(request, pytestconfig, tmpd_cwd_session):
         if parsl.dfk() != dfk:
             raise RuntimeError("DFK changed unexpectedly during test")
         dfk.cleanup()
-        parsl.clear()
+        assert DataFlowKernelLoader._dfk is None
     else:
         yield
 
@@ -253,7 +253,7 @@ def load_dfk_local_module(request, pytestconfig, tmpd_cwd_session):
             if parsl.dfk() != dfk:
                 raise RuntimeError("DFK changed unexpectedly during test")
             dfk.cleanup()
-            parsl.clear()
+            assert DataFlowKernelLoader._dfk is None
 
     else:
         yield

parsl/tests/sites/test_dynamic_executor.py

@@ -75,4 +75,3 @@ def test_dynamic_executor():
     print("Done testing")
 
     dfk.cleanup()
-    parsl.clear()

parsl/tests/test_bash_apps/test_std_uri.py

@@ -35,8 +35,6 @@ def const_with_cpath(autopath_specifier, content_path, caplog):
     for record in caplog.records:
         assert record.levelno < logging.ERROR
 
-    parsl.clear()
-
 
 @pytest.mark.local
 def test_std_autopath_const_str(caplog, tmpd_cwd):
@@ -74,8 +72,6 @@ def test_std_autopath_fail(caplog):
         with pytest.raises(URIFailError):
             app_stdout()
 
-    parsl.clear()
-
 
 @parsl.bash_app
 def app_both(stdout=parsl.AUTO_LOGNAME, stderr=parsl.AUTO_LOGNAME):
@@ -124,5 +120,3 @@ def test_std_autopath_zip(caplog, tmpd_cwd):
 
     for record in caplog.records:
         assert record.levelno < logging.ERROR
-
-    parsl.clear()

parsl/tests/test_checkpointing/test_periodic.py

@@ -9,12 +9,6 @@ def local_setup():
     parsl.load(fresh_config())
 
 
-def local_teardown():
-    # explicit clear without dfk.cleanup here, because the
-    # test does that already
-    parsl.clear()
-
-
 @python_app(cache=True)
 def slow_double(x, sleep_dur=1):
     import time
@@ -39,9 +33,10 @@ def test_periodic():
     with parsl.dfk():
         futs = [slow_double(sleep_for) for _ in range(4)]
         [f.result() for f in futs]
+        run_dir = parsl.dfk().run_dir
 
     # Here we will check if the loglines came back with 5 seconds deltas
-    with open("{}/parsl.log".format(parsl.dfk().run_dir)) as f:
+    with open("{}/parsl.log".format(run_dir)) as f:
         log_lines = f.readlines()
     expected_msg = " Done checkpointing"
     expected_msg2 = " No tasks checkpointed in this pass"

parsl/tests/test_checkpointing/test_python_checkpoint_2.py

@@ -19,7 +19,6 @@ def parsl_configured(run_dir, **kw):
     yield dfk
 
     parsl.dfk().cleanup()
-    parsl.clear()
 
 
 @python_app(cache=True)

parsl/tests/test_checkpointing/test_python_checkpoint_3.py

@@ -14,7 +14,6 @@ def local_setup():
 
 def local_teardown():
     parsl.dfk().cleanup()
-    parsl.clear()
 
 
 @python_app

parsl/tests/test_checkpointing/test_task_exit.py

@@ -16,7 +16,6 @@ def local_setup():
 
 def local_teardown():
     parsl.dfk().cleanup()
-    parsl.clear()
 
 
 @python_app(cache=True)

parsl/tests/test_htex/test_basic.py

@@ -14,7 +14,6 @@ def local_setup():
 
 def local_teardown():
     parsl.dfk().cleanup()
-    parsl.clear()
 
 
 @python_app

parsl/tests/test_htex/test_command_client_timeout.py

@@ -0,0 +1,69 @@
+import pytest
+import threading
+import time
+import zmq
+from parsl import curvezmq
+from parsl.executors.high_throughput.zmq_pipes import CommandClient
+from parsl.executors.high_throughput.errors import CommandClientTimeoutError, CommandClientBadError
+
+
+# Time constant used for timeout tests: various delays and
+# timeouts will be appropriate multiples of this, but the
+# value of T itself should not matter too much as long as
+# it is big enough for zmq connections to happen successfully.
+T = 0.25
+
+
+@pytest.mark.local
+def test_command_not_sent() -> None:
+    """Tests timeout on command send.
+    """
+    ctx = curvezmq.ClientContext(None)
+
+    # RFC6335 ephemeral port range
+    cc = CommandClient(ctx, "127.0.0.1", (49152, 65535))
+
+    # cc will now wait for a connection, but we won't do anything to make the
+    # other side of the connection exist, so any command given to cc should
+    # timeout.
+
+    with pytest.raises(CommandClientTimeoutError):
+        cc.run("SOMECOMMAND", timeout_s=T)
+
+    cc.close()
+
+
+@pytest.mark.local
+def test_command_ignored() -> None:
+    """Tests timeout on command response.
+    Tests that we timeout after a response and that the command client
+    sets itself into a bad state.
+
+    This only tests sequential access to the command client, even though
+    htex makes multithreaded use of the command client: see issue #3376 about
+    that lack of thread safety.
+    """
+    ctx = curvezmq.ClientContext(None)
+
+    # RFC6335 ephemeral port range
+    cc = CommandClient(ctx, "127.0.0.1", (49152, 65535))
+
+    ic_ctx = curvezmq.ServerContext(None)
+    ic_channel = ic_ctx.socket(zmq.REP)
+    ic_channel.connect(f"tcp://127.0.0.1:{cc.port}")
+
+    with pytest.raises(CommandClientTimeoutError):
+        cc.run("SLOW_COMMAND", timeout_s=T)
+
+    req = ic_channel.recv_pyobj()
+    assert req == "SLOW_COMMAND", "Should have received command on interchange side"
+    assert not cc.ok, "CommandClient should have set itself to bad"
+
+    with pytest.raises(CommandClientBadError):
+        cc.run("ANOTHER_COMMAND")
+
+    cc.close()
+    ctx.term()
+
+    ic_channel.close()
+    ic_ctx.term()

parsl/tests/test_htex/test_cpu_affinity_explicit.py

@@ -37,16 +37,9 @@ def test_cpu_affinity_explicit():
     config.executors[0].max_workers_per_node = 1
 
     logger.debug(f"config: {config}")
-    # TODO: is there a `with` style for this, to properly deal with exceptions?
-
-    parsl.load(config)
-    try:
 
+    with parsl.load(config):
         worker_affinity = my_affinity().result()
         logger.debug(f"worker reported this affinity: {worker_affinity}")
         assert len(worker_affinity) == 1
         assert worker_affinity == set((single_core,))
-
-    finally:
-        parsl.dfk().cleanup()
-        parsl.clear()

parsl/tests/test_htex/test_manager_failure.py

@@ -20,7 +20,6 @@ def load_config():
     yield
 
     parsl.dfk().cleanup()
-    parsl.clear()
 
 
 @python_app

parsl/tests/test_htex/test_managers_command.py

@@ -7,16 +7,11 @@ from parsl.app.app import python_app
 from parsl.tests.configs.htex_local import fresh_config
 
 
-def local_setup():
+def local_config():
     config = fresh_config()
     config.executors[0].poll_period = 1
     config.executors[0].max_workers_per_node = 1
-    parsl.load(config)
-
-
-def local_teardown():
-    parsl.dfk().cleanup()
-    parsl.clear()
+    return config
 
 
 @python_app

parsl/tests/test_htex/test_missing_worker.py

@@ -5,18 +5,12 @@ from parsl.app.app import python_app
 from parsl.tests.configs.htex_local import fresh_config
 
 
-def local_setup():
+def local_config():
     config = fresh_config()
     config.executors[0].poll_period = 1
     config.executors[0].max_workers_per_node = 1
     config.executors[0].launch_cmd = "executable_that_hopefully_does_not_exist_1030509.py"
-    parsl.load(config)
-
-
-def local_teardown():
-
-    parsl.dfk().cleanup()
-    parsl.clear()
+    return config
 
 
 @python_app

parsl/tests/test_monitoring/test_app_names.py

@@ -61,7 +61,6 @@ def test_app_name(get_app, expected_name, expected_result, tmpd_cwd):
     assert app().result() == expected_result
 
     parsl.dfk().cleanup()
-    parsl.clear()
 
     engine = sqlalchemy.create_engine(c.monitoring.logging_endpoint)
     with engine.begin() as connection:

parsl/tests/test_monitoring/test_basic.py

@@ -66,8 +66,6 @@ def test_row_counts(tmpd_cwd, fresh_config):
     with parsl.load(config):
         assert this_app().result() == 5
 
-    parsl.clear()
-
     # at this point, we should find one row in the monitoring database.
 
     engine = sqlalchemy.create_engine(db_url)

parsl/tests/test_monitoring/test_db_locks.py

@@ -63,7 +63,6 @@ def test_row_counts():
 
     logger.info("cleaning up parsl")
     parsl.dfk().cleanup()
-    parsl.clear()
 
     # at this point, we should find data consistent with executing one
     # task in the database.

parsl/tests/test_monitoring/test_fuzz_zmq.py

@@ -83,7 +83,6 @@ def test_row_counts():
 
     logger.info("cleaning up parsl")
     parsl.dfk().cleanup()
-    parsl.clear()
 
     # at this point, we should find one row in the monitoring database.
 

parsl/tests/test_monitoring/test_htex_init_blocks_vs_monitoring.py

@@ -65,8 +65,6 @@ def test_row_counts(tmpd_cwd, strategy):
 
         this_app().result()
 
-    parsl.clear()
-
     engine = sqlalchemy.create_engine(db_url)
     with engine.begin() as connection:
 

parsl/tests/test_monitoring/test_incomplete_futures.py

@@ -52,7 +52,6 @@ def test_future_representation(tmpd_cwd):
     # seconds, with the assumption "data will arrive in the DB within
     # 30 seconds, but probably much sooner".
     parsl.dfk().cleanup()
-    parsl.clear()
 
     engine = sqlalchemy.create_engine(monitoring_url)
     with engine.begin() as connection: