parsl 2025.9.15__tar.gz → 2025.9.29__tar.gz

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: parsl
-Version: 2025.9.15
+Version: 2025.9.29
 Summary: Simple data dependent workflows in Python
 Home-page: https://github.com/Parsl/parsl
-Download-URL: https://github.com/Parsl/parsl/archive/2025.09.15.tar.gz
+Download-URL: https://github.com/Parsl/parsl/archive/2025.09.29.tar.gz
 Author: The Parsl Team
 Author-email: parsl@googlegroups.com
 License: Apache 2.0
@@ -11,11 +11,10 @@ Keywords: Workflows,Scientific computing
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.9.0
+Requires-Python: >=3.10.0
 Provides-Extra: monitoring
 Provides-Extra: visualization
 Provides-Extra: aws

{parsl-2025.9.15 → parsl-2025.9.29}/README.rst

@@ -1,6 +1,6 @@
 Parsl - Parallel Scripting Library
 ==================================
-|licence| |docs| |NSF-1550588| |NSF-1550476| |NSF-1550562| |NSF-1550528| |NumFOCUS| |CZI-EOSS| 
+|licence| |docs| |NSF-1550588| |NSF-1550476| |NSF-1550562| |NSF-1550528| |NumFOCUS| |CZI-EOSS| |paper| 
 
 Parsl extends parallelism in Python beyond a single computer.
 
