parsl 2025.9.8__tar.gz → 2025.9.22__tar.gz

{parsl-2025.9.8/parsl.egg-info → parsl-2025.9.22}/PKG-INFO

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

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/curvezmq.py

@@ -101,17 +101,6 @@ class BaseContext(metaclass=ABCMeta):
         """
         self._ctx.destroy(linger)
 
-    def recreate(self, linger: Optional[int] = None):
-        """Destroy then recreate the context.
-
-        Parameters
-        ----------
-        linger : int, optional
-            If specified, set LINGER on sockets prior to closing them.
-        """
-        self.destroy(linger)
-        self._ctx = zmq.Context()
-
 
 class ServerContext(BaseContext):
     """CurveZMQ server context
@@ -175,11 +164,6 @@ class ServerContext(BaseContext):
             self.auth_thread.stop()
         super().destroy(linger)
 
-    def recreate(self, linger: Optional[int] = None):
-        super().recreate(linger)
-        if self.auth_thread:
-            self.auth_thread = self._start_auth_thread()
-
 
 class ClientContext(BaseContext):
     """CurveZMQ client context

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/executors/execute_task.py

@@ -1,17 +1,11 @@
-import os
-
-from parsl.serialize import unpack_res_spec_apply_message
+from parsl.serialize import unpack_apply_message
 
 
 def execute_task(bufs: bytes):
     """Deserialize the buffer and execute the task.
     Returns the result or throws exception.
     """
-    f, args, kwargs, resource_spec = unpack_res_spec_apply_message(bufs)
-
-    for varname in resource_spec:
-        envname = "PARSL_" + str(varname).upper()
-        os.environ[envname] = str(resource_spec[varname])
+    f, args, kwargs = unpack_apply_message(bufs)
 
     # We might need to look into callability of the function from itself
     # since we change it's name in the new namespace

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/executors/flux/executor.py

@@ -24,7 +24,7 @@ from parsl.executors.flux.execute_parsl_task import __file__ as _WORKER_PATH
 from parsl.executors.flux.flux_instance_manager import __file__ as _MANAGER_PATH
 from parsl.providers import LocalProvider
 from parsl.providers.base import ExecutionProvider
-from parsl.serialize import deserialize, pack_res_spec_apply_message
+from parsl.serialize import deserialize, pack_apply_message
 from parsl.serialize.errors import SerializationError
 from parsl.utils import RepresentationMixin
 
@@ -284,10 +284,8 @@ class FluxExecutor(ParslExecutor, RepresentationMixin):
             infile = os.path.join(self.working_dir, f"{task_id}_in{os.extsep}pkl")
             outfile = os.path.join(self.working_dir, f"{task_id}_out{os.extsep}pkl")
             try:
-                fn_buf = pack_res_spec_apply_message(
-                    func, args, kwargs,
-                    resource_specification={},
-                    buffer_threshold=1024 * 1024
+                fn_buf = pack_apply_message(
+                    func, args, kwargs, buffer_threshold=1 << 20,
                 )
             except TypeError:
                 raise SerializationError(func.__name__)

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/executors/high_throughput/executor.py

@@ -35,7 +35,7 @@ from parsl.monitoring.radios.zmq_router import ZMQRadioReceiver, start_zmq_recei
 from parsl.process_loggers import wrap_with_logs
 from parsl.providers import LocalProvider
 from parsl.providers.base import ExecutionProvider
-from parsl.serialize import deserialize, pack_res_spec_apply_message
+from parsl.serialize import deserialize, pack_apply_message
 from parsl.serialize.errors import DeserializationError, SerializationError
 from parsl.usage_tracking.api import UsageInformation
 from parsl.utils import RepresentationMixin
@@ -332,6 +332,13 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
         self.encrypted = encrypted
         self.cert_dir = None
 
+        # This flag will enable/disable internal Python mismatch checks
+        # between the interchange and worker managers. This serves as a
+        # temporary workaround for Globus Compute to support different
+        # Python versions at the endpoint and worker layers. We can drop
+        # the flag once we implement modular internal message protocols.
+        self._check_python_mismatch: bool = True
+
         if not launch_cmd:
             launch_cmd = DEFAULT_LAUNCH_CMD
         self.launch_cmd = launch_cmd
@@ -568,6 +575,7 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
                               "cert_dir": self.cert_dir,
                               "manager_selector": self.manager_selector,
                               "run_id": self.run_id,
+                              "_check_python_mismatch": self._check_python_mismatch,
                               }
 
         config_pickle = pickle.dumps(interchange_config)
@@ -700,9 +708,7 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
         self.tasks[task_id] = fut
 
         try:
-            fn_buf = pack_res_spec_apply_message(func, args, kwargs,
-                                                 resource_specification=resource_specification,
-                                                 buffer_threshold=1024 * 1024)
+            fn_buf = pack_apply_message(func, args, kwargs, buffer_threshold=1 << 20)
         except TypeError:
             raise SerializationError(func.__name__)
 

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/executors/high_throughput/interchange.py

@@ -23,7 +23,6 @@ from parsl.monitoring.radios.base import MonitoringRadioSender
 from parsl.monitoring.radios.zmq import ZMQRadioSender
 from parsl.process_loggers import wrap_with_logs
 from parsl.serialize import serialize as serialize_object
-from parsl.utils import setproctitle
 from parsl.version import VERSION as PARSL_VERSION
 
 PKL_HEARTBEAT_CODE = pickle.dumps((2 ** 32) - 1)
@@ -56,6 +55,7 @@ class Interchange:
                  cert_dir: Optional[str],
                  manager_selector: ManagerSelector,
                  run_id: str,
+                 _check_python_mismatch: bool,
                  ) -> None:
         """
         Parameters
