lsst-pipe-base 29.2025.2900__py3-none-any.whl → 29.2025.3100__py3-none-any.whl

lsst/pipe/base/quantum_graph_builder.py

@@ -103,13 +103,13 @@ class InitInputMissingError(QuantumGraphBuilderError):
 
 
 class QuantumGraphBuilder(ABC):
-    """An abstract base class for building `QuantumGraph` objects from a
+    """An abstract base class for building `.QuantumGraph` objects from a
     pipeline.
 
     Parameters
     ----------
     pipeline_graph : `.pipeline_graph.PipelineGraph`
-        Pipeline to build a `QuantumGraph` from, as a graph.  Will be resolved
+        Pipeline to build a `.QuantumGraph` from, as a graph.  Will be resolved
         in-place with the given butler (any existing resolution is ignored).
     butler : `lsst.daf.butler.Butler`
         Client for the data repository.  Should be read-only.
@@ -139,7 +139,7 @@ class QuantumGraphBuilder(ABC):
     The `build` method splits the pipeline graph into independent subgraphs,
     then calls the abstract method `process_subgraph` on each, to allow
     concrete implementations to populate the rough graph structure (the
-    `~quantum_graph_skeleton.QuantumGraphSkeleton` class), including searching
+    `~.quantum_graph_skeleton.QuantumGraphSkeleton` class), including searching
     for existing datasets.  The `build` method then:
 
     - assembles `lsst.daf.butler.Quantum` instances from all data IDs in the
@@ -321,7 +321,7 @@ class QuantumGraphBuilder(ABC):
 
         Returns
         -------
-        quantum_graph : `QuantumGraph`
+        quantum_graph : `.QuantumGraph`
             DAG describing processing to be performed.
 
         Notes
