parsl 2025.9.15__tar.gz → 2025.9.22__tar.gz

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: parsl
-Version: 2025.9.15
+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.15.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.15 → 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.15 → 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.15 → 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
@@ -708,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.15 → 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)
@@ -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,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()
 
@@ -627,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.15 → 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.15 → 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.15 → 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.15 → 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.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.15 → 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.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.15 → parsl-2025.9.22}/parsl/tests/test_htex/test_priority_queue.py

@@ -1,3 +1,5 @@
+from random import randint
+
 import pytest
 
 import parsl
@@ -40,8 +42,11 @@ def test_priority_queue():
         futures = {}
 
         # Submit tasks with mixed priorities
-        # Priorities: [10, 10, 5, 5, 1, 1] to test fallback behavior
-        for i, priority in enumerate([10, 10, 5, 5, 1, 1]):
+        # Test fallback behavior with a guaranteed-unsorted priorities
+        priorities = [randint(2, 9) for _ in range(randint(1, 10))]
+        priorities.insert(0, 10)
+        priorities.extend((1, 10, 1))
+        for i, priority in enumerate(priorities):
             spec = {'priority': priority}
             futures[(priority, i)] = fake_task(parsl_resource_specification=spec)
 

{parsl-2025.9.15 → parsl-2025.9.22}/parsl/tests/test_mpi_apps/test_mpi_scheduler.py

@@ -1,4 +1,3 @@
-import logging
 import os
 import pickle
 from unittest import mock
@@ -10,7 +9,9 @@ from parsl.executors.high_throughput.mpi_resource_management import (
     TaskScheduler,
 )
 from parsl.multiprocessing import SpawnContext
-from parsl.serialize import pack_res_spec_apply_message, unpack_res_spec_apply_message
+from parsl.serialize import pack_apply_message
+
+mock_task_buffer = pack_apply_message("func", "args", "kwargs")
 
 
 @pytest.fixture(autouse=True)
@@ -42,12 +43,8 @@ def test_MPISched_put_task():
     assert len(scheduler.available_nodes) == 8
     assert scheduler._free_node_counter.value == 8
 
-    mock_task_buffer = pack_res_spec_apply_message("func",
-                                                   "args",
-                                                   "kwargs",
-                                                   resource_specification={"num_nodes": 2,
-                                                                           "ranks_per_node": 2})
-    task_package = {"task_id": 1, "buffer": mock_task_buffer}
+    res_spec = {"num_nodes": 2, "ranks_per_node": 2}
+    task_package = {"task_id": 1, "buffer": mock_task_buffer, "resource_spec": res_spec}
     scheduler.put_task(task_package)
 
     assert scheduler._free_node_counter.value == 6
@@ -82,21 +79,17 @@ def test_MPISched_roundtrip():
     assert scheduler.available_nodes
     assert len(scheduler.available_nodes) == 8
 
-    for round in range(1, 9):
+    for trip in range(1, 9):
         assert scheduler._free_node_counter.value == 8
 
-        mock_task_buffer = pack_res_spec_apply_message("func",
-                                                       "args",
-                                                       "kwargs",
-                                                       resource_specification={"num_nodes": round,
-                                                                               "ranks_per_node": 2})
-        task_package = {"task_id": round, "buffer": mock_task_buffer}
+        res_spec = {"num_nodes": trip, "ranks_per_node": 2}
+        task_package = {"task_id": trip, "buffer": mock_task_buffer, "resource_spec": res_spec}
         scheduler.put_task(task_package)
 
-        assert scheduler._free_node_counter.value == 8 - round
+        assert scheduler._free_node_counter.value == 8 - trip
 
         # Pop in a mock result
-        result_pkl = pickle.dumps({"task_id": round, "type": "result", "buffer": "RESULT BUF"})
+        result_pkl = pickle.dumps({"task_id": trip, "type": "result", "buffer": "RESULT BUF"})
         result_q.put(result_pkl)
 
         got_result = scheduler.get_result(True, 1)
@@ -114,27 +107,15 @@ def test_MPISched_contention():
 
     assert scheduler._free_node_counter.value == 8
 
-    mock_task_buffer = pack_res_spec_apply_message("func",
-                                                   "args",
-                                                   "kwargs",
-                                                   resource_specification={
-                                                       "num_nodes": 8,
-                                                       "ranks_per_node": 2
-                                                   })
-    task_package = {"task_id": 1, "buffer": mock_task_buffer}
+    rspec_1 = {"num_nodes": 8, "ranks_per_node": 2}
+    task_package = {"task_id": 1, "buffer": mock_task_buffer, "resource_spec": rspec_1}
     scheduler.put_task(task_package)
 
     assert scheduler._free_node_counter.value == 0
     assert scheduler._backlog_queue.empty()
 
