parsl 2024.3.18__py3-none-any.whl → 2025.1.13__py3-none-any.whl

parsl/dataflow/errors.py

@@ -1,6 +1,7 @@
-from parsl.errors import ParslError
 from typing import Optional, Sequence, Tuple
 
+from parsl.errors import ParslError
+
 
 class DataFlowException(ParslError):
     """Base class for all exceptions.
@@ -24,11 +25,8 @@ class BadCheckpoint(DataFlowException):
     def __init__(self, reason: str) -> None:
         self.reason = reason
 
-    def __repr__(self) -> str:
-        return self.reason
-
     def __str__(self) -> str:
-        return self.__repr__()
+        return self.reason
 
 
 class DependencyError(DataFlowException):

parsl/dataflow/futures.py

@@ -1,19 +1,11 @@
-"""This module implements the AppFutures.
-
-We have two basic types of futures:
-    1. DataFutures which represent data objects
-    2. AppFutures which represent the futures on App/Leaf tasks.
-
-"""
 from __future__ import annotations
 
-from concurrent.futures import Future
 import logging
 import threading
-from typing import Any, Optional, Sequence
+from concurrent.futures import Future
+from typing import Any, Optional, Sequence, Union
 
 import parsl.app.app as app
-
 from parsl.app.futures import DataFuture
 from parsl.dataflow.taskrecord import TaskRecord
 
@@ -77,13 +69,34 @@ class AppFuture(Future):
         self._outputs = []
         self.task_record = task_record
 
+        self._stdout_future: Optional[DataFuture] = None
+        self._stderr_future: Optional[DataFuture] = None
+
     @property
-    def stdout(self) -> Optional[str]:
-        return self.task_record['kwargs'].get('stdout')
+    def stdout(self) -> Union[None, str, DataFuture]:
+        """Return app stdout. If stdout was specified as a string, then this
+        property will return that string. If stdout was specified as a File,
+        then this property will return a DataFuture representing that file
+        stageout.
+        TODO: this can be a tuple too I think?"""
+        if self._stdout_future:
+            return self._stdout_future
+        else:
+            # this covers the str and None cases
+            return self.task_record['kwargs'].get('stdout')
 
     @property
-    def stderr(self) -> Optional[str]:
-        return self.task_record['kwargs'].get('stderr')
+    def stderr(self) -> Union[None, str, DataFuture]:
+        """Return app stderr. If stdout was specified as a string, then this
+        property will return that string. If stdout was specified as a File,
+        then this property will return a DataFuture representing that file
+        stageout.
+        TODO: this can be a tuple too I think?"""
+        if self._stderr_future:
+            return self._stderr_future
+        else:
+            # this covers the str and None cases
+            return self.task_record['kwargs'].get('stderr')
 
     @property
     def tid(self) -> int:

parsl/dataflow/memoization.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
+
 import hashlib
-from functools import lru_cache, singledispatch
 import logging
 import pickle
-from parsl.dataflow.taskrecord import TaskRecord
+from functools import lru_cache, singledispatch
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
-from typing import Dict, Any, List, Optional, TYPE_CHECKING
+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:"
 
-from concurrent.futures import Future
-
 import types
+from concurrent.futures import Future
 
 logger = logging.getLogger(__name__)
 

parsl/dataflow/rundirs.py

@@ -1,22 +1,21 @@
+import logging
 import os
 from glob import glob
-import logging
 
 logger = logging.getLogger(__name__)
 
 
 def make_rundir(path: str) -> str:
-    """When a path has not been specified, make the run directory.
+    """Create a numbered run directory under the specified path.
 
-    Creates a rundir with the following hierarchy:
-        ./runinfo <- Home of all run directories
+        ./runinfo <- specified path
           |----000
           |----001 <- Directories for each run
           | ....
           |----NNN
 
-    Kwargs:
-        - path (str): String path to a specific run dir
+    Args:
+        - path (str): String path to root of all rundirs
     """
     try:
         if not os.path.exists(path):

parsl/dataflow/taskrecord.py

@@ -1,19 +1,18 @@
 from __future__ import annotations
 
-import threading
 import datetime
-from typing_extensions import TypedDict
+import threading
 from concurrent.futures import Future
 
-
 # only for type checking:
-from typing import Any, Callable, Dict, Optional, List, Sequence, TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Union
+
+from typing_extensions import TypedDict
 
 if TYPE_CHECKING:
     from parsl.dataflow.futures import AppFuture
 
 import parsl.dataflow.dflow as dflow
-
 from parsl.dataflow.states import States
 
 

parsl/executors/__init__.py