@@ -373,7 +373,7 @@ class QuantumGraphBuilder(ABC):
     @abstractmethod
     def process_subgraph(self, subgraph: PipelineGraph) -> QuantumGraphSkeleton:
         """Build the rough structure for an independent subset of the
-        `QuantumGraph` and query for relevant existing datasets.
+        `.QuantumGraph` and query for relevant existing datasets.
 
         Parameters
         ----------
@@ -384,39 +384,38 @@ class QuantumGraphBuilder(ABC):
 
         Returns
         -------
-        skeleton : `quantum_graph_skeleton.QuantumGraphSkeleton`
+        skeleton : `.quantum_graph_skeleton.QuantumGraphSkeleton`
             Class representing an initial quantum graph. See
-            `quantum_graph_skeleton.QuantumGraphSkeleton` docs for details.
+            `.quantum_graph_skeleton.QuantumGraphSkeleton` docs for details.
             After this is returned, the object may be modified in-place in
             unspecified ways.
 
         Notes
         -----
-        The `quantum_graph_skeleton.QuantumGraphSkeleton` should associate
-        `DatasetRef` objects with nodes for existing datasets.  In
-        particular:
+        The `.quantum_graph_skeleton.QuantumGraphSkeleton` should associate
+        `lsst.daf.butler.DatasetRef` objects with nodes for existing datasets.
+        In particular:
 
-        - `quantum_graph_skeleton.QuantumGraphSkeleton.set_dataset_ref` must be
-          used to associate existing datasets with all overall-input dataset
+        - `.quantum_graph_skeleton.QuantumGraphSkeleton.set_dataset_ref` must
+          be used to associate existing datasets with all overall-input dataset
           nodes in the skeleton by querying `input_collections`.  This includes
           all standard input nodes and any prerequisite nodes added by the
           method (prerequisite nodes may also be left out entirely, as the base
           class can add them later, albeit possibly less efficiently).
-        - `quantum_graph_skeleton.QuantumGraphSkeleton.set_output_for_skip`
+        - `.quantum_graph_skeleton.QuantumGraphSkeleton.set_output_for_skip`
           must be used to associate existing datasets with output dataset nodes
           by querying `skip_existing_in`.
-        - `quantum_graph_skeleton.QuantumGraphSkeleton.add_output_in_the_way`
+        - `.quantum_graph_skeleton.QuantumGraphSkeleton.add_output_in_the_way`
           must be used to associated existing outputs with output dataset nodes
-          by querying `output_run` if `output_run_exists` is `True`.
-          Note that the presence of such datasets is not automatically an
-          error, even if `clobber` is `False`, as these may be quanta that will
-          be skipped.
+          by querying `output_run` if `output_run_exists` is `True`. Note that
+          the presence of such datasets is not automatically an error, even if
+          `clobber` is `False`, as these may be quanta that will be skipped.
 
-        `DatasetRef` objects for existing datasets with empty data IDs in all
-        of the above categories may be found in the `empty_dimensions_datasets`
-        attribute, as these are queried for prior to this call by the base
-        class, but associating them with graph nodes is still this method's
-        responsibility.
+        `lsst.daf.butler.DatasetRef` objects for existing datasets with empty
+        data IDs in all of the above categories may be found in the
+        `empty_dimensions_datasets` attribute, as these are queried for prior
+        to this call by the base class, but associating them with graph nodes
+        is still this method's responsibility.
 
         Dataset types should never be components and should always use the
         "common" storage class definition in `pipeline_graph.DatasetTypeNode`
@@ -435,16 +434,17 @@ class QuantumGraphBuilder(ABC):
         ----------
         task_node : `pipeline_graph.TaskNode`
             Node for this task in the pipeline graph.
-        skeleton : `quantum_graph_skeleton.QuantumGraphSkeleton`
+        skeleton : `.quantum_graph_skeleton.QuantumGraphSkeleton`
             Preliminary quantum graph, to be modified in-place.
 
         Notes
         -----
         This method modifies ``skeleton`` in-place in several ways:
 
-        - It associates a `DatasetRef` with all output datasets and drops input
-          dataset nodes that do not have a `DatasetRef` already.  This ensures
-          producing and consuming tasks start from the same `DatasetRef`.
+        - It associates a `lsst.daf.butler.DatasetRef` with all output datasets
+          and drops input dataset nodes that do not have a
+          `lsst.daf.butler.DatasetRef` already.  This ensures producing and
+          consuming tasks start from the same `lsst.daf.butler.DatasetRef`.
         - It adds "inputs", "outputs", and "init_inputs" attributes to the
           quantum nodes, holding the same `NamedValueMapping` objects needed to
           construct an actual `Quantum` instances.
@@ -596,7 +596,7 @@ class QuantumGraphBuilder(ABC):
             Node for this task in the pipeline graph.
         quantum_key : `QuantumKey`
             Identifier for this quantum in the graph.
-        skeleton : `quantum_graph_skeleton.QuantumGraphSkeleton`
+        skeleton : `.quantum_graph_skeleton.QuantumGraphSkeleton`
             Preliminary quantum graph, to be modified in-place.
 
         Returns
@@ -611,9 +611,10 @@ class QuantumGraphBuilder(ABC):
         `skip_existing_in` collections, the quantum will be skipped. This
         causes the quantum node to be removed from the graph.  Dataset nodes
         that were previously the outputs of this quantum will be associated
-        with `DatasetRef` objects that were found in ``skip_existing_in``, or
-        will be removed if there is no such dataset there.  Any output dataset
-        in `output_run` will be removed from the "output in the way" category.
+        with `lsst.daf.butler.DatasetRef` objects that were found in
+        ``skip_existing_in``, or will be removed if there is no such dataset
+        there.  Any output dataset in `output_run` will be removed from the
+        "output in the way" category.
         """
         metadata_dataset_key = DatasetKey(
             task_node.metadata_output.parent_dataset_type_name, quantum_key.data_id_values
@@ -659,7 +660,7 @@ class QuantumGraphBuilder(ABC):
         ----------
         quantum_key : `QuantumKey`
             Identifier for this quantum in the graph.
-        skeleton : `quantum_graph_skeleton.QuantumGraphSkeleton`
+        skeleton : `.quantum_graph_skeleton.QuantumGraphSkeleton`
             Preliminary quantum graph, to be modified in-place.
         task_prerequisite_info : `~prerequisite_helpers.PrerequisiteInfo`
             Information about the prerequisite inputs to this task.
@@ -679,7 +680,7 @@ class QuantumGraphBuilder(ABC):
         the original there).  If `clobber` is `False`, `RuntimeError` is
         raised.  If there is no output already present, a new one with a random
         UUID is generated.  In all cases the dataset node in the skeleton is