-    mock_task_buffer = pack_res_spec_apply_message("func",
-                                                   "args",
-                                                   "kwargs",
-                                                   resource_specification={
-                                                       "num_nodes": 8,
-                                                       "ranks_per_node": 2
-                                                   })
-    task_package = {"task_id": 2, "buffer": mock_task_buffer}
+    rspec_2 = {"num_nodes": 8, "ranks_per_node": 2}
+    task_package = {"task_id": 2, "buffer": mock_task_buffer, "resource_spec": rspec_2}
     scheduler.put_task(task_package)
 
     # Second task should now be in the backlog_queue
@@ -143,8 +124,7 @@ def test_MPISched_contention():
     # Confirm that the first task is available and has all 8 nodes provisioned
     task_on_worker_side = task_q.get()
     assert task_on_worker_side['task_id'] == 1
-    _, _, _, resource_spec = unpack_res_spec_apply_message(task_on_worker_side['buffer'])
-    assert len(resource_spec['MPI_NODELIST'].split(',')) == 8
+    assert len(rspec_1["MPI_NODELIST"].split(",")) == 8
     assert task_q.empty()  # Confirm that task 2 is not yet scheduled
 
     # Simulate worker returning result and the scheduler picking up result
@@ -159,8 +139,7 @@ def test_MPISched_contention():
     # Pop in a mock result
     task_on_worker_side = task_q.get()
     assert task_on_worker_side['task_id'] == 2
-    _, _, _, resource_spec = unpack_res_spec_apply_message(task_on_worker_side['buffer'])
-    assert len(resource_spec['MPI_NODELIST'].split(',')) == 8
+    assert len(rspec_2["MPI_NODELIST"].split(",")) == 8
 
 
 @pytest.mark.local
@@ -178,11 +157,7 @@ def test_hashable_backlog_queue():
     assert scheduler._free_node_counter.value == 8
 
     for i in range(3):
-        mock_task_buffer = pack_res_spec_apply_message("func", "args", "kwargs",
-                                                       resource_specification={
-                                                           "num_nodes": 8,
-                                                           "ranks_per_node": 2
-                                                       })
-        task_package = {"task_id": i, "buffer": mock_task_buffer}
+        res_spec = {"num_nodes": 8, "ranks_per_node": 2}
+        task_package = {"task_id": i, "buffer": mock_task_buffer, "resource_spec": res_spec}
         scheduler.put_task(task_package)
     assert scheduler._backlog_queue.qsize() == 2, "Expected 2 backlogged tasks"

{parsl-2025.9.15 → parsl-2025.9.22}/parsl/version.py

@@ -3,4 +3,4 @@
 Year.Month.Day[alpha/beta/..]
 Alphas will be numbered like this -> 2024.12.10a0
 """
-VERSION = '2025.09.15'
+VERSION = '2025.09.22'

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: parsl
-Version: 2025.9.15
+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.15.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.15 → parsl-2025.9.22}/parsl.egg-info/SOURCES.txt

@@ -423,7 +423,6 @@ parsl/tests/test_serialization/test_2555_caching_deserializer.py
 parsl/tests/test_serialization/test_3495_deserialize_managerlost.py
 parsl/tests/test_serialization/test_basic.py
 parsl/tests/test_serialization/test_htex_code_cache.py
-parsl/tests/test_serialization/test_pack_resource_spec.py
 parsl/tests/test_serialization/test_proxystore_configured.py
 parsl/tests/test_serialization/test_proxystore_impl.py
 parsl/tests/test_shutdown/__init__.py

parsl-2025.9.15/parsl/serialize/__init__.py

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

parsl-2025.9.15/parsl/tests/test_execute_task.py

@@ -1,29 +0,0 @@
-import os
-
-import pytest
-
-from parsl.executors.execute_task import execute_task
-from parsl.serialize.facade import pack_res_spec_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_res_spec_apply_message(addemup, args, kwargs, {})
-    res = execute_task(buff)
-    assert res == addemup(*args, **kwargs)
-
-
-@pytest.mark.local
-def test_execute_task_resource_spec():
-    resource_spec = {"num_nodes": 2, "ranks_per_node": 2, "num_ranks": 4}
-    buff = pack_res_spec_apply_message(addemup, (1, 2), {}, resource_spec)
-    execute_task(buff)
-    for key, val in resource_spec.items():
-        assert os.environ[f"PARSL_{key.upper()}"] == str(val)

parsl-2025.9.15/parsl/tests/test_serialization/test_pack_resource_spec.py

@@ -1,23 +0,0 @@
-import pytest
-
-from parsl.serialize import pack_res_spec_apply_message, unpack_res_spec_apply_message
-
-
-def double(x: int, y: int = 2) -> int:
-    return x * y
-
-
-@pytest.mark.local
-def test_pack_and_unpack():
-    args = (5,)
-    kwargs = {'y': 10}
-    resource_spec = {'num_nodes': 4}
-    packed = pack_res_spec_apply_message(double, args, kwargs, resource_specification=resource_spec)
-
-    unpacked = unpack_res_spec_apply_message(packed)
-    assert len(unpacked) == 4
-    u_fn, u_args, u_kwargs, u_res_spec = unpacked
-    assert u_fn == double
-    assert u_args == args
-    assert u_kwargs == kwargs
-    assert u_res_spec == resource_spec