parsl 2025.9.1__tar.gz → 2025.9.15__tar.gz

{parsl-2025.9.1/parsl.egg-info → parsl-2025.9.15}/PKG-INFO

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

{parsl-2025.9.1 → parsl-2025.9.15}/parsl/__init__.py

@@ -15,7 +15,6 @@ AUTO_LOGNAME
 
 """
 import logging
-import multiprocessing as _multiprocessing
 import os
 import platform
 
@@ -32,9 +31,6 @@ from parsl.log_utils import set_file_logger, set_stream_logger
 from parsl.monitoring import MonitoringHub
 from parsl.version import VERSION
 
-if platform.system() == 'Darwin':
-    _multiprocessing.set_start_method('fork', force=True)
-
 __author__ = 'The Parsl Team'
 __version__ = VERSION
 

{parsl-2025.9.1 → parsl-2025.9.15}/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.1 → parsl-2025.9.15}/parsl/dataflow/dflow.py

@@ -1267,7 +1267,7 @@ class DataFlowKernel:
         # should still see it.
         logger.info("DFK cleanup complete")
 
-    def checkpoint(self, tasks: Optional[Sequence[TaskRecord]] = None) -> str:
+    def checkpoint(self, tasks: Optional[Sequence[TaskRecord]] = None) -> None:
         """Checkpoint the dfk incrementally to a checkpoint file.
 
         When called, every task that has been completed yet not
@@ -1328,8 +1328,6 @@ class DataFlowKernel:
             else:
                 logger.info("Done checkpointing {} tasks".format(count))
 
-            return checkpoint_dir
-
     @staticmethod
     def _log_std_streams(task_record: TaskRecord) -> None:
         tid = task_record['id']

{parsl-2025.9.1 → parsl-2025.9.15}/parsl/dataflow/memoization.py

@@ -242,20 +242,6 @@ class Memoizer:
         assert isinstance(result, Future) or result is None
         return result
 
-    def hash_lookup(self, hashsum: str) -> Future[Any]:
-        """Lookup a hash in the memoization table.
-
-        Args:
-            - hashsum (str): The same hashes used to uniquely identify apps+inputs
-
-        Returns:
-            - Lookup result
-
-        Raises:
-            - KeyError: if hash not in table
-        """
-        return self.memo_lookup_table[hashsum]
-
     def update_memo(self, task: TaskRecord, r: Future[Any]) -> None:
         """Updates the memoization lookup table with the result from a task.
 

{parsl-2025.9.1 → parsl-2025.9.15}/parsl/executors/high_throughput/executor.py

@@ -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)

{parsl-2025.9.1 → parsl-2025.9.15}/parsl/executors/high_throughput/interchange.py

@@ -56,6 +56,7 @@ class Interchange:
                  cert_dir: Optional[str],
                  manager_selector: ManagerSelector,
                  run_id: str,
+                 _check_python_mismatch: bool,
                  ) -> None:
         """
         Parameters
@@ -99,6 +100,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 +132,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
@@ -222,35 +229,29 @@ class Interchange:
                 reply = self.connected_block_history
 
             elif command_req == "WORKERS":
-                num_workers = 0
-                for manager in self._ready_managers.values():
-                    num_workers += manager['worker_count']
-                reply = num_workers
+                reply = sum(m['worker_count'] for m in self._ready_managers.values())
 
             elif command_req == "MANAGERS":
                 reply = []
-                for manager_id in self._ready_managers:
-                    m = self._ready_managers[manager_id]
-                    idle_since = m['idle_since']
-                    if idle_since is not None:
-                        idle_duration = time.time() - idle_since
-                    else:
-                        idle_duration = 0.0
-                    resp = {'manager': manager_id.decode('utf-8'),
-                            'block_id': m['block_id'],
-                            'worker_count': m['worker_count'],
-                            'tasks': len(m['tasks']),
-                            'idle_duration': idle_duration,
-                            'active': m['active'],
-                            'parsl_version': m['parsl_version'],
-                            'python_version': m['python_version'],
-                            'draining': m['draining']}
+                now = time.time()
+                for manager_id, m in self._ready_managers.items():
+                    idle_duration = now - (m['idle_since'] or now)
+                    resp = {
+                        'manager': manager_id.decode('utf-8'),
+                        'block_id': m['block_id'],
+                        'worker_count': m['worker_count'],
+                        'tasks': len(m['tasks']),
+                        'idle_duration': idle_duration,
+                        'active': m['active'],
+                        'parsl_version': m['parsl_version'],
+                        'python_version': m['python_version'],
+                        'draining': m['draining']
+                    }
                     reply.append(resp)
 
             elif command_req == "MANAGERS_PACKAGES":
                 reply = {}