@@ -1,9 +1,11 @@
+from parsl.executors.flux.executor import FluxExecutor
+from parsl.executors.high_throughput.executor import HighThroughputExecutor
+from parsl.executors.high_throughput.mpi_executor import MPIExecutor
 from parsl.executors.threads import ThreadPoolExecutor
 from parsl.executors.workqueue.executor import WorkQueueExecutor
-from parsl.executors.high_throughput.executor import HighThroughputExecutor
-from parsl.executors.flux.executor import FluxExecutor
 
 __all__ = ['ThreadPoolExecutor',
            'HighThroughputExecutor',
+           'MPIExecutor',
            'WorkQueueExecutor',
            'FluxExecutor']

parsl/executors/base.py

@@ -1,9 +1,11 @@
+import os
 from abc import ABCMeta, abstractmethod
 from concurrent.futures import Future
-from typing import Any, Callable, Dict, Optional, List
+from typing import Any, Callable, Dict, Optional
+
 from typing_extensions import Literal, Self
 
-from parsl.jobs.states import JobStatus
+from parsl.monitoring.radios.base import MonitoringRadioSender
 
 
 class ParslExecutor(metaclass=ABCMeta):
@@ -45,6 +47,21 @@ class ParslExecutor(metaclass=ABCMeta):
     label: str = "undefined"
     radio_mode: str = "udp"
 
+    def __init__(
+        self,
+        *,
+        hub_address: Optional[str] = None,
+        hub_zmq_port: Optional[int] = None,
+        submit_monitoring_radio: Optional[MonitoringRadioSender] = None,
+        run_dir: str = ".",
+        run_id: Optional[str] = None,
+    ):
+        self.hub_address = hub_address
+        self.hub_zmq_port = hub_zmq_port
+        self.submit_monitoring_radio = submit_monitoring_radio
+        self.run_dir = os.path.abspath(run_dir)
+        self.run_id = run_id
+
     def __enter__(self) -> Self:
         return self
 
@@ -53,7 +70,7 @@ class ParslExecutor(metaclass=ABCMeta):
         return False
 
     @abstractmethod
-    def start(self) -> Optional[List[str]]:
+    def start(self) -> None:
         """Start the executor.
 
         Any spin-up operations (for example: starting thread pools) should be performed here.
@@ -79,13 +96,6 @@ class ParslExecutor(metaclass=ABCMeta):
         """
         pass
 
-    def create_monitoring_info(self, status: Dict[str, JobStatus]) -> List[object]:
-        """Create a monitoring message for each block based on the poll status.
-
-        :return: a list of dictionaries mapping to the info of each block
-        """
-        return []
-
     def monitor_resources(self) -> bool:
         """Should resource monitoring happen for tasks on running on this executor?
 
@@ -106,6 +116,16 @@ class ParslExecutor(metaclass=ABCMeta):
     def run_dir(self, value: str) -> None:
         self._run_dir = value
 
+    @property
+    def run_id(self) -> Optional[str]:
+        """UUID for the enclosing DFK.
+        """
+        return self._run_id
+
+    @run_id.setter
+    def run_id(self, value: Optional[str]) -> None:
+        self._run_id = value
+
     @property
     def hub_address(self) -> Optional[str]:
         """Address to the Hub for monitoring.
@@ -117,11 +137,21 @@ class ParslExecutor(metaclass=ABCMeta):
         self._hub_address = value
 
     @property
-    def hub_port(self) -> Optional[int]:
+    def hub_zmq_port(self) -> Optional[int]:
         """Port to the Hub for monitoring.
         """
-        return self._hub_port
+        return self._hub_zmq_port
+
+    @hub_zmq_port.setter
+    def hub_zmq_port(self, value: Optional[int]) -> None:
+        self._hub_zmq_port = value
+
+    @property
+    def submit_monitoring_radio(self) -> Optional[MonitoringRadioSender]:
+        """Local radio for sending monitoring messages
+        """
+        return self._submit_monitoring_radio
 
-    @hub_port.setter
-    def hub_port(self, value: Optional[int]) -> None:
-        self._hub_port = value
+    @submit_monitoring_radio.setter
+    def submit_monitoring_radio(self, value: Optional[MonitoringRadioSender]) -> None:
+        self._submit_monitoring_radio = value

parsl/executors/errors.py

@@ -1,4 +1,6 @@
 """Exceptions raise by Executors."""
+from typing import Set
+
 from parsl.errors import ParslError
 from parsl.executors.base import ParslExecutor
 
@@ -44,6 +46,17 @@ class UnsupportedFeatureError(ExecutorError):
                                                                  self.current_executor)
 
 