@@ -99,6 +99,11 @@ class Interchange:
 
         cert_dir : str | None
             Path to the certificate directory.
+
+        _check_python_mismatch : bool
+            If True, the interchange and worker managers must run the same version of
+            Python. Running different versions can cause inter-process communication
+            errors, so proceed with caution.
         """
         self.cert_dir = cert_dir
         self.logdir = logdir
@@ -126,6 +131,7 @@ class Interchange:
         logger.info("Connected to client")
 
         self.run_id = run_id
+        self._check_python_mismatch = _check_python_mismatch
 
         self.hub_address = hub_address
         self.hub_zmq_port = hub_zmq_port
@@ -213,7 +219,7 @@ class Interchange:
 
         reply: Any  # the type of reply depends on the command_req received (aka this needs dependent types...)
 
-        if self.command_channel in self.socks and self.socks[self.command_channel] == zmq.POLLIN:
+        if self.socks.get(self.command_channel) == zmq.POLLIN:
             logger.debug("entering command_server section")
 
             command_req = self.command_channel.recv_pyobj()
@@ -321,7 +327,7 @@ class Interchange:
         """Process incoming task message(s).
         """
 
-        if self.task_incoming in self.socks and self.socks[self.task_incoming] == zmq.POLLIN:
+        if self.socks.get(self.task_incoming) == zmq.POLLIN:
             logger.debug("start task_incoming section")
             msg = self.task_incoming.recv_pyobj()
 
@@ -396,7 +402,9 @@ class Interchange:
             logger.info(f'Registration info for manager {manager_id!r}: {meta}')
             self._send_monitoring_info(monitoring_radio, new_rec)
 
-            if (mgr_minor_py, mgr_parsl_v) != (ix_minor_py, ix_parsl_v):
+            python_mismatch: bool = ix_minor_py != mgr_minor_py
+            parsl_mismatch: bool = ix_parsl_v != mgr_parsl_v
+            if parsl_mismatch or (self._check_python_mismatch and python_mismatch):
                 kill_event.set()
                 vm_exc = VersionMismatch(
                     f"py.v={ix_minor_py} parsl.v={ix_parsl_v}",
@@ -618,6 +626,8 @@ def start_file_logger(filename: str, level: int = logging.DEBUG, format_string:
 
 
 if __name__ == "__main__":
+    from parsl.utils import setproctitle
+
     setproctitle("parsl: HTEX interchange")
 
     config = pickle.load(sys.stdin.buffer)

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/executors/high_throughput/mpi_resource_management.py

@@ -9,7 +9,6 @@ from enum import Enum
 from typing import Dict, List, Optional
 
 from parsl.multiprocessing import SpawnContext
-from parsl.serialize import pack_res_spec_apply_message, unpack_res_spec_apply_message
 
 logger = logging.getLogger(__name__)
 
@@ -167,9 +166,7 @@ class MPITaskScheduler(TaskScheduler):
 
     def put_task(self, task_package: dict):
         """Schedule task if resources are available otherwise backlog the task"""
-        user_ns = locals()
-        user_ns.update({"__builtins__": __builtins__})
-        _f, _args, _kwargs, resource_spec = unpack_res_spec_apply_message(task_package["buffer"])
+        resource_spec = task_package.get("resource_spec", {})
 
         nodes_needed = resource_spec.get("num_nodes")
         tid = task_package["task_id"]
@@ -183,9 +180,6 @@ class MPITaskScheduler(TaskScheduler):
             else:
                 resource_spec["MPI_NODELIST"] = ",".join(allocated_nodes)
                 self._map_tasks_to_nodes[tid] = allocated_nodes
-                buffer = pack_res_spec_apply_message(_f, _args, _kwargs, resource_spec)
-                task_package["buffer"] = buffer
-                task_package["resource_spec"] = resource_spec
 
         self.pending_task_q.put(task_package)
 

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/executors/high_throughput/process_worker_pool.py

@@ -603,6 +603,10 @@ def update_resource_spec_env_vars(mpi_launcher: str, resource_spec: Dict, node_i
 
 
 def _init_mpi_env(mpi_launcher: str, resource_spec: Dict):
+    for varname in resource_spec:
+        envname = "PARSL_" + str(varname).upper()
+        os.environ[envname] = str(resource_spec[varname])
+
     node_list = resource_spec.get("MPI_NODELIST")
     if node_list is None:
         return
@@ -753,8 +757,8 @@ def worker(
             worker_enqueued = True
 
         try:
-            # The worker will receive {'task_id':<tid>, 'buffer':<buf>}
             req = task_queue.get(timeout=task_queue_timeout)
+            # req is {'task_id':<tid>, 'buffer':<buf>, 'resource_spec':<dict>}
         except queue.Empty:
             continue
 

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/executors/high_throughput/zmq_pipes.py

@@ -74,51 +74,37 @@ class CommandClient:
 
         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)
-
-                    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:
-                    logger.exception("Potential ZMQ REQ-REP deadlock caught")
-                    logger.info("Trying to reestablish context")
-                    self.zmq_context.recreate()
-                    self.create_socket_and_bind()
+            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:
-                    break
-
-        if reply == '__PARSL_ZMQ_PIPES_MAGIC__':
-            logger.error("Command channel run retries exhausted. Unable to run command")
-            raise Exception("Command Channel retries exhausted")
+                    raise InternalConsistencyError(f"ZMQ poll returned unexpected value: {poll_result}")
+
+            self.zmq_socket.send_pyobj(message, copy=True)
+
+            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}")
 
-        return reply
+            logger.debug("Receiving command client response")
+            reply = self.zmq_socket.recv_pyobj()
+            logger.debug("Received command client response")
+            return reply
 
     def close(self):
         self.zmq_socket.close()

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/executors/radical/executor.py

@@ -20,7 +20,7 @@ from parsl.app.errors import BashExitFailure, RemoteExceptionWrapper
 from parsl.app.python import timeout
 from parsl.data_provider.files import File
 from parsl.executors.base import ParslExecutor
-from parsl.serialize import deserialize, pack_res_spec_apply_message
+from parsl.serialize import deserialize, pack_apply_message
 from parsl.serialize.errors import DeserializationError, SerializationError
 from parsl.utils import RepresentationMixin
 
@@ -441,11 +441,7 @@ class RadicalPilotExecutor(ParslExecutor, RepresentationMixin):
 
     def _pack_and_apply_message(self, func, args, kwargs):
         try:
-            buffer = pack_res_spec_apply_message(func,
-                                                 args,
-                                                 kwargs,
-                                                 resource_specification={},
-                                                 buffer_threshold=1024 * 1024)
+            buffer = pack_apply_message(func, args, kwargs, buffer_threshold=1 << 20)
             task_func = rp.utils.serialize_bson(buffer)
         except TypeError:
             raise SerializationError(func.__name__)

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/executors/radical/rpex_worker.py

@@ -5,7 +5,7 @@ import radical.pilot as rp
 import parsl.app.errors as pe
 from parsl.app.bash import remote_side_bash_executor
 from parsl.executors.execute_task import execute_task
-from parsl.serialize import serialize, unpack_res_spec_apply_message
+from parsl.serialize import serialize, unpack_apply_message
 
 
 class ParslWorker:
@@ -33,7 +33,7 @@ class ParslWorker:
 
         try:
             buffer = rp.utils.deserialize_bson(task['description']['executable'])
-            func, args, kwargs, _resource_spec = unpack_res_spec_apply_message(buffer)
+            func, args, kwargs = unpack_apply_message(buffer)
             ret = remote_side_bash_executor(func, *args, **kwargs)
             exc = (None, None)
             val = None

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/monitoring/monitoring.py

@@ -11,9 +11,9 @@ import typeguard
 
 from parsl.monitoring.types import TaggedMonitoringMessage
 from parsl.multiprocessing import (
-    SizedQueue,
     SpawnEvent,
     SpawnProcess,
+    SpawnQueue,
     join_terminate_close_proc,
 )
 from parsl.utils import RepresentationMixin
@@ -126,7 +126,7 @@ class MonitoringHub(RepresentationMixin):
         self.monitoring_hub_active = True
 
         self.resource_msgs: Queue[TaggedMonitoringMessage]
-        self.resource_msgs = SizedQueue()
+        self.resource_msgs = SpawnQueue()
 
         self.dbm_exit_event: ms.Event
         self.dbm_exit_event = SpawnEvent()

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/multiprocessing.py

@@ -4,7 +4,6 @@
 import logging
 import multiprocessing
 import multiprocessing.queues
-import platform
 from multiprocessing.context import ForkProcess as ForkProcessType
 from multiprocessing.context import SpawnProcess as SpawnProcessType
 from typing import Callable
@@ -21,54 +20,6 @@ SpawnEvent = SpawnContext.Event
 SpawnQueue = SpawnContext.Queue
 
 
-class MacSafeQueue(multiprocessing.queues.Queue):
-    """ Multiprocessing queues do not have qsize attributes on MacOS.
-    This is slower but more portable version of the multiprocessing Queue
-    that adds a explicit counter
-
-    Reference : https://github.com/keras-team/autokeras/commit/4ddd568b06b4045ace777bc0fb7bc18573b85a75
-    """
-
-    def __init__(self, *args, **kwargs):
-        if 'ctx' not in kwargs:
-            kwargs['ctx'] = multiprocessing.get_context('spawn')
-        super().__init__(*args, **kwargs)
-        self._counter = multiprocessing.Value('i', 0)
-
-    def put(self, *args, **kwargs):
-        # logger.critical("Putting item {}".format(args))
-        x = super().put(*args, **kwargs)
-        with self._counter.get_lock():
-            self._counter.value += 1
-        return x
-
-    def get(self, *args, **kwargs):
-        x = super().get(*args, **kwargs)
-        with self._counter.get_lock():
-            self._counter.value -= 1
-        # logger.critical("Getting item {}".format(x))
-        return x
-
-    def qsize(self):
-        return self._counter.value
-
-    def empty(self):
-        return not self._counter.value
-
-
-# SizedQueue should be constructable using the same calling
-# convention as multiprocessing.Queue but that entire signature
-# isn't expressible in mypy 0.790
-SizedQueue: Callable[..., multiprocessing.Queue]
-
-
-if platform.system() != 'Darwin':
-    import multiprocessing
-    SizedQueue = SpawnQueue
-else:
-    SizedQueue = MacSafeQueue
-
-
 def join_terminate_close_proc(process: SpawnProcessType, *, timeout: int = 30) -> None:
     """Increasingly aggressively terminate a process.
 

