lsst-pipe-base 29.2025.1700__tar.gz → 29.2025.1900__tar.gz

{lsst_pipe_base-29.2025.1700/python/lsst_pipe_base.egg-info → lsst_pipe_base-29.2025.1900}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-pipe-base
-Version: 29.2025.1700
+Version: 29.2025.1900
 Summary: Pipeline infrastructure for the Rubin Science Pipelines.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License

{lsst_pipe_base-29.2025.1700 → lsst_pipe_base-29.2025.1900}/python/lsst/pipe/base/_status.py

@@ -30,7 +30,7 @@ from __future__ import annotations
 import abc
 import enum
 import logging
-from typing import TYPE_CHECKING, ClassVar, Protocol
+from typing import TYPE_CHECKING, Any, ClassVar, Protocol
 
 from lsst.utils import introspection
 
@@ -245,6 +245,16 @@ class AlgorithmError(RepeatableQuantumError, abc.ABC):
     (for example: number of data points in a fit vs. degrees of freedom).
     """
 
+    def __new__(cls, *args: Any, **kwargs: Any) -> AlgorithmError:
+        # Have to override __new__ because builtin subclasses aren't checked
+        # for abstract methods; see https://github.com/python/cpython/issues/50246
+        if cls.__abstractmethods__:
+            raise TypeError(
+                f"Can't instantiate abstract class {cls.__name__} with "
+                f"abstract methods: {','.join(sorted(cls.__abstractmethods__))}"
+            )
+        return super().__new__(cls, *args, **kwargs)
+
     @property
     @abc.abstractmethod
     def metadata(self) -> NestedMetadataDict | None:

{lsst_pipe_base-29.2025.1700 → lsst_pipe_base-29.2025.1900}/python/lsst/pipe/base/all_dimensions_quantum_graph_builder.py

@@ -34,20 +34,18 @@ from __future__ import annotations
 __all__ = ("AllDimensionsQuantumGraphBuilder", "DatasetQueryConstraintVariant")
 
 import dataclasses
-import itertools
 from collections import defaultdict
 from collections.abc import Iterable, Mapping
-from typing import TYPE_CHECKING, Any, TypeAlias, final
+from typing import TYPE_CHECKING, Any, final
 
 import astropy.table
 
 from lsst.daf.butler import (
     Butler,
     DataCoordinate,
-    DataIdValue,
+    DimensionDataAttacher,
     DimensionGroup,
-    DimensionRecord,
-    DimensionUniverse,
+    DimensionRecordSet,
     MissingDatasetTypeError,
 )
 from lsst.utils.logging import LsstLogAdapter
@@ -61,9 +59,6 @@ if TYPE_CHECKING:
     from .pipeline_graph import DatasetTypeNode, PipelineGraph, TaskNode
 
 
-DimensionRecordsMap: TypeAlias = dict[str, dict[tuple[DataIdValue, ...], DimensionRecord]]
-
-
 @final
 class AllDimensionsQuantumGraphBuilder(QuantumGraphBuilder):
     """An implementation of `QuantumGraphBuilder` that uses a single large
@@ -145,9 +140,7 @@ class AllDimensionsQuantumGraphBuilder(QuantumGraphBuilder):
             return skeleton
         self._find_followup_datasets(tree, skeleton)
         dimension_records = self._fetch_most_dimension_records(tree)
-        leftovers = self._attach_most_dimension_records(skeleton, dimension_records)
-        self._fetch_leftover_dimension_records(leftovers, dimension_records)
-        self._attach_leftover_dimension_records(skeleton, leftovers, dimension_records)
+        self._attach_dimension_records(skeleton, dimension_records)
         return skeleton
 
     def _query_for_data_ids(self, tree: _DimensionGroupTree) -> None:
@@ -197,7 +190,14 @@ class AllDimensionsQuantumGraphBuilder(QuantumGraphBuilder):
                 query_cmd.append(f"    collections = {list(self.input_collections)}")
             for dataset_type_name in constraint_datasets:
                 query_cmd.append(f"    query = query.join_dataset_search({dataset_type_name!r}, collections)")