+class InvalidResourceSpecification(ExecutorError):
+    """Error raised when Invalid input is supplied via resource Specification"""
+
+    def __init__(self, invalid_keys: Set[str], message: str = ''):
+        self.invalid_keys = invalid_keys
+        self.message = message
+
+    def __str__(self):
+        return f"Invalid Resource Specification Supplied: {self.invalid_keys}. {self.message}"
+
+
 class ScalingFailed(ExecutorError):
     """Scaling failed due to error in Execution provider."""
 

parsl/executors/execute_task.py

@@ -0,0 +1,37 @@
+import os
+
+from parsl.serialize import unpack_res_spec_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])
+
+    # We might need to look into callability of the function from itself
+    # since we change it's name in the new namespace
+    prefix = "parsl_"
+    fname = prefix + "f"
+    argname = prefix + "args"
+    kwargname = prefix + "kwargs"
+    resultname = prefix + "result"
+
+    code = "{0} = {1}(*{2}, **{3})".format(resultname, fname,
+                                           argname, kwargname)
+
+    user_ns = locals()
+    user_ns.update({
+        '__builtins__': __builtins__,
+        fname: f,
+        argname: args,
+        kwargname: kwargs,
+        resultname: resultname
+    })
+
+    exec(code, user_ns, user_ns)
+    return user_ns.get(resultname)

parsl/executors/flux/execute_parsl_task.py

@@ -1,12 +1,12 @@
 """Script for executing tasks inside of Flux jobs."""
 
 import argparse
-import os
 import logging
+import os
 
-from parsl.executors.high_throughput.process_worker_pool import execute_task
-from parsl.serialize import serialize
+from parsl.executors.execute_task import execute_task
 from parsl.executors.flux import TaskResult
+from parsl.serialize import serialize
 
 
 def main():

parsl/executors/flux/executor.py

@@ -1,33 +1,32 @@
 """Defines the FluxExecutor class."""
 
+import collections
 import concurrent.futures as cf
 import functools
+import itertools
 import os
+import queue
+import shutil
 import sys
-import uuid
 import threading
-import itertools
-import shutil
-import queue
-from socket import gethostname
-import collections
-from collections.abc import Mapping, Callable
-from typing import Optional, Any, Dict
+import uuid
 import weakref
+from collections.abc import Callable, Mapping
+from socket import gethostname
+from typing import Any, Dict, Optional
 
 import zmq
 
-from parsl.utils import RepresentationMixin
+from parsl.app.errors import AppException
 from parsl.executors.base import ParslExecutor
+from parsl.executors.errors import ScalingFailed
 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.executors.errors import ScalingFailed
 from parsl.providers import LocalProvider
 from parsl.providers.base import ExecutionProvider
 from parsl.serialize import deserialize, pack_res_spec_apply_message
 from parsl.serialize.errors import SerializationError
-from parsl.app.errors import AppException
-
+from parsl.utils import RepresentationMixin
 
 _WORKER_PATH = os.path.realpath(_WORKER_PATH)
 _MANAGER_PATH = os.path.realpath(_MANAGER_PATH)
@@ -201,7 +200,6 @@ class FluxExecutor(ParslExecutor, RepresentationMixin):
                 raise EnvironmentError("Cannot find Flux installation in PATH")
         self.flux_path = os.path.abspath(flux_path)
         self._task_id_counter = itertools.count()
-        self._socket = zmq.Context().socket(zmq.REP)
         # Assumes a launch command cannot be None or empty
         self.launch_cmd = launch_cmd or self.DEFAULT_LAUNCH_CMD
         self._submission_queue: queue.Queue = queue.Queue()