parsl-2025.9.22/parsl/serialize/__init__.py

@@ -0,0 +1,13 @@
+from parsl.serialize.facade import (
+    deserialize,
+    pack_apply_message,
+    serialize,
+    unpack_apply_message,
+)
+
+__all__ = (
+    "serialize",
+    "deserialize",
+    "pack_apply_message",
+    "unpack_apply_message",
+)

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/serialize/facade.py

@@ -62,44 +62,12 @@ def pack_apply_message(func: Any, args: Any, kwargs: Any, buffer_threshold: int
     return packed_buffer
 
 
-def pack_res_spec_apply_message(func: Any, args: Any, kwargs: Any, resource_specification: Any, buffer_threshold: int = int(128 * 1e6)) -> bytes:
-    """Serialize and pack function, parameters, and resource_specification
-
-    Parameters
-    ----------
-
-    func: Function
-        A function to ship
-
-    args: Tuple/list of objects
-        positional parameters as a list
-
-    kwargs: Dict
-        Dict containing named parameters
-
-    resource_specification: Dict
-        Dict containing application resource specification
-
-    buffer_threshold: int
-        Limits buffer to specified size in bytes. Exceeding this limit would give you
-        a warning in the log. Default is 128MB.
-    """
-    return pack_apply_message(func, args, (kwargs, resource_specification), buffer_threshold=buffer_threshold)
-
-
 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) -> List[Any]:
-    """ Unpack and deserialize function, parameters, and resource_specification
-    """
-    func, args, (kwargs, resource_spec) = unpack_apply_message(packed_buffer)
-    return [func, args, kwargs, resource_spec]
-
-
 def serialize(obj: Any, buffer_threshold: int = int(1e6)) -> bytes:
     """ Try available serialization methods one at a time
 

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/tests/test_curvezmq.py

@@ -296,48 +296,6 @@ def test_server_context_destroy(server_ctx: curvezmq.ServerContext, encrypted: b
         assert not server_ctx.auth_thread.pipe
 
 
-@pytest.mark.local
-@pytest.mark.parametrize("encrypted", (True, False), indirect=True)
-def test_client_context_recreate(client_ctx: curvezmq.ClientContext):
-    hidden_ctx = client_ctx._ctx
-    sock = client_ctx.socket(zmq.REQ)
-
-    assert not sock.closed
-    assert not client_ctx.closed
-
-    client_ctx.recreate()
-
-    assert sock.closed
-    assert not client_ctx.closed
-    assert hidden_ctx != client_ctx._ctx
-    assert hidden_ctx.closed
-
-
-@pytest.mark.local
-@pytest.mark.parametrize("encrypted", (True, False), indirect=True)
-def test_server_context_recreate(server_ctx: curvezmq.ServerContext, encrypted: bool):
-    hidden_ctx = server_ctx._ctx
-    sock = server_ctx.socket(zmq.REP)
-
-    assert not sock.closed
-    assert not server_ctx.closed
-    if encrypted:
-        assert server_ctx.auth_thread
-        auth_thread = server_ctx.auth_thread
-        assert auth_thread.pipe
-
-    server_ctx.recreate()
-
-    assert sock.closed
-    assert not server_ctx.closed
-    assert hidden_ctx.closed
-    assert hidden_ctx != server_ctx._ctx
-    if encrypted:
-        assert server_ctx.auth_thread
-        assert auth_thread != server_ctx.auth_thread
-        assert server_ctx.auth_thread.pipe
-
-
 @pytest.mark.local
 @pytest.mark.parametrize("encrypted", (True, False), indirect=True)
 def test_connection(

parsl-2025.9.22/parsl/tests/test_execute_task.py

@@ -0,0 +1,20 @@
+import os
+
+import pytest
+
+from parsl.executors.execute_task import execute_task
+from parsl.serialize.facade import pack_apply_message
+
+
+def addemup(*args: int, name: str = "apples"):
+    total = sum(args)
+    return f"{total} {name}"
+
+
+@pytest.mark.local
+def test_execute_task():
+    args = (1, 2, 3)
+    kwargs = {"name": "boots"}
+    buff = pack_apply_message(addemup, args, kwargs)
+    res = execute_task(buff)
+    assert res == addemup(*args, **kwargs)

parsl-2025.9.22/parsl/tests/test_htex/test_command_concurrency_regression_1321.py

@@ -0,0 +1,54 @@
+import time
+from threading import Event, Thread
+
+import pytest
+
+import parsl
+from parsl.tests.configs.htex_local import fresh_config as local_config
+
+N_THREADS = 50
+DURATION_S = 10
+
+
+@pytest.mark.local
+def test_concurrency_blast():
+    """Blast interchange command channel from many threads.
+    """
+
+    cc = parsl.dfk().executors['htex_local'].command_client
+
+    threads = []
+
+    ok_so_far = True
+
+    for _ in range(N_THREADS):
+
+        # This event will be set if the thread reaches the end of its body.
+        event = Event()
+
+        thread = Thread(target=blast, args=(cc, event))
+        threads.append((thread, event))
+
+    for thread, event in threads:
+        thread.start()
+
+    for thread, event in threads:
+        thread.join()
+        if not event.is_set():
+            ok_so_far = False
+
+    assert ok_so_far, "at least one thread did not exit normally"
+
+
+def blast(cc, e):
+    target_end = time.monotonic() + DURATION_S
+
+    while time.monotonic() < target_end:
+        cc.run("WORKERS")
+        cc.run("MANGERs_PACKAGES")
+        cc.run("CONNECTED_BLOCKS")
+        cc.run("WORKER_BINDS")
+
+    # If any of the preceeding cc.run calls raises an exception, the thread
+    # will not set its successful completion event.
+    e.set()

{parsl-2025.9.8 → parsl-2025.9.22}/parsl/tests/test_htex/test_interchange_exit_bad_registration.py

@@ -50,7 +50,8 @@ def test_exit_with_bad_registration(tmpd_cwd, try_assert):
                           "logging_level": logging.DEBUG,
                           "cert_dir": None,
                           "manager_selector": RandomManagerSelector(),
-                          "run_id": "test"
+                          "run_id": "test",
+                          "_check_python_mismatch": True,
                           }
 
     config_pickle = pickle.dumps(interchange_config)