-                query = query.join_dataset_search(dataset_type_name, self.input_collections)
+                try:
+                    query = query.join_dataset_search(dataset_type_name, self.input_collections)
+                except MissingDatasetTypeError:
+                    raise QuantumGraphBuilderError(
+                        f"No datasets for overall-input {dataset_type_name!r} found (the dataset type is "
+                        "not even registered).  This is probably a bug in either the pipeline definition or "
+                        "the dataset constraints passed to the quantum graph builder."
+                    ) from None
             query_cmd.append(
                 f"    query = query.where({dict(tree.subgraph.data_id.mapping)}, "
                 f"{self.where!r}, bind={self.bind!r})"
@@ -453,7 +453,7 @@ class AllDimensionsQuantumGraphBuilder(QuantumGraphBuilder):
                     del branch.data_ids
 
     @timeMethod
-    def _fetch_most_dimension_records(self, tree: _DimensionGroupTree) -> DimensionRecordsMap:
+    def _fetch_most_dimension_records(self, tree: _DimensionGroupTree) -> list[DimensionRecordSet]:
         """Query for dimension records for all non-prerequisite data IDs (and
         possibly some prerequisite data IDs).
 
@@ -464,10 +464,8 @@ class AllDimensionsQuantumGraphBuilder(QuantumGraphBuilder):
 
         Returns
         -------
-        dimension_records : `dict`
-            Nested dictionary of dimension records, keyed first by dimension
-            element name and then by the `DataCoordinate.required_values`
-            tuple.
+        dimension_records : `list` [ `lsst.daf.butler.DimensionRecordSet` ]
+            List of sets of dimension records.
 
         Notes
         -----
@@ -476,7 +474,7 @@ class AllDimensionsQuantumGraphBuilder(QuantumGraphBuilder):
         can also be used to fetch dimension records for those data IDs.
         """
         self.log.verbose("Performing follow-up queries for dimension records.")
-        result: dict[str, dict[tuple[DataIdValue, ...], DimensionRecord]] = {}
+        result: list[DimensionRecordSet] = []
         for branch in tree.branches_by_dimensions.values():
             if not branch.record_elements:
                 continue
@@ -485,16 +483,17 @@ class AllDimensionsQuantumGraphBuilder(QuantumGraphBuilder):
             with self.butler.query() as butler_query:
                 butler_query = butler_query.join_data_coordinates(branch.data_ids)
                 for element in branch.record_elements:
-                    result[element] = {
-                        record.dataId.required_values: record
-                        for record in butler_query.dimension_records(element)
-                    }
+                    result.append(
+                        DimensionRecordSet(
+                            element, butler_query.dimension_records(element), universe=self.universe
+                        )
+                    )
         return result
 
     @timeMethod
-    def _attach_most_dimension_records(
-        self, skeleton: QuantumGraphSkeleton, dimension_records: DimensionRecordsMap
-    ) -> DataIdExpansionLeftovers:
+    def _attach_dimension_records(
+        self, skeleton: QuantumGraphSkeleton, dimension_records: Iterable[DimensionRecordSet]
+    ) -> None:
         """Attach dimension records to most data IDs in the in-progress graph,
         and return a data structure that records the rest.
 
@@ -502,108 +501,31 @@ class AllDimensionsQuantumGraphBuilder(QuantumGraphBuilder):
         ----------
         skeleton : `.quantum_graph_skeleton.QuantumGraphSkeleton`
             In-progress quantum graph to modify in place.
-        dimension_records : `dict`
-            Nested dictionary of dimension records, keyed first by dimension
-            element name and then by the `DataCoordinate.required_values`
-            tuple.
-
-        Returns
-        -------
-        leftovers : `DataIdExpansionLeftovers`
-            Struct recording data IDs in ``skeleton`` that were not expanded
-            and the data IDs of the dimension records that need to be fetched
-            in order to do so.
+        dimension_records : `~collections.abc.Iterable` [ \
+                `lsst.daf.butler.DimensionRecordSet` ]
+            Iterable of sets of dimension records.
         """
         # Group all nodes by data ID (and dimensions of data ID).
-        data_ids_to_expand: defaultdict[DimensionGroup, defaultdict[DataCoordinate, NodeKeysForDataId]] = (
-            defaultdict(NodeKeysForDataId.make_defaultdict)
+        data_ids_to_expand: defaultdict[DimensionGroup, defaultdict[DataCoordinate, list[Key]]] = defaultdict(
+            lambda: defaultdict(list)
         )
         data_id: DataCoordinate | None
         for node_key in skeleton:
             if data_id := skeleton[node_key].get("data_id"):
-                if isinstance(node_key, PrerequisiteDatasetKey):
-                    data_ids_to_expand[data_id.dimensions][data_id].prerequisites.append(node_key)
-                else:
-                    data_ids_to_expand[data_id.dimensions][data_id].others.append(node_key)
-        # Expand data IDs and track the records that are missing (which can
-        # only come from prerequisite data IDs).
-        leftovers = DataIdExpansionLeftovers()
+                data_ids_to_expand[data_id.dimensions][data_id].append(node_key)
+        attacher = DimensionDataAttacher(
+            records=dimension_records,
+            dimensions=DimensionGroup.union(*data_ids_to_expand.keys(), universe=self.universe),
+        )
         for dimensions, data_ids in data_ids_to_expand.items():
-            attacher = DimensionRecordAttacher(dimensions, dimension_records)
-            skipped_data_ids: dict[DataCoordinate, list[PrerequisiteDatasetKey]] = {}
-            for data_id, node_keys in data_ids.items():
-                expanded_data_id: DataCoordinate | None
-                if node_keys.others:
-                    # This data ID was used in at least one non-prerequisite
-                    # key, so we know we've got the records we need for it
-                    # already.
-                    expanded_data_id = attacher.apply(data_id)
-                else:
-                    # This key only appeared in prerequisites, so we might not
-                    # have all the records we need.
-                    if (expanded_data_id := attacher.maybe_apply(data_id, leftovers)) is None:
-                        skipped_data_ids[data_id] = node_keys.prerequisites
-                        continue
-                for node_key in itertools.chain(node_keys.others, node_keys.prerequisites):
-                    skeleton.set_data_id(node_key, expanded_data_id)
-            if skipped_data_ids:
-                leftovers.data_ids_to_expand[dimensions] = skipped_data_ids
-        return leftovers
-
-    @timeMethod
-    def _fetch_leftover_dimension_records(
-        self, leftovers: DataIdExpansionLeftovers, dimension_records: DimensionRecordsMap
-    ) -> None:
-        """Fetch additional dimension records whose data IDs were not included
-        in the initial common data ID query.
-
-        Parameters
-        ----------
-        leftovers : `DataIdExpansionLeftovers`
-            Struct recording data IDs in ``skeleton`` that were not expanded.
-        dimension_records : `dict`
-            Nested dictionary of dimension records, keyed first by dimension
-            element name and then by the `DataCoordinate.required_values`
-            tuple. Will be updated in place.
-        """
-        for element, data_id_values_set in leftovers.missing_record_data_ids.items():
-            dimensions = self.butler.dimensions[element].minimal_group
-            data_ids = [DataCoordinate.from_required_values(dimensions, v) for v in data_id_values_set]
-            with self.butler.query() as q:
-                new_records = {
-                    r.dataId.required_values: r
-                    for r in q.join_data_coordinates(data_ids).dimension_records(element)
-                }
-            dimension_records.setdefault(element, {}).update(new_records)
-
-    @timeMethod
-    def _attach_leftover_dimension_records(
-        self,
-        skeleton: QuantumGraphSkeleton,
-        leftovers: DataIdExpansionLeftovers,
-        dimension_records: DimensionRecordsMap,
-    ) -> None:
-        """Attach dimension records to any data IDs in the in-progress graph
-        that were not handled in the first pass.
-
-        Parameters
-        ----------
-        skeleton : `.quantum_graph_skeleton.QuantumGraphSkeleton`
-            In-progress quantum graph to modify in place.
-        leftovers : `DataIdExpansionLeftovers`
-            Struct recording data IDs in ``skeleton`` that were not expanded
-            and the data IDs of the dimension records that need to be fetched
-            in order to do so.
-        dimension_records : `dict`
-            Nested dictionary of dimension records, keyed first by dimension
-            element name and then by the `DataCoordinate.required_values`
-            tuple.
-        """
-        for dimensions, data_ids in leftovers.data_ids_to_expand.items():
-            attacher = DimensionRecordAttacher(dimensions, dimension_records)
-            for data_id, prerequisite_keys in data_ids.items():
-                expanded_data_id = attacher.apply(data_id)
-                for node_key in prerequisite_keys:
+            with self.butler.query() as query:
+                # Butler query will be used as-needed to get dimension records
+                # (from prerequisites) we didn't fetch in advance.  These are
+                # cached in the attacher so we don't look them up multiple
+                # times.
+                expanded_data_ids = attacher.attach(dimensions, data_ids.keys(), query=query)
+            for expanded_data_id, node_keys in zip(expanded_data_ids, data_ids.values()):
+                for node_key in node_keys:
                     skeleton.set_data_id(node_key, expanded_data_id)
 
 
@@ -970,7 +892,7 @@ class _DimensionGroupTree:
             dimensions: _DimensionGroupBranch(tasks, dataset_types)
             for dimensions, (tasks, dataset_types) in self.subgraph.group_by_dimensions().items()
         }
-        self.all_dimensions = _union_dimensions(self.branches_by_dimensions.keys(), universe)
+        self.all_dimensions = DimensionGroup.union(*self.branches_by_dimensions.keys(), universe=universe)
         _DimensionGroupBranch.populate_record_elements(self.all_dimensions, self.branches_by_dimensions)
         _DimensionGroupBranch.populate_edges(self.subgraph, self.branches_by_dimensions)
         self.trunk_branches = _DimensionGroupBranch.populate_branches(
@@ -997,141 +919,3 @@ class _DimensionGroupTree:
         for branch_dimensions, branch in self.trunk_branches.items():
             log.debug("Projecting query data IDs to %s.", branch_dimensions)
             branch.project_data_ids(log)
-
-
-class DimensionRecordAttacher:
-    """A helper class that expands data IDs by attaching dimension records.
-
-    Parameters
-    ----------
-    dimensions : `DimensionGroup`
-        Dimensions of the data IDs this instance will operate on.
-    dimension_records : `dict`
-        Nested dictionary of dimension records, keyed first by dimension
-        element name and then by the `DataCoordinate.required_values`
-        tuple.
-    """
-
-    def __init__(self, dimensions: DimensionGroup, dimension_records: DimensionRecordsMap):
-        self.dimensions = dimensions
-        self.indexers = {element: self._make_indexer(element) for element in dimensions.elements}
-        self.dimension_records = dimension_records
-
-    def _make_indexer(self, element: str) -> list[int]:
-        """Return a list of indexes into data ID full-values that extract the
-        `~DataCoordinate.required_values` for the ``element``
-        `DimensionElement.minimal_group` from the `~DataCoordinate.full_values`
-        for `dimensions`.
-        """
-        return [
-            self.dimensions._data_coordinate_indices[d]
-            for d in self.dimensions.universe[element].minimal_group.required
-        ]
-
-    def apply(self, data_id: DataCoordinate) -> DataCoordinate:
-        """Attach dimension records to the given data ID.
-
-        Parameters
-        ----------
-        data_id : `DataCoordinate`
-            Input data ID.
-
-        Returns
-        -------
-        expanded_data_id : `DataCoordinate`
-            Output data ID.
-        """
-        v = data_id.full_values
-        records_for_data_id = {}
-        for element, indexer in self.indexers.items():
-            records_for_element = self.dimension_records[element]
-            records_for_data_id[element] = records_for_element[tuple([v[i] for i in indexer])]
-        return data_id.expanded(records_for_data_id)
-
-    def maybe_apply(
-        self, data_id: DataCoordinate, leftovers: DataIdExpansionLeftovers
-    ) -> DataCoordinate | None:
-        """Attempt to attach dimension records to the given data ID, and record
-        the data IDs of missing dimension records on failure.
-
-        Parameters
-        ----------
-        data_id : `DataCoordinate`
-            Input data ID.
-        leftovers : `DataIdExpansionLeftovers`
-            Struct recording data IDs that were not expanded and the data IDs
-            of the dimension records that need to be fetched in order to do so.
-            The latter will be updated in place; callers are responsible for
-            updating the former when `None` is returned (since this method
-            doesn't have enough information to do so on its own).
-
-        Returns
-        -------
-        expanded_data_id : `DataCoordinate` or `None`
-            Output data ID, or `None` if one or more records were missing.
-        """
-        v = data_id.full_values
-        records_for_data_id = {}
-        failed = False
-        # Note that we need to process all elements even when we know we're
-        # going to fail, since we need to fully populate `leftovers` with what
-        # we still need to query for.
-        for element, indexer in self.indexers.items():
-            k = tuple([v[i] for i in indexer])
-            if (records_for_element := self.dimension_records.get(element)) is None:
-                leftovers.missing_record_data_ids[element].add(k)
-                failed = True
-            elif (r := records_for_element.get(k)) is None:
-                leftovers.missing_record_data_ids[element].add(k)
-                failed = True
-            else:
-                records_for_data_id[element] = r
-        if not failed:
-            return data_id.expanded(records_for_data_id)
-        else:
-            return None
-
-
-@dataclasses.dataclass
-class NodeKeysForDataId:
-    """Struct that holds the skeleton-graph node keys for a single data ID.
-
-    This is used when expanding (i.e. attaching dimension records to) data IDs,
-    where we group node keys by data ID in order to avoid repeatedly expanding
-    the same data ID and cut down on the number of equivalent data ID instances
-    alive in memory.  We separate prerequisite nodes from all other nodes
-    because they're the only ones whose data IDs are not by construction a
-    subset of the data IDs in the big initial query.
-    """
-
-    prerequisites: list[PrerequisiteDatasetKey] = dataclasses.field(default_factory=list)
-    """Node keys that correspond to prerequisite input dataset types."""
-
-    others: list[Key] = dataclasses.field(default_factory=list)
-    """All other node keys."""
-
-    @classmethod
-    def make_defaultdict(cls) -> defaultdict[DataCoordinate, NodeKeysForDataId]:
-        return defaultdict(cls)
-
-
-DataIdExpansionToDoMap: TypeAlias = defaultdict[
-    DimensionGroup, defaultdict[DataCoordinate, NodeKeysForDataId]
-]
-
-
-@dataclasses.dataclass
-class DataIdExpansionLeftovers:
-    data_ids_to_expand: dict[DimensionGroup, dict[DataCoordinate, list[PrerequisiteDatasetKey]]] = (
-        dataclasses.field(default_factory=dict)
-    )
-    missing_record_data_ids: defaultdict[str, set[tuple[DataIdValue, ...]]] = dataclasses.field(
-        default_factory=lambda: defaultdict(set)
-    )
-
-
-def _union_dimensions(groups: Iterable[DimensionGroup], universe: DimensionUniverse) -> DimensionGroup:
-    dimension_names: set[str] = set()
-    for dimensions_for_group in groups:
-        dimension_names.update(dimensions_for_group.names)
-    return universe.conform(dimension_names)

{lsst_pipe_base-29.2025.1700 → lsst_pipe_base-29.2025.1900}/python/lsst/pipe/base/caching_limited_butler.py

@@ -34,6 +34,7 @@ from collections.abc import Iterable, Set
 from typing import Any
 
 from lsst.daf.butler import (
+    ButlerMetrics,
     DatasetId,
     DatasetProvenance,
     DatasetRef,
@@ -90,6 +91,17 @@ class CachingLimitedButler(LimitedButler):
         self._cache: dict[str, tuple[DatasetId, InMemoryDatasetHandle]] = {}
         self._no_copy_on_cache = no_copy_on_cache
 
+    @property
+    def _metrics(self) -> ButlerMetrics:
+        # Need to always forward from the wrapped metrics object.
+        return self._wrapped._metrics
+
+    @_metrics.setter
+    def _metrics(self, metrics: ButlerMetrics) -> None:
+        # Allow record_metrics() context manager to override the wrapped
+        # butler.
+        self._wrapped._metrics = metrics
+
     def get(
         self,
         ref: DatasetRef,

{lsst_pipe_base-29.2025.1700 → lsst_pipe_base-29.2025.1900}/python/lsst/pipe/base/connections.py

@@ -52,7 +52,15 @@ from dataclasses import dataclass
 from types import MappingProxyType, SimpleNamespace
 from typing import TYPE_CHECKING, Any
 
-from lsst.daf.butler import DataCoordinate, DatasetRef, DatasetType, NamedKeyDict, NamedKeyMapping, Quantum
+from lsst.daf.butler import (
+    Butler,
+    DataCoordinate,
+    DatasetRef,
+    DatasetType,
+    NamedKeyDict,
+    NamedKeyMapping,
+    Quantum,
+)
 
 from ._status import NoWorkFound
 from .connectionTypes import BaseConnection, BaseInput, Output, PrerequisiteInput
@@ -1165,13 +1173,19 @@ class QuantaAdjuster:
         Pipeline graph the quantum graph is being built from.
     skeleton : `quantum_graph_skeleton.QuantumGraphSkeleton`
         Under-construction quantum graph that will be modified in place.
+    butler : `lsst.daf.butler.Butler`
+        Read-only instance with its default collection search path set to the
+        input collections passed to the quantum-graph builder.
     """
 
-    def __init__(self, task_label: str, pipeline_graph: PipelineGraph, skeleton: QuantumGraphSkeleton):
+    def __init__(
+        self, task_label: str, pipeline_graph: PipelineGraph, skeleton: QuantumGraphSkeleton, butler: Butler
+    ):
         self._task_node = pipeline_graph.tasks[task_label]
         self._pipeline_graph = pipeline_graph
         self._skeleton = skeleton
         self._n_removed = 0
+        self._butler = butler
 
     @property
     def task_label(self) -> str:
@@ -1183,8 +1197,15 @@ class QuantaAdjuster:
         """The node for this task in the pipeline graph."""
         return self._task_node
 
+    @property
+    def butler(self) -> Butler:
+        """Read-only instance with its default collection search path set to
+        the input collections passed to the quantum-graph builder.
+        """
+        return self._butler
+
     def iter_data_ids(self) -> Iterator[DataCoordinate]:
-        """Iterate over the data IDs of all quanta for this task."
+        """Iterate over the data IDs of all quanta for this task.
 
         Returns
         -------
@@ -1218,7 +1239,7 @@ class QuantaAdjuster:
 
         Parameters
         ----------
-        data_id : `~lsst.daf.butler.DataCoordinate`
+        quantum_data_id : `~lsst.daf.butler.DataCoordinate`
             Data ID of the quantum to get the inputs of.
 
         Returns
@@ -1250,6 +1271,41 @@ class QuantaAdjuster:
             for edge in self._task_node.iter_all_inputs()
         }
 
+    def get_outputs(self, quantum_data_id: DataCoordinate) -> dict[str, list[DataCoordinate]]:
+        """Return the data IDs of all regular outputs to a quantum.
+
+        Parameters
+        ----------
+        quantum_data_id : `~lsst.daf.butler.DataCoordinate`
+            Data ID of the quantum to get the outputs of.
+
+        Returns
+        -------
+        inputs : `dict` [ `str`, `list` [ `~lsst.daf.butler.DataCoordinate` ] ]
+            Data IDs of inputs, keyed by the connection name (the internal task
+            name, not the dataset type name).  This only contains regular
+            outputs, not init-outputs or log or metadata outputs.
+
+        Notes
+        -----
+        If two connections have the same dataset type, the current
+        implementation assumes the set of datasets is the same for the two
+        connections.  This limitation may be removed in the future.
+        """
+        from .quantum_graph_skeleton import QuantumKey
+
+        by_dataset_type_name: defaultdict[str, list[DataCoordinate]] = defaultdict(list)
+        quantum_key = QuantumKey(self._task_node.label, quantum_data_id.required_values)
+        for dataset_key in self._skeleton.iter_outputs_of(quantum_key):
+            dataset_type_node = self._pipeline_graph.dataset_types[dataset_key.parent_dataset_type_name]
+            by_dataset_type_name[dataset_key.parent_dataset_type_name].append(
+                DataCoordinate.from_required_values(dataset_type_node.dimensions, dataset_key.data_id_values)
+            )
+        return {
+            edge.connection_name: by_dataset_type_name[edge.parent_dataset_type_name]
+            for edge in self._task_node.outputs.values()
+        }
+
     def add_input(
         self, quantum_data_id: DataCoordinate, connection_name: str, dataset_data_id: DataCoordinate
     ) -> None:
@@ -1284,13 +1340,42 @@ class QuantaAdjuster:
             )
         self._skeleton.add_input_edge(quantum_key, dataset_key)
 
+    def move_output(
+        self, quantum_data_id: DataCoordinate, connection_name: str, dataset_data_id: DataCoordinate
+    ) -> None:
+        """Remove an output of one quantum and make it a new output of another.
+
+        Parameters
+        ----------
+        quantum_data_id : `~lsst.daf.butler.DataCoordinate`
+            Data ID of the quantum to move the output to.
+        connection_name : `str`
+            Name of the connection (the task-internal name, not the butler
+            dataset type name).
+        dataset_data_id : `~lsst.daf.butler.DataCoordinate`
+            Data ID of the output dataset.  Must already exist in the graph
+            as an output of a different quantum of this task.
+        """
+        from .quantum_graph_skeleton import DatasetKey, QuantumKey
+
+        quantum_key = QuantumKey(self._task_node.label, quantum_data_id.required_values)
+        write_edge = self._task_node.outputs[connection_name]
+        dataset_key = DatasetKey(write_edge.parent_dataset_type_name, dataset_data_id.required_values)
+        if dataset_key not in self._skeleton:
+            raise LookupError(
+                f"Dataset {write_edge.parent_dataset_type_name}@{dataset_data_id} is "
+                "not already in the graph."
+            )
+        self._skeleton.remove_output_edge(dataset_key)
+        self._skeleton.add_output_edge(quantum_key, dataset_key)
+
     def expand_quantum_data_id(self, data_id: DataCoordinate) -> DataCoordinate:
         """Expand a quantum data ID to include implied values and dimension
         records.
 
         Parameters
         ----------
-        quantum_data_id : `~lsst.daf.butler.DataCoordinate`
+        data_id : `~lsst.daf.butler.DataCoordinate`
             A data ID of a quantum already in the graph.
 
         Returns

{lsst_pipe_base-29.2025.1700 → lsst_pipe_base-29.2025.1900}/python/lsst/pipe/base/quantum_graph_builder.py

@@ -170,7 +170,6 @@ class QuantumGraphBuilder(ABC):
         self.log = getLogger(__name__)
         self.metadata = TaskMetadata()
         self._pipeline_graph = pipeline_graph
-        self.butler = butler
         if input_collections is None:
             input_collections = butler.collections.defaults
         if not input_collections:
@@ -180,6 +179,7 @@ class QuantumGraphBuilder(ABC):
             output_run = butler.run
         if not output_run:
             raise ValueError("No output RUN collection provided.")
+        self.butler = butler.clone(collections=input_collections)
         self.output_run = output_run
         self.skip_existing_in = skip_existing_in
         self.empty_data_id = DataCoordinate.make_empty(butler.dimensions)
@@ -494,7 +494,7 @@ class QuantumGraphBuilder(ABC):
         # Give the task a chance to adjust all quanta together.  This
         # operates directly on the skeleton (via a the 'adjuster', which
         # is just an interface adapter).
-        adjuster = QuantaAdjuster(task_node.label, self._pipeline_graph, skeleton)
+        adjuster = QuantaAdjuster(task_node.label, self._pipeline_graph, skeleton, self.butler)
         task_node.get_connections().adjust_all_quanta(adjuster)
         # Loop over all quanta again, remembering those we get rid of in other
         # ways.
@@ -507,6 +507,7 @@ class QuantumGraphBuilder(ABC):
             # raise if one of the check conditions is not met, which is the
             # intended behavior.
             helper = AdjustQuantumHelper(inputs=adjusted_inputs, outputs=adjusted_outputs)
+            quantum_data_id = skeleton[quantum_key]["data_id"]
             try:
                 helper.adjust_in_place(task_node.get_connections(), task_node.label, quantum_data_id)
             except NoWorkFound as err:

{lsst_pipe_base-29.2025.1700 → lsst_pipe_base-29.2025.1900}/python/lsst/pipe/base/quantum_graph_skeleton.py

@@ -517,6 +517,20 @@ class QuantumGraphSkeleton:
         assert dataset_key in self._xgraph
         self._xgraph.add_edge(task_key, dataset_key)
 
+    def remove_output_edge(self, dataset_key: DatasetKey) -> None:
+        """Remove the edge connecting a dataset to the quantum that produces
+        it.
+
+        Parameters
+        ----------
+        dataset_key : `DatasetKey`
+            Identifier for the dataset node.  Must identify a node already
+            present in the graph.
+        """
+        (task_key,) = self._xgraph.predecessors(dataset_key)
+        assert dataset_key in self._xgraph
+        self._xgraph.remove_edge(task_key, dataset_key)
+
     def remove_orphan_datasets(self) -> None:
         """Remove any dataset nodes that do not have any edges."""
         for orphan in list(networkx.isolates(self._xgraph)):