-                for manager_id in self._ready_managers:
-                    m = self._ready_managers[manager_id]
+                for manager_id, m in self._ready_managers.items():
                     manager_id_str = manager_id.decode('utf-8')
                     reply[manager_id_str] = m["packages"]
 
@@ -402,7 +403,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}",

{parsl-2025.9.1 → parsl-2025.9.15}/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.1 → parsl-2025.9.15}/parsl/monitoring/db_manager.py

@@ -346,9 +346,9 @@ class DatabaseManager:
         exception_happened = False
 
         while (not self._kill_event.is_set() or
-               self.pending_priority_queue.qsize() != 0 or self.pending_resource_queue.qsize() != 0 or
-               self.pending_node_queue.qsize() != 0 or self.pending_block_queue.qsize() != 0 or
-               resource_queue.qsize() != 0):
+               not self.pending_priority_queue.empty() or not self.pending_resource_queue.empty() or
+               not self.pending_node_queue.empty() or not self.pending_block_queue.empty() or
+               not resource_queue.empty()):
 
             """
             WORKFLOW_INFO and TASK_INFO messages (i.e. priority messages)
@@ -357,9 +357,9 @@ class DatabaseManager:
             try:
                 logger.debug("""Checking STOP conditions: {}, {}, {}, {}, {}, {}""".format(
                                   self._kill_event.is_set(),
-                                  self.pending_priority_queue.qsize() != 0, self.pending_resource_queue.qsize() != 0,
-                                  self.pending_node_queue.qsize() != 0, self.pending_block_queue.qsize() != 0,
-                                  resource_queue.qsize() != 0))
+                                  not self.pending_priority_queue.empty(), not self.pending_resource_queue.empty(),
+                                  not self.pending_node_queue.empty(), not self.pending_block_queue.empty(),
+                                  not resource_queue.empty()))
 
                 # This is the list of resource messages which can be reprocessed as if they
                 # had just arrived because the corresponding first task message has been
@@ -558,9 +558,9 @@ class DatabaseManager:
     def _migrate_logs_to_internal(self, logs_queue: mpq.Queue, kill_event: threading.Event) -> None:
         logger.info("Starting _migrate_logs_to_internal")
 
-        while not kill_event.is_set() or logs_queue.qsize() != 0:
+        while not kill_event.is_set() or not logs_queue.empty():
             logger.debug("Checking STOP conditions: kill event: %s, queue has entries: %s",
-                         kill_event.is_set(), logs_queue.qsize() != 0)
+                         kill_event.is_set(), not logs_queue.empty())
 
             try:
                 x = logs_queue.get(timeout=0.1)

{parsl-2025.9.1 → parsl-2025.9.15}/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.1 → parsl-2025.9.15}/parsl/monitoring/radios/udp_router.py

@@ -21,9 +21,9 @@ from parsl.monitoring.errors import MonitoringRouterStartError
 from parsl.monitoring.radios.base import MonitoringRadioReceiver
 from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadioSender
 from parsl.multiprocessing import (
-    SizedQueue,
     SpawnEvent,
     SpawnProcess,
+    SpawnQueue,
     join_terminate_close_proc,
 )
 from parsl.process_loggers import wrap_with_logs
@@ -198,7 +198,7 @@ def start_udp_receiver(*,
                        hmac_digest: str) -> UDPRadioReceiver:
 
     udp_comm_q: Queue[Union[int, str]]
-    udp_comm_q = SizedQueue(maxsize=10)
+    udp_comm_q = SpawnQueue(maxsize=10)
 
     router_exit_event = SpawnEvent()
 

{parsl-2025.9.1 → parsl-2025.9.15}/parsl/monitoring/radios/zmq_router.py

@@ -19,9 +19,9 @@ from parsl.monitoring.errors import MonitoringRouterStartError
 from parsl.monitoring.radios.multiprocessing import MultiprocessingQueueRadioSender
 from parsl.monitoring.types import TaggedMonitoringMessage
 from parsl.multiprocessing import (
-    SizedQueue,
     SpawnEvent,
     SpawnProcess,
+    SpawnQueue,
     join_terminate_close_proc,
 )
 from parsl.process_loggers import wrap_with_logs
@@ -158,7 +158,7 @@ def start_zmq_receiver(*,
                        port_range: Tuple[int, int],
                        logdir: str,
                        worker_debug: bool) -> ZMQRadioReceiver:
-    comm_q = SizedQueue(maxsize=10)
+    comm_q = SpawnQueue(maxsize=10)
 
     router_exit_event = SpawnEvent()
 

{parsl-2025.9.1 → parsl-2025.9.15}/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.1 → parsl-2025.9.15}/parsl/tests/test_checkpointing/test_python_checkpoint_1.py

@@ -1,4 +1,5 @@
 import os
+from pathlib import Path
 
 import pytest
 
@@ -20,12 +21,14 @@ def uuid_app():
 
 
 @pytest.mark.local
-def test_initial_checkpoint_write():
+def test_initial_checkpoint_write() -> None:
     """1. Launch a few apps and write the checkpoint once a few have completed
     """
     uuid_app().result()
 
-    cpt_dir = parsl.dfk().checkpoint()
+    parsl.dfk().checkpoint()
 
-    cptpath = cpt_dir + '/tasks.pkl'
+    cpt_dir = Path(parsl.dfk().run_dir) / 'checkpoint'
+
+    cptpath = cpt_dir / 'tasks.pkl'
     assert os.path.exists(cptpath), f"Tasks checkpoint missing: {cptpath}"

{parsl-2025.9.1 → parsl-2025.9.15}/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.15/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.1 → parsl-2025.9.15}/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)

{parsl-2025.9.1 → parsl-2025.9.15}/parsl/tests/test_htex/test_priority_queue.py

@@ -46,6 +46,7 @@ def test_priority_queue():
             futures[(priority, i)] = fake_task(parsl_resource_specification=spec)
 
         provider.max_blocks = 1
+        htex.scale_out_facade(1)  # don't wait for the JSP to catch up
 
         # Wait for completion
         results = {

{parsl-2025.9.1 → parsl-2025.9.15}/parsl/tests/test_htex/test_zmq_binding.py

@@ -29,7 +29,8 @@ def make_interchange(*,
                        logging_level=logging.INFO,
                        manager_selector=RandomManagerSelector(),
                        poll_period=10,
-                       run_id="test_run_id")
+                       run_id="test_run_id",
+                       _check_python_mismatch=True)
 
 
 @pytest.fixture

parsl-2025.9.15/parsl/tests/test_python_apps/test_memoize_exception.py

@@ -0,0 +1,41 @@
+import parsl
+from parsl.app.app import python_app
+
+
+@python_app(cache=True)
+def raise_exception_cache(x, cache=True):
+    raise RuntimeError("exception from raise_exception_cache")
+
+
+@python_app(cache=False)
+def raise_exception_nocache(x, cache=True):
+    raise RuntimeError("exception from raise_exception_nocache")
+
+
+def test_python_memoization(n=2):
+    """Test Python memoization of exceptions, with cache=True"""
+    x = raise_exception_cache(0)
+
+    # wait for x to be done
+    x.exception()
+
+    for i in range(0, n):
+        fut = raise_exception_cache(0)
+
+        # check that we get back the same exception object, rather than
+        # a new one from a second invocation of raise_exception().
+        assert fut.exception() is x.exception(), "Memoized exception should have been memoized"
+
+
+def test_python_no_memoization(n=2):
+    """Test Python non-memoization of exceptions, with cache=False"""
+    x = raise_exception_nocache(0)
+
+    # wait for x to be done
+    x.exception()
+
+    for i in range(0, n):
+        fut = raise_exception_nocache(0)
+
+        # check that we get back a different exception object each time
+        assert fut.exception() is not x.exception(), "Memoized exception should have been memoized"