-        associated with a `DatasetRef`.
+        associated with a `lsst.daf.butler.DatasetRef`.
         """
         dataset_key: DatasetKey | PrerequisiteDatasetKey
         for dataset_key in skeleton.iter_outputs_of(quantum_key):
@@ -743,7 +744,7 @@ class QuantumGraphBuilder(ABC):
             Node for this task in the pipeline graph.
         quantum_key : `QuantumKey`
             Identifier for this quantum in the graph.
-        skeleton : `quantum_graph_skeleton.QuantumGraphSkeleton`
+        skeleton : `.quantum_graph_skeleton.QuantumGraphSkeleton`
             Preliminary quantum graph, to be modified in-place.
 
         Returns
@@ -787,7 +788,7 @@ class QuantumGraphBuilder(ABC):
             Node for this task in the pipeline graph.
         quantum_key : `QuantumKey`
             Identifier for this quantum in the graph.
-        skeleton : `quantum_graph_skeleton.QuantumGraphSkeleton`
+        skeleton : `.quantum_graph_skeleton.QuantumGraphSkeleton`
             Preliminary quantum graph, to be modified in-place.
         skypix_bounds_builder : `~prerequisite_helpers.SkyPixBoundsBuilder`
             An object that accumulates the appropriate spatial bounds for a
@@ -806,8 +807,8 @@ class QuantumGraphBuilder(ABC):
         Notes
         -----
         This method trims input dataset nodes that are not already associated
-        with a `DatasetRef`, and queries for prerequisite input nodes that do
-        not exist.
+        with a `lsst.daf.butler.DatasetRef`, and queries for prerequisite input
+        nodes that do not exist.
         """
         inputs_by_type: dict[str, set[DatasetRef]] = {}
         dataset_key: DatasetKey | PrerequisiteDatasetKey
@@ -987,7 +988,7 @@ class QuantumGraphBuilder(ABC):
 
         Parameters
         ----------
-        skeleton : `quantum_graph_skeleton.QuantumGraphSkeleton`
+        skeleton : `.quantum_graph_skeleton.QuantumGraphSkeleton`
             Preliminary quantum graph to update in place.
 
         Notes
@@ -1018,12 +1019,12 @@ class QuantumGraphBuilder(ABC):
     def _construct_quantum_graph(
         self, skeleton: QuantumGraphSkeleton, metadata: Mapping[str, Any]
     ) -> QuantumGraph:
-        """Construct a `QuantumGraph` object from the contents of a
-        fully-processed `quantum_graph_skeleton.QuantumGraphSkeleton`.
+        """Construct a `.QuantumGraph` object from the contents of a
+        fully-processed `.quantum_graph_skeleton.QuantumGraphSkeleton`.
 
         Parameters
         ----------
-        skeleton : `quantum_graph_skeleton.QuantumGraphSkeleton`
+        skeleton : `.quantum_graph_skeleton.QuantumGraphSkeleton`
             Preliminary quantum graph.  Must have "init_inputs", "inputs", and
             "outputs" attributes on all quantum nodes, as added by
             `_resolve_task_quanta`, as well as a "datastore_records" attribute
@@ -1033,7 +1034,7 @@ class QuantumGraphBuilder(ABC):
 
         Returns
         -------