@@ -67,6 +67,9 @@ then explore the `parallel computing patterns <https://parsl.readthedocs.io/en/s
 .. |NumFOCUS| image:: https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A
     :target: https://numfocus.org
     :alt: Powered by NumFOCUS
+.. |paper| image:: https://img.shields.io/badge/Software_DOI-10.1145/3307681.3325400-blue
+    :target: https://doi.org/10.1145/3307681.3325400
+    :alt: Conference proceedings paper
 
    
 Quickstart
@@ -120,7 +123,7 @@ For Developers
 Requirements
 ============
 
-Parsl is supported in Python 3.9+. Requirements can be found `here <requirements.txt>`_. Requirements for running tests can be found `here <test-requirements.txt>`_.
+Parsl is supported in Python 3.10+. Requirements can be found `here <requirements.txt>`_. Requirements for running tests can be found `here <test-requirements.txt>`_.
 
 Code of Conduct
 ===============

{parsl-2025.9.15 → parsl-2025.9.29}/parsl/benchmark/perf.py

@@ -2,32 +2,45 @@ import argparse
 import concurrent.futures
 import importlib
 import time
+from typing import Any, Dict
 
 import parsl
+from parsl.dataflow.dflow import DataFlowKernel
 
 min_iterations = 2
 
 
 # TODO: factor with conftest.py where this is copy/pasted from?
-def load_dfk_from_config(filename):
+def load_dfk_from_config(filename: str) -> DataFlowKernel:
     spec = importlib.util.spec_from_file_location('', filename)
+
+    if spec is None:
+        raise RuntimeError("Could not import configuration")
+
+    module = importlib.util.module_from_spec(spec)
+
+    if spec.loader is None:
+        raise RuntimeError("Could not load configuration")
+
+    spec.loader.exec_module(module)
+
     module = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(module)
 
     if hasattr(module, 'config'):
-        parsl.load(module.config)
+        return parsl.load(module.config)
     elif hasattr(module, 'fresh_config'):
-        parsl.load(module.fresh_config())
+        return parsl.load(module.fresh_config())
     else:
         raise RuntimeError("Config module does not define config or fresh_config")
 
 
 @parsl.python_app
-def app(extra_payload, parsl_resource_specification={}):
+def app(extra_payload: Any, parsl_resource_specification: Dict = {}) -> int:
     return 7
 
 
-def performance(*, resources: dict, target_t: float, args_extra_size: int):
+def performance(*, resources: dict, target_t: float, args_extra_size: int) -> None:
     n = 10
 
     delta_t: float
@@ -82,6 +95,7 @@ Example usage: python -m parsl.benchmark.perf --config parsl/tests/configs/workq
     parser.add_argument("--resources", metavar="EXPR", help="parsl_resource_specification dictionary")
     parser.add_argument("--time", metavar="SECONDS", help="target number of seconds for an iteration", default=120, type=float)
     parser.add_argument("--argsize", metavar="BYTES", help="extra bytes to add into app invocation arguments", default=0, type=int)
+    parser.add_argument("--version", action="version", version=f"parsl-perf from Parsl {parsl.__version__}")
 
     args = parser.parse_args()
 
@@ -90,10 +104,9 @@ Example usage: python -m parsl.benchmark.perf --config parsl/tests/configs/workq
     else:
         resources = {}
 
-    load_dfk_from_config(args.config)
-    performance(resources=resources, target_t=args.time, args_extra_size=args.argsize)
-    print("Cleaning up DFK")
-    parsl.dfk().cleanup()
+    with load_dfk_from_config(args.config):
+        performance(resources=resources, target_t=args.time, args_extra_size=args.argsize)
+        print("Tests complete - leaving DFK block")
     print("The end")
 
 

{parsl-2025.9.15 → parsl-2025.9.29}/parsl/dataflow/dflow.py

@@ -175,7 +175,7 @@ class DataFlowKernel:
         else:
             checkpoint_files = []
 
-        self.memoizer = Memoizer(self, memoize=config.app_cache, checkpoint_files=checkpoint_files)
+        self.memoizer = Memoizer(memoize=config.app_cache, checkpoint_files=checkpoint_files)
         self.checkpointed_tasks = 0
         self._checkpoint_timer = None
         self.checkpoint_mode = config.checkpoint_mode
@@ -561,7 +561,7 @@ class DataFlowKernel:
         if not task_record['app_fu'] == future:
             logger.error("Internal consistency error: callback future is not the app_fu in task structure, for task {}".format(task_id))
 
-        self.memoizer.update_memo(task_record, future)
+        self.memoizer.update_memo(task_record)
 
         # Cover all checkpointing cases here:
         # Do we need to checkpoint now, or queue for later,
@@ -1202,7 +1202,6 @@ class DataFlowKernel:
 
         self.log_task_states()
 
-        # Checkpointing takes priority over the rest of the tasks
         # checkpoint if any valid checkpoint method is specified
         if self.checkpoint_mode is not None:
             self.checkpoint()

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

@@ -4,20 +4,16 @@ import hashlib
 import logging
 import os
 import pickle
+import types
+from concurrent.futures import Future
 from functools import lru_cache, singledispatch
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence
+from typing import Any, Dict, List, Optional, Sequence
 
 import typeguard
 
 from parsl.dataflow.errors import BadCheckpoint
 from parsl.dataflow.taskrecord import TaskRecord
 
-if TYPE_CHECKING:
-    from parsl import DataFlowKernel  # import loop at runtime - needed for typechecking - TODO turn into "if typing:"
-
-import types
-from concurrent.futures import Future
-
 logger = logging.getLogger(__name__)
 
 
@@ -150,17 +146,13 @@ class Memoizer:
 
     """
 
-    def __init__(self, dfk: DataFlowKernel, *, memoize: bool = True, checkpoint_files: Sequence[str]):
+    def __init__(self, *, memoize: bool = True, checkpoint_files: Sequence[str]):
         """Initialize the memoizer.
 
-        Args:
-            - dfk (DFK obj): The DFK object
-
         KWargs:
             - memoize (Bool): enable memoization or not.
             - checkpoint (Dict): A checkpoint loaded as a dict.
         """
-        self.dfk = dfk
         self.memoize = memoize
 
         checkpoint = self.load_checkpoints(checkpoint_files)
@@ -242,16 +234,14 @@ class Memoizer:
         assert isinstance(result, Future) or result is None
         return result
 
-    def update_memo(self, task: TaskRecord, r: Future[Any]) -> None:
+    def update_memo(self, task: TaskRecord) -> None:
         """Updates the memoization lookup table with the result from a task.
+        This doesn't move any values around but associates the memoization
+        hashsum with the completed (by success or failure) AppFuture.
 
         Args:
-             - task (dict) : A task dict from dfk.tasks
-             - r (Result future): Result future
+             - task (TaskRecord) : A task record from dfk.tasks
         """
-        # TODO: could use typeguard
-        assert isinstance(r, Future)
-
         task_id = task['id']
 
         if not self.memoize or not task['memoize'] or 'hashsum' not in task:
@@ -265,7 +255,7 @@ class Memoizer:
             logger.info(f"Replacing app cache entry {task['hashsum']} with result from task {task_id}")
         else:
             logger.debug(f"Storing app cache entry {task['hashsum']} with result from task {task_id}")
-        self.memo_lookup_table[task['hashsum']] = r
+        self.memo_lookup_table[task['hashsum']] = task['app_fu']
 
     def _load_checkpoints(self, checkpointDirs: Sequence[str]) -> Dict[str, Future[Any]]:
         """Load a checkpoint file into a lookup table.

{parsl-2025.9.15 → parsl-2025.9.29}/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.15 → parsl-2025.9.29}/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.15 → parsl-2025.9.29}/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
@@ -237,7 +237,7 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
     @typeguard.typechecked
     def __init__(self,
                  label: str = 'HighThroughputExecutor',
-                 provider: ExecutionProvider = LocalProvider(),
+                 provider: Optional[ExecutionProvider] = None,
                  launch_cmd: Optional[str] = None,
                  interchange_launch_cmd: Optional[Sequence[str]] = None,
                  address: Optional[str] = None,
@@ -267,7 +267,9 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
 
         logger.debug("Initializing HighThroughputExecutor")
 
-        BlockProviderExecutor.__init__(self, provider=provider, block_error_handler=block_error_handler)
+        BlockProviderExecutor.__init__(self,
+                                       provider=provider if provider else LocalProvider(),
+                                       block_error_handler=block_error_handler)
         self.label = label
         self.worker_debug = worker_debug
         self.storage_access = storage_access
@@ -501,10 +503,7 @@ class HighThroughputExecutor(BlockProviderExecutor, RepresentationMixin, UsageIn
             else:
 
                 for serialized_msg in msgs:
-                    try:
-                        msg = pickle.loads(serialized_msg)
-                    except pickle.UnpicklingError:
-                        raise BadMessage("Message received could not be unpickled")
+                    msg = pickle.loads(serialized_msg)
 
                     if msg['type'] == 'result':
                         try:
@@ -708,13 +707,15 @@ 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__)
 
-        msg = {"task_id": task_id, "resource_spec": resource_specification, "buffer": fn_buf}
+        context = {}
+        if resource_specification:
+            context["resource_spec"] = resource_specification
+
+        msg = {"task_id": task_id, "context": context, "buffer": fn_buf}
 
         # Post task to the outgoing queue
         self.outgoing_q.put(msg)

{parsl-2025.9.15 → parsl-2025.9.29}/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)
@@ -220,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()
@@ -328,12 +327,12 @@ 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()
 
             # Process priority, higher number = lower priority
-            resource_spec = msg.get('resource_spec', {})
+            resource_spec = msg['context'].get('resource_spec', {})
             priority = resource_spec.get('priority', float('inf'))
             queue_entry = (-priority, -self.task_counter, msg)
 
@@ -361,9 +360,10 @@ class Interchange:
             mtype = meta['type']
         except Exception as e:
             logger.warning(
-                f'Failed to read manager message ([{type(e).__name__}] {e})'
+                'Failed to read manager message; ignoring message'
+                f' (Exception: [{type(e).__name__}] {e})'
             )
-            logger.debug('Message:\n   %r\n', msg_parts, exc_info=e)
+            logger.debug('Raw message bytes:\n   %r\n', msg_parts, exc_info=e)
             return
 
         logger.debug(
@@ -627,6 +627,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.15 → parsl-2025.9.29}/parsl/executors/high_throughput/mpi_executor.py

@@ -16,7 +16,6 @@ from parsl.executors.status_handling import BlockProviderExecutor
 from parsl.jobs.states import JobStatus
 from parsl.launchers import SimpleLauncher
 from parsl.monitoring.radios.base import RadioConfig
-from parsl.providers import LocalProvider
 from parsl.providers.base import ExecutionProvider
 
 
@@ -47,7 +46,7 @@ class MPIExecutor(HighThroughputExecutor):
     @typeguard.typechecked
     def __init__(self,
                  label: str = 'MPIExecutor',
-                 provider: ExecutionProvider = LocalProvider(),
+                 provider: Optional[ExecutionProvider] = None,
                  launch_cmd: Optional[str] = None,
                  interchange_launch_cmd: Optional[str] = None,
                  address: Optional[str] = None,

{parsl-2025.9.15 → parsl-2025.9.29}/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,13 +166,10 @@ 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("context", {}).get("resource_spec", {})
 
-        nodes_needed = resource_spec.get("num_nodes")
-        tid = task_package["task_id"]
-        if nodes_needed:
+        if nodes_needed := resource_spec.get("num_nodes"):
+            tid = task_package["task_id"]
             try:
                 allocated_nodes = self._get_nodes(nodes_needed)
             except MPINodesUnavailable:
@@ -183,9 +179,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.15 → parsl-2025.9.29}/parsl/executors/high_throughput/process_worker_pool.py

@@ -373,6 +373,8 @@ class Manager:
             if socks.get(ix_sock) == zmq.POLLIN:
                 pkl_msg = ix_sock.recv()
                 tasks = pickle.loads(pkl_msg)
+                del pkl_msg
+
                 last_interchange_contact = time.time()
 
                 if tasks == HEARTBEAT_CODE:
@@ -454,6 +456,7 @@ class Manager:
                                               'exception': serialize(RemoteExceptionWrapper(*sys.exc_info()))}
                             pkl_package = pickle.dumps(result_package)
                             self.pending_result_queue.put(pkl_package)
+                            del pkl_package
                     except KeyError:
                         logger.info("Worker {} was not busy when it died".format(worker_id))
 
@@ -603,6 +606,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 +760,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
 
@@ -766,7 +773,10 @@ def worker(
             ready_worker_count.value -= 1
         worker_enqueued = False
 
-        _init_mpi_env(mpi_launcher=mpi_launcher, resource_spec=req["resource_spec"])
+        ctxt = req["context"]
+        res_spec = ctxt.get("resource_spec", {})
+
+        _init_mpi_env(mpi_launcher=mpi_launcher, resource_spec=res_spec)
 
         try:
             result = execute_task(req['buffer'])
@@ -776,7 +786,8 @@ def worker(
             result_package = {'type': 'result', 'task_id': tid, 'exception': serialize(RemoteExceptionWrapper(*sys.exc_info()))}
         else:
             result_package = {'type': 'result', 'task_id': tid, 'result': serialized_result}
-            # logger.debug("Result: {}".format(result))
+            del serialized_result
+        del req
 
         logger.info("Completed executor task {}".format(tid))
         try:
@@ -788,6 +799,7 @@ def worker(
                                         })
 
         result_queue.put(pkl_package)
+        del pkl_package, result_package
         tasks_in_progress.pop(worker_id)
         logger.info("All processing finished for executor task {}".format(tid))
 

{parsl-2025.9.15 → parsl-2025.9.29}/parsl/executors/high_throughput/zmq_pipes.py

@@ -136,30 +136,18 @@ class TasksOutgoing:
         self.port = self.zmq_socket.bind_to_random_port(tcp_url(ip_address),
                                                         min_port=port_range[0],
                                                         max_port=port_range[1])
-        self.poller = zmq.Poller()
-        self.poller.register(self.zmq_socket, zmq.POLLOUT)
 
     def put(self, message):
         """ This function needs to be fast at the same time aware of the possibility of
         ZMQ pipes overflowing.
 
-        The timeout increases slowly if contention is detected on ZMQ pipes.
         We could set copy=False and get slightly better latency but this results
         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.
         """
-        timeout_ms = 1
-        while True:
-            socks = dict(self.poller.poll(timeout=timeout_ms))
-            if self.zmq_socket in socks and socks[self.zmq_socket] == zmq.POLLOUT:
-                # The copy option adds latency but reduces the risk of ZMQ overflow
-                logger.debug("Sending TasksOutgoing message")
-                self.zmq_socket.send_pyobj(message, copy=True)
-                logger.debug("Sent TasksOutgoing message")
-                return
-            else:
-                timeout_ms *= 2
-                logger.debug("Not sending due to non-ready zmq pipe, timeout: {} ms".format(timeout_ms))
+        logger.debug("Sending TasksOutgoing message")
+        self.zmq_socket.send_pyobj(message)
+        logger.debug("Sent TasksOutgoing message")
 
     def close(self):
         self.zmq_socket.close()
@@ -192,20 +180,15 @@ class ResultsIncoming:
         self.port = self.results_receiver.bind_to_random_port(tcp_url(ip_address),
                                                               min_port=port_range[0],
                                                               max_port=port_range[1])
-        self.poller = zmq.Poller()
-        self.poller.register(self.results_receiver, zmq.POLLIN)
 
     def get(self, timeout_ms=None):
         """Get a message from the queue, returning None if timeout expires
         without a message. timeout is measured in milliseconds.
         """
-        socks = dict(self.poller.poll(timeout=timeout_ms))
-        if self.results_receiver in socks and socks[self.results_receiver] == zmq.POLLIN:
-            m = self.results_receiver.recv_multipart()
-            logger.debug("Received ResultsIncoming message")
-            return m
-        else:
-            return None
+        if zmq.POLLIN == self.results_receiver.poll(timeout_ms, zmq.POLLIN):
+            logger.debug("Receiving ResultsIncoming multipart message")
+            return self.results_receiver.recv_multipart()
+        return None
 
     def close(self):
         self.results_receiver.close()

{parsl-2025.9.15 → parsl-2025.9.29}/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.15 → parsl-2025.9.29}/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.15 → parsl-2025.9.29}/parsl/executors/taskvine/executor.py

@@ -107,13 +107,17 @@ class TaskVineExecutor(BlockProviderExecutor, putils.RepresentationMixin):
                  function_exec_mode: Union[Literal['regular'], Literal['serverless']] = 'regular',
                  manager_config: TaskVineManagerConfig = TaskVineManagerConfig(),
                  factory_config: TaskVineFactoryConfig = TaskVineFactoryConfig(),
-                 provider: Optional[ExecutionProvider] = LocalProvider(init_blocks=1),
+                 provider: Optional[ExecutionProvider] = None,
                  storage_access: Optional[List[Staging]] = None,
                  remote_monitoring_radio: Optional[RadioConfig] = None):
 
         # Set worker launch option for this executor
         if worker_launch_method == 'factory' or worker_launch_method == 'manual':
             provider = None
+        elif worker_launch_method == 'provider' and provider is None:
+            # provider method chosen, but no explicit provider supplied to __init__
+            # so default to LocalProvider
+            provider = LocalProvider(init_blocks=1)
 
         # Initialize the parent class with the execution provider and block error handling enabled.
         # If provider is None, then no worker is launched via the provider method.

parsl-2025.9.29/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",
+)