@@ -214,7 +212,6 @@ class FluxExecutor(ParslExecutor, RepresentationMixin):
             args=(
                 self._submission_queue,
                 self._stop_event,
-                self._socket,
                 self.working_dir,
                 self.flux_executor_kwargs,
                 self.provider,
@@ -307,11 +304,13 @@ def _submit_wrapper(
 
     If an exception is thrown, error out all submitted tasks.
     """
-    try:
-        _submit_flux_jobs(submission_queue, stop_event, *args, **kwargs)
-    except Exception as exc:
-        _error_out_jobs(submission_queue, stop_event, exc)
-        raise
+    with zmq.Context() as ctx:
+        with ctx.socket(zmq.REP) as socket:
+            try:
+                _submit_flux_jobs(submission_queue, stop_event, socket, *args, **kwargs)
+            except Exception as exc:
+                _error_out_jobs(submission_queue, stop_event, exc)
+                raise
 
 
 def _error_out_jobs(

parsl/executors/flux/flux_instance_manager.py

@@ -1,10 +1,10 @@
 """Script meant to be the initial program of a Flux instance."""
 
 import argparse
+import logging
 import os
 from os.path import dirname
-import logging
-from socket import gethostname, gethostbyname
+from socket import gethostbyname, gethostname
 
 import zmq
 
@@ -16,8 +16,8 @@ def main():
     encapsulating Flux instance.
     """
     # flux imports only available when launched under Flux instance
-    import flux.job
     import flux
+    import flux.job
 
     logging.basicConfig(
         level=logging.DEBUG, format="%(asctime)s [%(levelname)s] %(message)s"
@@ -27,30 +27,29 @@ def main():
     parser.add_argument("hostname", help="hostname of the parent executor's socket")
     parser.add_argument("port", help="Port of the parent executor's socket")
     args = parser.parse_args()
-    context = zmq.Context()
-    socket = context.socket(zmq.REQ)
-    socket.connect(
-        args.protocol + "://" + gethostbyname(args.hostname) + ":" + args.port
-    )
-    # send the path to the ``flux.job`` package
-    socket.send(dirname(dirname(os.path.realpath(flux.__file__))).encode())
-    logging.debug("Flux package path sent.")
-    # collect the encapsulating Flux instance's URI
-    local_uri = flux.Flux().attr_get("local-uri")
-    hostname = gethostname()
-    if args.hostname == hostname:
-        flux_uri = local_uri
-    else:
-        flux_uri = "ssh://" + gethostname() + local_uri.replace("local://", "")
-    logging.debug("Flux URI is %s", flux_uri)
-    response = socket.recv()  # get acknowledgment
-    logging.debug("Received acknowledgment %s", response)
-    socket.send(flux_uri.encode())  # send URI
-    logging.debug("URI sent. Blocking for response...")
-    response = socket.recv()  # wait for shutdown message
-    logging.debug("Response %s received, draining flux jobs...", response)
-    flux.Flux().rpc("job-manager.drain").get()
-    logging.debug("Flux jobs drained, exiting.")
+    with zmq.Context() as context, context.socket(zmq.REQ) as socket:
+        socket.connect(
+            args.protocol + "://" + gethostbyname(args.hostname) + ":" + args.port
+        )
+        # send the path to the ``flux.job`` package
+        socket.send(dirname(dirname(os.path.realpath(flux.__file__))).encode())
+        logging.debug("Flux package path sent.")
+        # collect the encapsulating Flux instance's URI
+        local_uri = flux.Flux().attr_get("local-uri")
+        hostname = gethostname()
+        if args.hostname == hostname:
+            flux_uri = local_uri
+        else:
+            flux_uri = "ssh://" + gethostname() + local_uri.replace("local://", "")
+        logging.debug("Flux URI is %s", flux_uri)
+        response = socket.recv()  # get acknowledgment
+        logging.debug("Received acknowledgment %s", response)
+        socket.send(flux_uri.encode())  # send URI
+        logging.debug("URI sent. Blocking for response...")
+        response = socket.recv()  # wait for shutdown message
+        logging.debug("Response %s received, draining flux jobs...", response)
+        flux.Flux().rpc("job-manager.drain").get()
+        logging.debug("Flux jobs drained, exiting.")
 
 
 if __name__ == "__main__":

parsl/executors/high_throughput/errors.py

@@ -1,3 +1,36 @@
+import time
+
+
+class ManagerLost(Exception):
+    """
+    Task lost due to manager loss.  Manager is considered lost when multiple heartbeats
+    have been missed.
+    """
+    def __init__(self, manager_id: bytes, hostname: str) -> None:
+        self.manager_id = manager_id
+        self.tstamp = time.time()
+        self.hostname = hostname
+
+    def __str__(self) -> str:
+        return (
+            f"Task failure due to loss of manager {self.manager_id.decode()} on"
+            f" host {self.hostname}"
+        )
+
+
+class VersionMismatch(Exception):
+    """Manager and Interchange versions do not match"""
+    def __init__(self, interchange_version: str, manager_version: str):
+        self.interchange_version = interchange_version
+        self.manager_version = manager_version
+
+    def __str__(self) -> str:
+        return (
+            f"Manager version info {self.manager_version} does not match interchange"
+            f" version info {self.interchange_version}, causing a critical failure"
+        )
+
+
 class WorkerLost(Exception):
     """Exception raised when a worker is lost
     """
@@ -5,8 +38,15 @@ class WorkerLost(Exception):
         self.worker_id = worker_id
         self.hostname = hostname
 
-    def __repr__(self):
+    def __str__(self):
         return "Task failure due to loss of worker {} on host {}".format(self.worker_id, self.hostname)
 
-    def __str__(self):
-        return self.__repr__()
+
+class CommandClientTimeoutError(Exception):
+    """Raised when the command client times out waiting for a response.
+    """
+
+
+class CommandClientBadError(Exception):
+    """Raised when the command client is bad from an earlier timeout.
+    """