-        quantum_graph : `QuantumGraph`
+        quantum_graph : `.QuantumGraph`
             DAG describing processing to be performed.
         """
         quanta: dict[TaskDef, set[Quantum]] = {}

lsst/pipe/base/quantum_graph_executor.py

@@ -0,0 +1,125 @@
+# This file is part of pipe_base.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (http://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This software is dual licensed under the GNU General Public License and also
+# under a 3-clause BSD license. Recipients may choose which of these licenses
+# to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
+# respectively.  If you choose the GPL option then the following text applies
+# (but note that there is still no warranty even if you opt for BSD instead):
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import annotations
+
+__all__ = ["QuantumExecutor", "QuantumGraphExecutor"]
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+from .quantum_reports import QuantumReport, Report
+
+if TYPE_CHECKING:
+    import uuid
+
+    from lsst.daf.butler import Quantum
+
+    from .graph import QuantumGraph
+    from .pipeline_graph import TaskNode
+
+
+class QuantumExecutor(ABC):
+    """Class which abstracts execution of a single Quantum.
+
+    In general implementation should not depend on execution model and
+    execution should always happen in-process. Main reason for existence
+    of this class is to provide do-nothing implementation that can be used
+    in the unit tests.
+    """
+
+    @abstractmethod
+    def execute(
+        self, task_node: TaskNode, /, quantum: Quantum, quantum_id: uuid.UUID | None = None
+    ) -> tuple[Quantum, QuantumReport | None]:
+        """Execute single quantum.
+
+        Parameters
+        ----------
+        task_node : `~.pipeline_graph.TaskNode`
+            Task definition structure.
+        quantum : `~lsst.daf.butler.Quantum`
+            Quantum for this execution.
+        quantum_id : `uuid.UUID` or `None`, optional
+            The ID of the quantum to be executed.
+
+        Returns
+        -------
+        quantum : `~lsst.daf.butler.Quantum`
+            The quantum actually executed.
+        report : `~.quantum_reports.QuantumReport`
+            Structure describing the status of the execution of a quantum.
+            `None` is returned if implementation does not support this
+            feature.
+
+        Notes
+        -----
+        Any exception raised by the task or code that wraps task execution is
+        propagated to the caller of this method.
+        """
+        raise NotImplementedError()
+
+
+class QuantumGraphExecutor(ABC):
+    """Class which abstracts QuantumGraph execution.
+
+    Any specific execution model is implemented in sub-class by overriding
+    the `execute` method.
+    """
+
+    @abstractmethod
+    def execute(self, graph: QuantumGraph) -> None:
+        """Execute whole graph.
+
+        Implementation of this method depends on particular execution model
+        and it has to be provided by a subclass. Execution model determines
+        what happens here; it can be either actual running of the task or,
+        for example, generation of the scripts for delayed batch execution.
+
+        Parameters
+        ----------
+        graph : `.QuantumGraph`
+            Execution graph.
+        """
+        raise NotImplementedError()
+
+    def getReport(self) -> Report | None:
+        """Return execution report from last call to `execute`.
+
+        Returns
+        -------
+        report : `~.quantum_reports.Report`, optional
+            Structure describing the status of the execution of a quantum
+            graph. `None` is returned if implementation does not support
+            this feature.
+
+        Raises
+        ------
+        RuntimeError
+            Raised if this method is called before `execute`.
+        """
+        return None

lsst/pipe/base/quantum_reports.py

@@ -0,0 +1,334 @@
+# This file is part of pipe_base.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (http://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This software is dual licensed under the GNU General Public License and also
+# under a 3-clause BSD license. Recipients may choose which of these licenses
+# to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
+# respectively.  If you choose the GPL option then the following text applies
+# (but note that there is still no warranty even if you opt for BSD instead):
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import annotations
+
+__all__ = ["ExceptionInfo", "ExecutionStatus", "QuantumReport", "Report"]
+
+import enum
+import sys
+from typing import Any
+
+import pydantic
+
+from lsst.daf.butler import DataCoordinate, DataId, DataIdValue
+from lsst.utils.introspection import get_full_type_name
+
+from .graph import QgraphSummary
+
+
+def _serializeDataId(dataId: DataId) -> dict[str, DataIdValue]:
+    if isinstance(dataId, DataCoordinate):
+        return dict(dataId.required)
+    else:
+        return dataId  # type: ignore
+
+
+class ExecutionStatus(enum.Enum):
+    """Possible values for job execution status.
+
+    Status `FAILURE` is set if one or more tasks failed. Status `TIMEOUT` is
+    set if there are no failures but one or more tasks timed out. Timeouts can
+    only be detected in multi-process mode, child task is killed on timeout
+    and usually should have non-zero exit code.
+    """
+
+    SUCCESS = "success"
+    FAILURE = "failure"
+    TIMEOUT = "timeout"
+    SKIPPED = "skipped"
+
+
+class ExceptionInfo(pydantic.BaseModel):
+    """Information about exception."""
+
+    className: str
+    """Name of the exception class if exception was raised."""
+
+    message: str
+    """Exception message for in-process quantum execution, None if
+    quantum was executed in sub-process.
+    """
+
+    @classmethod
+    def from_exception(cls, exception: Exception) -> ExceptionInfo:
+        """Construct instance from an exception.
+
+        Parameters
+        ----------
+        exception : `Exception`
+            Exception to wrap.
+
+        Returns
+        -------
+        info : `ExceptionInfo`
+            Information about the exception.
+        """
+        return cls(className=get_full_type_name(exception), message=str(exception))
+
+    # Work around the fact that Sphinx chokes on Pydantic docstring formatting,
+    # when we inherit those docstrings in our public classes.
+    if "sphinx" in sys.modules:
+
+        def copy(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.copy`."""
+            return super().copy(*args, **kwargs)
+
+        def model_dump(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_dump`."""
+            return super().model_dump(*args, **kwargs)
+
+        def model_dump_json(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_dump_json`."""
+            return super().model_dump(*args, **kwargs)
+
+        def model_copy(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_copy`."""
+            return super().model_copy(*args, **kwargs)
+
+        @classmethod
+        def model_construct(cls, *args: Any, **kwargs: Any) -> Any:  # type: ignore[misc, override]
+            """See `pydantic.BaseModel.model_construct`."""
+            return super().model_construct(*args, **kwargs)
+
+        @classmethod
+        def model_json_schema(cls, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_json_schema`."""
+            return super().model_json_schema(*args, **kwargs)
+
+
+class QuantumReport(pydantic.BaseModel):
+    """Task execution report for a single Quantum.
+
+    Parameters
+    ----------
+    dataId : `~lsst.daf.butler.DataId`
+        Quantum data ID.
+    taskLabel : `str`
+        Label for task executing this Quantum.
+    status : `ExecutionStatus`
+        Status of this quantum execution.
+    exitCode : `int` or `None`, optional
+        Exit code for sub-process executing this Quantum. `None` for
+        in-process execution. Negative if process was killed by a signal.
+    exceptionInfo : `ExceptionInfo` or `None`, optional
+        Exception information if an exception was raised.
+    """
+
+    status: ExecutionStatus = ExecutionStatus.SUCCESS
+    """Execution status, one of the values in `ExecutionStatus` enum."""
+
+    dataId: dict[str, DataIdValue]
+    """Quantum DataId."""
+
+    taskLabel: str | None
+    """Label for a task executing this Quantum."""
+
+    exitCode: int | None = None
+    """Exit code for a sub-process executing Quantum, None for in-process
+    Quantum execution. Negative if process was killed by a signal.
+    """
+
+    exceptionInfo: ExceptionInfo | None = None
+    """Exception information if exception was raised."""
+
+    def __init__(
+        self,
+        dataId: DataId,
+        taskLabel: str,
+        status: ExecutionStatus = ExecutionStatus.SUCCESS,
+        exitCode: int | None = None,
+        exceptionInfo: ExceptionInfo | None = None,
+    ):
+        super().__init__(
+            status=status,
+            dataId=_serializeDataId(dataId),
+            taskLabel=taskLabel,
+            exitCode=exitCode,
+            exceptionInfo=exceptionInfo,
+        )
+
+    @classmethod
+    def from_exception(
+        cls,
+        exception: Exception,
+        dataId: DataId,
+        taskLabel: str,
+        *,
+        exitCode: int | None = None,
+    ) -> QuantumReport:
+        """Construct report instance from an exception and other pieces of
+        data.
+
+        Parameters
+        ----------
+        exception : `Exception`
+            Exception caught from processing quantum.
+        dataId : `~lsst.daf.butler.DataId`
+            Data ID of quantum.
+        taskLabel : `str`
+            Label of task.
+        exitCode : `int`, optional
+            Exit code for the process, used when it is known that the process
+            will exit with that exit code.
+        """
+        return cls(
+            status=ExecutionStatus.FAILURE,
+            dataId=dataId,
+            taskLabel=taskLabel,
+            exitCode=exitCode,
+            exceptionInfo=ExceptionInfo.from_exception(exception),
+        )
+
+    @classmethod
+    def from_exit_code(
+        cls,
+        exitCode: int,
+        dataId: DataId,
+        taskLabel: str,
+    ) -> QuantumReport:
+        """Construct report instance from an exit code and other pieces of
+        data.
+
+        Parameters
+        ----------
+        exitCode : `int`
+            The exit code of the subprocess.
+        dataId : `~lsst.daf.butler.DataId`
+            The quantum Data ID.
+        taskLabel : `str`
+            The task label.
+        """
+        return cls(
+            status=ExecutionStatus.SUCCESS if exitCode == 0 else ExecutionStatus.FAILURE,
+            dataId=dataId,
+            taskLabel=taskLabel,
+            exitCode=exitCode,
+        )
+
+    # Work around the fact that Sphinx chokes on Pydantic docstring formatting,
+    # when we inherit those docstrings in our public classes.
+    if "sphinx" in sys.modules:
+
+        def copy(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.copy`."""
+            return super().copy(*args, **kwargs)
+
+        def model_dump(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_dump`."""
+            return super().model_dump(*args, **kwargs)
+
+        def model_dump_json(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_dump_json`."""
+            return super().model_dump(*args, **kwargs)
+
+        def model_copy(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_copy`."""
+            return super().model_copy(*args, **kwargs)
+
+        @classmethod
+        def model_construct(cls, *args: Any, **kwargs: Any) -> Any:  # type: ignore[misc, override]
+            """See `pydantic.BaseModel.model_construct`."""
+            return super().model_construct(*args, **kwargs)
+
+        @classmethod
+        def model_json_schema(cls, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_json_schema`."""
+            return super().model_json_schema(*args, **kwargs)
+
+
+class Report(pydantic.BaseModel):
+    """Execution report for the whole job with one or few quanta."""
+
+    qgraphSummary: QgraphSummary
+    """Summary report about QuantumGraph."""
+
+    status: ExecutionStatus = ExecutionStatus.SUCCESS
+    """Job status."""
+
+    cmdLine: list[str] | None = None
+    """Command line for the whole job."""
+
+    exitCode: int | None = None
+    """Job exit code, this obviously cannot be set in pipetask."""
+
+    exceptionInfo: ExceptionInfo | None = None
+    """Exception information if exception was raised."""
+
+    quantaReports: list[QuantumReport] = []
+    """List of per-quantum reports, ordering is not specified. Some or all
+    quanta may not produce a report.
+    """
+
+    # Always want to validate the default value for cmdLine so
+    # use a model_validator.
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_cmdLine(cls, data: Any) -> Any:
+        if data.get("cmdLine") is None:
+            data["cmdLine"] = sys.argv
+        return data
+
+    def set_exception(self, exception: Exception) -> None:
+        """Update exception information from an exception object.
+
+        Parameters
+        ----------
+        exception : `Exception`
+            Exception to use to extract information from.
+        """
+        self.exceptionInfo = ExceptionInfo.from_exception(exception)
+
+    # Work around the fact that Sphinx chokes on Pydantic docstring formatting,
+    # when we inherit those docstrings in our public classes.
+    if "sphinx" in sys.modules:
+
+        def copy(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.copy`."""
+            return super().copy(*args, **kwargs)
+
+        def model_dump(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_dump`."""
+            return super().model_dump(*args, **kwargs)
+
+        def model_dump_json(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_dump_json`."""
+            return super().model_dump(*args, **kwargs)
+
+        def model_copy(self, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_copy`."""
+            return super().model_copy(*args, **kwargs)
+
+        @classmethod
+        def model_construct(cls, *args: Any, **kwargs: Any) -> Any:  # type: ignore[misc, override]
+            """See `pydantic.BaseModel.model_construct`."""
+            return super().model_construct(*args, **kwargs)
+
+        @classmethod
+        def model_json_schema(cls, *args: Any, **kwargs: Any) -> Any:
+            """See `pydantic.BaseModel.model_json_schema`."""
+            return super().model_json_schema(*args, **kwargs)