lsst-pipe-base 29.2025.3100__tar.gz → 29.2025.3300__tar.gz

{lsst_pipe_base-29.2025.3100/python/lsst_pipe_base.egg-info → lsst_pipe_base-29.2025.3300}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-pipe-base
-Version: 29.2025.3100
+Version: 29.2025.3300
 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.3100 → lsst_pipe_base-29.2025.3300}/pyproject.toml

@@ -195,6 +195,7 @@ checks = [
     "EX01",  # Example section.
     "SS06",  # Summary can go into second line.
     "GL01",  # Summary text can start on same line as """
+    "GL03",  # Double line breaks (fights with ruff-fmt on examples in docs).
     "GL08",  # Do not require docstring.
     "ES01",  # No extended summary required.
     "RT01",  # Unfortunately our @property trigger this.

{lsst_pipe_base-29.2025.3100 → lsst_pipe_base-29.2025.3300}/python/lsst/pipe/base/__init__.py

@@ -11,7 +11,6 @@ from ._status import *
 from ._task_metadata import *
 from .config import *
 from .connections import *
-from .executionButlerBuilder import *
 from .graph import *
 from .pipeline import *
 

{lsst_pipe_base-29.2025.3100 → lsst_pipe_base-29.2025.3300}/python/lsst/pipe/base/all_dimensions_quantum_graph_builder.py

@@ -44,7 +44,6 @@ import astropy.table
 from lsst.daf.butler import (
     Butler,
     DataCoordinate,
-    DimensionDataAttacher,
     DimensionElement,
     DimensionGroup,
     DimensionRecordSet,
@@ -57,7 +56,7 @@ from lsst.utils.timer import timeMethod
 
 from ._datasetQueryConstraints import DatasetQueryConstraintVariant
 from .quantum_graph_builder import QuantumGraphBuilder, QuantumGraphBuilderError
-from .quantum_graph_skeleton import DatasetKey, Key, PrerequisiteDatasetKey, QuantumGraphSkeleton, QuantumKey
+from .quantum_graph_skeleton import DatasetKey, PrerequisiteDatasetKey, QuantumGraphSkeleton, QuantumKey
 
 if TYPE_CHECKING:
     from .pipeline_graph import DatasetTypeNode, PipelineGraph, TaskNode
@@ -143,13 +142,14 @@ class AllDimensionsQuantumGraphBuilder(QuantumGraphBuilder):
         self._query_for_data_ids(tree)
         dimension_records = self._fetch_most_dimension_records(tree)
         tree.generate_data_ids(self.log)
-        skeleton = self._make_subgraph_skeleton(tree)
+        skeleton: QuantumGraphSkeleton = self._make_subgraph_skeleton(tree)
         if not skeleton.has_any_quanta:
             # QG is going to be empty; exit early not just for efficiency, but
             # also so downstream code doesn't have to guard against this case.
             return skeleton
         self._find_followup_datasets(tree, skeleton)
-        self._attach_dimension_records(skeleton, dimension_records)
+        all_data_id_dimensions = subgraph.get_all_dimensions()
+        skeleton.attach_dimension_records(self.butler, all_data_id_dimensions, dimension_records)
         return skeleton
 
     def _query_for_data_ids(self, tree: _DimensionGroupTree) -> None:
@@ -486,44 +486,6 @@ class AllDimensionsQuantumGraphBuilder(QuantumGraphBuilder):
                     result.append(record_set)
         return result
 
-    @timeMethod
-    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.
-
-        Parameters
-        ----------
-        skeleton : `.quantum_graph_skeleton.QuantumGraphSkeleton`
-            In-progress quantum graph to modify in place.
-        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, list[Key]]] = defaultdict(
-            lambda: defaultdict(list)
-        )
-        data_id: DataCoordinate | None
-        for node_key in skeleton:
-            if data_id := skeleton[node_key].get("data_id"):
-                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():
-            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)
-
 
 @dataclasses.dataclass(eq=False, repr=False, slots=True)
 class _DimensionGroupTwig:

{lsst_pipe_base-29.2025.3100 → lsst_pipe_base-29.2025.3300}/python/lsst/pipe/base/caching_limited_butler.py

@@ -84,7 +84,6 @@ class CachingLimitedButler(LimitedButler):
         no_copy_on_cache: Set[str] = frozenset(),
     ):
         self._wrapped = wrapped
-        self._datastore = self._wrapped._datastore
         self.storageClasses = self._wrapped.storageClasses
         self._cache_on_put = cache_on_put
         self._cache_on_get = cache_on_get
@@ -148,9 +147,6 @@ class CachingLimitedButler(LimitedButler):
         # note that this does not use the cache at all
         return self._wrapped.getDeferred(ref, parameters=parameters, storageClass=storageClass)
 
-    def stored(self, ref: DatasetRef) -> bool:
-        return self.stored_many([ref])[ref]  # TODO: remove this once DM-43086 is done.
-
     def stored_many(self, refs: Iterable[DatasetRef]) -> dict[DatasetRef, bool]:
         result = {}
         unknown_refs = []
@@ -205,3 +201,11 @@ class CachingLimitedButler(LimitedButler):
     @property
     def dimensions(self) -> DimensionUniverse:
         return self._wrapped.dimensions
+
+    @property
+    def _datastore(self) -> Any:
+        return self._wrapped._datastore
+
+    @_datastore.setter  # demanded by MyPy since we declare it to be an instance attribute in LimitedButler.
+    def _datastore(self, value: Any) -> None:
+        self._wrapped._datastore = value

{lsst_pipe_base-29.2025.3100 → lsst_pipe_base-29.2025.3300}/python/lsst/pipe/base/graph/graphSummary.py

@@ -39,10 +39,10 @@ class QgraphTaskSummary(pydantic.BaseModel):
     numQuanta: int = 0
     """Number of Quanta for this PipelineTask in this QuantumGraph."""
 
-    numInputs: dict[str, int] = Counter()
+    numInputs: dict[str, int] = pydantic.Field(default_factory=Counter)
     """Total number of inputs per dataset type name for this PipelineTask."""
 
-    numOutputs: dict[str, int] = Counter()
+    numOutputs: dict[str, int] = pydantic.Field(default_factory=Counter)
     """Total number of outputs per dataset type name for this PipelineTask."""
 
     # Work around the fact that Sphinx chokes on Pydantic docstring formatting,
@@ -79,7 +79,7 @@ class QgraphTaskSummary(pydantic.BaseModel):
 class QgraphSummary(pydantic.BaseModel):
     """Report for the QuantumGraph creation or reading."""
 
-    graphID: BuildId
+    graphID: BuildId | None = None
     """QuantumGraph ID."""
 
     cmdLine: str | None = None
@@ -97,7 +97,7 @@ class QgraphSummary(pydantic.BaseModel):
     outputRun: str | None = None
     """Output run collection."""
 
-    qgraphTaskSummaries: dict[str, QgraphTaskSummary] = {}
+    qgraphTaskSummaries: dict[str, QgraphTaskSummary] = pydantic.Field(default_factory=dict)
     """Quanta information summarized per PipelineTask."""
 
     # Work around the fact that Sphinx chokes on Pydantic docstring formatting,

{lsst_pipe_base-29.2025.3100 → lsst_pipe_base-29.2025.3300}/python/lsst/pipe/base/mp_graph_executor.py

@@ -29,6 +29,7 @@ from __future__ import annotations
 
 __all__ = ["MPGraphExecutor", "MPGraphExecutorError", "MPTimeoutError"]
 
+import enum
 import importlib
 import logging
 import multiprocessing
@@ -39,7 +40,6 @@ import threading
 import time
 import uuid
 from collections.abc import Iterable
-from enum import Enum
 from typing import Literal
 
 from lsst.daf.butler.cli.cliLog import CliLog
@@ -55,14 +55,26 @@ from .quantum_reports import ExecutionStatus, QuantumReport, Report
 _LOG = logging.getLogger(__name__)
 
 
-# Possible states for the executing task:
-#  - PENDING: job has not started yet
-#  - RUNNING: job is currently executing
-#  - FINISHED: job finished successfully
-#  - FAILED: job execution failed (process returned non-zero status)
-#  - TIMED_OUT: job is killed due to too long execution time
-#  - FAILED_DEP: one of the dependencies of this job has failed/timed out
-JobState = Enum("JobState", "PENDING RUNNING FINISHED FAILED TIMED_OUT FAILED_DEP")
+class JobState(enum.Enum):
+    """Possible state for an executing task."""
+
+    PENDING = enum.auto()
+    """The job has not started yet."""
+
+    RUNNING = enum.auto()
+    """The job is currently executing."""
+
+    FINISHED = enum.auto()
+    """The job finished successfully."""
+
+    FAILED = enum.auto()
+    """The job execution failed (process returned non-zero status)."""
+
+    TIMED_OUT = enum.auto()
+    """The job was killed due to too long execution time."""
+
+    FAILED_DEP = enum.auto()
+    """One of the dependencies of this job failed or timed out."""
 
 
 class _Job:

{lsst_pipe_base-29.2025.3100 → lsst_pipe_base-29.2025.3300}/python/lsst/pipe/base/pipeline_graph/_pipeline_graph.py

@@ -150,8 +150,10 @@ class PipelineGraph:
         self._description = value
 
     @property
-    def universe(self) -> DimensionUniverse | None:
+    def universe(self) -> DimensionUniverse:
         """Definitions for all butler dimensions."""
+        if self._universe is None:
+            raise UnresolvedGraphError("Pipeline graph is not resolved.")
         return self._universe
 
     @property
@@ -159,7 +161,7 @@ class PipelineGraph:
         """Data ID that represents a constraint on all quanta generated from
         this pipeline.
 
-        This is may not be available unless `universe` is not `None`.
+        This is may not be available unless the graph is resolved.
         """
         return DataCoordinate.standardize(self._raw_data_id, universe=self.universe)
 
@@ -305,7 +307,7 @@ class PipelineGraph:
                 for k, v in self._task_subsets.items()
             },
             description=self._description,
-            universe=self.universe,
+            universe=self._universe,
             data_id=self._raw_data_id,
             step_definitions=step_definitions,
         )
@@ -774,7 +776,7 @@ class PipelineGraph:
             key=NodeKey(NodeType.TASK, label),
             init_key=NodeKey(NodeType.TASK_INIT, label),
             data=_TaskNodeImportedData.configure(label, task_class, config, connections),
-            universe=self.universe,
+            universe=self._universe,
         )
         self.add_task_nodes([task_node])
         return task_node
@@ -1571,9 +1573,9 @@ class PipelineGraph:
 
         Returns
         -------
-        groups : `dict` [ `DimensionGroup`, `tuple` ]
-            A dictionary of groups keyed by `DimensionGroup`, in which each
-            value is a tuple of:
+        groups : `dict` [ `~lsst.daf.butler.DimensionGroup`, `tuple` ]
+            A dictionary of groups keyed by `~lsst.daf.butler.DimensionGroup`,
+            in which each value is a tuple of:
 
             - a `dict` of `TaskNode` instances, keyed by task label
             - a `dict` of `DatasetTypeNode` instances, keyed by
@@ -1605,6 +1607,25 @@ class PipelineGraph:
                 group[1][dataset_type_node.name] = dataset_type_node
         return result
 
+    def get_all_dimensions(self, prerequisites: bool = True) -> DimensionGroup:
+        """Return all dimensions used in this graph's tasks and dataset types.
+
+        Parameters
+        ----------
+        prerequisites : `bool`, optional
+            If `False`, do not include the dimensions that are only used by
+            prerequisite input dataset types.
+
+        Returns
+        -------
+        dimensions : `~lsst.daf.butler.DimensionGroup`.
+            All dimensions in this pipeline.
+        """
+        return DimensionGroup.union(
+            *self.group_by_dimensions(prerequisites=prerequisites).keys(),
+            universe=self.universe,
+        )
+
     def split_independent(self) -> Iterable[PipelineGraph]:
         """Iterate over independent subgraphs that together comprise this
         pipeline graph.
@@ -1668,11 +1689,13 @@ class PipelineGraph:
         not considered part of the pipeline graph in other respects, but it
         does get written with other provenance datasets.
         """
-        if self.universe is None:
+        if self._universe is None:
             raise UnresolvedGraphError(
                 "PipelineGraph must be resolved in order to get the packages dataset type."
             )
-        return DatasetType(PACKAGES_INIT_OUTPUT_NAME, self.universe.empty, PACKAGES_INIT_OUTPUT_STORAGE_CLASS)
+        return DatasetType(
+            PACKAGES_INIT_OUTPUT_NAME, self._universe.empty, PACKAGES_INIT_OUTPUT_STORAGE_CLASS
+        )
 
     def register_dataset_types(self, butler: Butler, include_packages: bool = True) -> None:
         """Register all dataset types in a data repository.
@@ -1767,6 +1790,7 @@ class PipelineGraph:
         self,
         get_init_input: Callable[[DatasetType], Any] | None = None,
         init_outputs: list[tuple[Any, DatasetType]] | None = None,
+        labels: Iterable[str] | None = None,
     ) -> list[PipelineTask]:
         """Instantiate all tasks in the pipeline.
 
@@ -1785,6 +1809,9 @@ class PipelineGraph:
             correspond to the storage class of the output connection, which
             may not be the same as the storage class on the graph's dataset
             type node.
+        labels : `~collections.abc.Iterable` [ `str` ], optional
+            The labels of tasks to instantiate.  If not provided, all tasks in
+            the graph will be instantiated.
 
         Returns
         -------
@@ -1793,10 +1820,13 @@ class PipelineGraph:
         """
         if not self.is_fully_resolved:
             raise UnresolvedGraphError("Pipeline graph must be fully resolved before instantiating tasks.")
-        empty_data_id = DataCoordinate.make_empty(cast(DimensionUniverse, self.universe))
+        empty_data_id = DataCoordinate.make_empty(self.universe)
+        labels = set(labels) if labels is not None else self.tasks.keys()
         handles: dict[str, InMemoryDatasetHandle] = {}
         tasks: list[PipelineTask] = []
         for task_node in self.tasks.values():
+            if task_node.label not in labels:
+                continue
             task_init_inputs: dict[str, Any] = {}
             for read_edge in task_node.init.inputs.values():
                 if (handle := handles.get(read_edge.dataset_type_name)) is not None:

{lsst_pipe_base-29.2025.3100 → lsst_pipe_base-29.2025.3300}/python/lsst/pipe/base/pipeline_graph/_tasks.py

@@ -360,6 +360,57 @@ class TaskInitNode:
         yield from self.outputs.values()
         yield self.config_output
 
+    def get_input_edge(self, connection_name: str) -> ReadEdge:
+        """Look up an input edge by connection name.
+
+        Parameters
+        ----------
+        connection_name : `str`
+            Name of the connection.
+
+        Returns
+        -------
+        edge : `ReadEdge`
+            Input edge.
+        """
+        return self.inputs[connection_name]
+
+    def get_output_edge(self, connection_name: str) -> WriteEdge:
+        """Look up an output edge by connection name.
+
+        Parameters
+        ----------
+        connection_name : `str`
+            Name of the connection.
+
+        Returns
+        -------
+        edge : `WriteEdge`
+            Output edge.
+        """
+        if connection_name == acc.CONFIG_INIT_OUTPUT_CONNECTION_NAME:
+            return self.config_output
+        return self.outputs[connection_name]
+
+    def get_edge(self, connection_name: str) -> Edge:
+        """Look up an edge by connection name.
+
+        Parameters
+        ----------
+        connection_name : `str`
+            Name of the connection.
+
+        Returns
+        -------
+        edge : `Edge`
+            Edge.
+        """
+        try:
+            return self.get_input_edge(connection_name)
+        except KeyError:
+            pass
+        return self.get_output_edge(connection_name)
+
     def diff_edges(self, other: TaskInitNode) -> list[str]:
         """Compare the edges of this task initialization node to those from the
         same task label in a different pipeline.
@@ -742,6 +793,61 @@ class TaskNode:
         if self.log_output is not None:
             yield self.log_output
 
+    def get_input_edge(self, connection_name: str) -> ReadEdge:
+        """Look up an input edge by connection name.
+
+        Parameters
+        ----------
+        connection_name : `str`
+            Name of the connection.
+
+        Returns
+        -------
+        edge : `ReadEdge`
+            Input edge.
+        """
+        return self.inputs[connection_name]
+
+    def get_output_edge(self, connection_name: str) -> WriteEdge:
+        """Look up an output edge by connection name.
+
+        Parameters
+        ----------
+        connection_name : `str`
+            Name of the connection.
+
+        Returns
+        -------
+        edge : `WriteEdge`
+            Output edge.
+        """
+        if connection_name == acc.METADATA_OUTPUT_CONNECTION_NAME:
+            return self.metadata_output
+        if connection_name == acc.LOG_OUTPUT_CONNECTION_NAME:
+            if self.log_output is None:
+                raise KeyError(connection_name)
+            return self.log_output
+        return self.outputs[connection_name]
+
+    def get_edge(self, connection_name: str) -> Edge:
+        """Look up an edge by connection name.
+
+        Parameters
+        ----------
+        connection_name : `str`
+            Name of the connection.
+
+        Returns
+        -------
+        edge : `Edge`
+            Edge.
+        """
+        try:
+            return self.get_input_edge(connection_name)
+        except KeyError:
+            pass
+        return self.get_output_edge(connection_name)
+
     def diff_edges(self, other: TaskNode) -> list[str]:
         """Compare the edges of this task node to those from the same task
         label in a different pipeline.

{lsst_pipe_base-29.2025.3100 → lsst_pipe_base-29.2025.3300}/python/lsst/pipe/base/pipeline_graph/io.py

@@ -713,7 +713,7 @@ class SerializedPipelineGraph(pydantic.BaseModel):
             },
             step_labels=list(target.steps),
             steps_verified=target.steps.verified,
-            dimensions=target.universe.dimensionConfig.toDict() if target.universe is not None else None,
+            dimensions=target._universe.dimensionConfig.toDict() if target._universe is not None else None,
             data_id=target._raw_data_id,
         )
         if target._sorted_keys:

{lsst_pipe_base-29.2025.3100 → lsst_pipe_base-29.2025.3300}/python/lsst/pipe/base/quantum_graph_builder.py

@@ -55,6 +55,7 @@ from lsst.daf.butler import (
     NamedKeyMapping,
     Quantum,
 )
+from lsst.daf.butler.datastore.record_data import DatastoreRecordData
 from lsst.daf.butler.registry import MissingCollectionError, MissingDatasetTypeError
 from lsst.utils.logging import LsstLogAdapter, getLogger
 from lsst.utils.timer import timeMethod
@@ -1000,19 +1001,35 @@ class QuantumGraphBuilder(ABC):
         """
         overall_inputs = skeleton.extract_overall_inputs()
         exported_records = self.butler._datastore.export_records(overall_inputs.values())
-        for quantum_key in skeleton.iter_all_quanta():
-            quantum_records = {}
-            input_ids = {
+        for task_label in self._pipeline_graph.tasks:
+            if not skeleton.has_task(task_label):
+                continue
+            task_init_key = skeleton.get_task_init_node(task_label)
+            init_input_ids = {
                 ref.id
-                for dataset_key in skeleton.iter_inputs_of(quantum_key)
+                for dataset_key in skeleton.iter_inputs_of(task_init_key)
                 if (ref := overall_inputs.get(dataset_key)) is not None
             }
-            if input_ids:
+            init_records = {}
+            if init_input_ids:
                 for datastore_name, records in exported_records.items():
-                    matching_records = records.subset(input_ids)
+                    matching_records = records.subset(init_input_ids)
                     if matching_records is not None:
-                        quantum_records[datastore_name] = matching_records
-            skeleton[quantum_key]["datastore_records"] = quantum_records
+                        init_records[datastore_name] = matching_records
+            skeleton[task_init_key]["datastore_records"] = init_records
+            for quantum_key in skeleton.get_quanta(task_label):
+                quantum_records = {}
+                input_ids = {
+                    ref.id
+                    for dataset_key in skeleton.iter_inputs_of(quantum_key)
+                    if (ref := overall_inputs.get(dataset_key)) is not None
+                }
+                if input_ids:
+                    for datastore_name, records in exported_records.items():
+                        matching_records = records.subset(input_ids)
+                        if matching_records is not None:
+                            quantum_records[datastore_name] = matching_records
+                skeleton[quantum_key]["datastore_records"] = quantum_records
 
     @final
     @timeMethod
@@ -1045,20 +1062,29 @@ class QuantumGraphBuilder(ABC):
                 continue
             task_node = self._pipeline_graph.tasks[task_def.label]
             task_init_key = skeleton.get_task_init_node(task_def.label)
-            init_inputs[task_def] = skeleton[task_init_key]["inputs"].values()
-            init_outputs[task_def] = skeleton[task_init_key]["outputs"].values()
+            task_init_state = skeleton[task_init_key]
+            init_datastore_records: dict[str, DatastoreRecordData] = task_init_state.get(
+                "datastore_records", {}
+            )
+            init_inputs[task_def] = task_init_state["inputs"].values()
+            init_outputs[task_def] = task_init_state["outputs"].values()
             quanta_for_task: set[Quantum] = set()
             for quantum_key in skeleton.get_quanta(task_node.label):
-                node_state = skeleton[quantum_key]
+                quantum_state = skeleton[quantum_key]
+                quantum_datastore_records: dict[str, DatastoreRecordData] = quantum_state.get(
+                    "datastore_records", {}
+                )
                 quanta_for_task.add(
                     Quantum(
                         taskName=task_node.task_class_name,
                         taskClass=task_node.task_class,
-                        dataId=node_state["data_id"],
-                        initInputs=node_state["init_inputs"],
-                        inputs=node_state["inputs"],
-                        outputs=node_state["outputs"],
-                        datastore_records=node_state.get("datastore_records"),
+                        dataId=quantum_state["data_id"],
+                        initInputs=quantum_state["init_inputs"],
+                        inputs=quantum_state["inputs"],
+                        outputs=quantum_state["outputs"],
+                        datastore_records=DatastoreRecordData.merge_mappings(
+                            quantum_datastore_records, init_datastore_records
+                        ),
                     )
                 )
             quanta[task_def] = quanta_for_task

{lsst_pipe_base-29.2025.3100 → lsst_pipe_base-29.2025.3300}/python/lsst/pipe/base/quantum_graph_skeleton.py

@@ -40,12 +40,21 @@ __all__ = (
 )
 
 import dataclasses
+from collections import defaultdict
 from collections.abc import Iterable, Iterator, MutableMapping, Set
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, TypeAlias
 
 import networkx
 
-from lsst.daf.butler import DataCoordinate, DataIdValue, DatasetRef
+from lsst.daf.butler import (
+    Butler,
+    DataCoordinate,
+    DataIdValue,
+    DatasetRef,
+    DimensionDataAttacher,
+    DimensionGroup,
+    DimensionRecordSet,
+)
 from lsst.utils.logging import getLogger
 
 if TYPE_CHECKING:
@@ -170,6 +179,7 @@ class QuantumGraphSkeleton:
         self._tasks: dict[str, tuple[TaskInitKey, set[QuantumKey]]] = {}
         self._xgraph: networkx.DiGraph = networkx.DiGraph()
         self._global_init_outputs: set[DatasetKey] = set()
+        self._dimension_data: dict[str, DimensionRecordSet] = {}
         for task_label in task_labels:
             task_init_key = TaskInitKey(task_label)
             self._tasks[task_label] = (task_init_key, set())
@@ -310,6 +320,10 @@ class QuantumGraphSkeleton:
         for task_label, (_, quanta) in other._tasks.items():
             self._tasks[task_label][1].update(quanta)
         self._xgraph.update(other._xgraph)
+        for record_set in other._dimension_data.values():
+            self._dimension_data.setdefault(
+                record_set.element.name, DimensionRecordSet(record_set.element)
+            ).update(record_set)
 
     def add_quantum_node(self, task_label: str, data_id: DataCoordinate, **attrs: Any) -> QuantumKey:
         """Add a new node representing a quantum.
@@ -710,3 +724,48 @@ class QuantumGraphSkeleton:
             Raised if this node does not have an expanded data ID.
         """
         return self._xgraph.nodes[key]["data_id"]
+
+    def attach_dimension_records(
+        self, butler: Butler, dimensions: DimensionGroup, dimension_records: Iterable[DimensionRecordSet]
+    ) -> None:
+        """Attach dimension records to the data IDs in the skeleton.
+
+        Parameters
+        ----------
+        butler : `lsst.daf.butler.Butler`
+            Butler to use to query for missing dimension records.
+        dimensions : `lsst.daf.butler.DimensionGroup`
+            Superset of all of the dimensions of all data IDs.
+        dimension_records : `~collections.abc.Iterable` [ \
+                `lsst.daf.butler.DimensionRecordSet` ]
+            Iterable of sets of dimension records to attach.
+        """
+        for record_set in dimension_records:
+            self._dimension_data.setdefault(
+                record_set.element.name, DimensionRecordSet(record_set.element)
+            ).update(record_set)
+        # Group all nodes by data ID (and dimensions of data ID).
+        data_ids_to_expand: defaultdict[DimensionGroup, defaultdict[DataCoordinate, list[Key]]] = defaultdict(
+            lambda: defaultdict(list)
+        )
+        data_id: DataCoordinate | None
+        for node_key in self:
+            if data_id := self[node_key].get("data_id"):
+                data_ids_to_expand[data_id.dimensions][data_id].append(node_key)
+        attacher = DimensionDataAttacher(records=self._dimension_data.values(), dimensions=dimensions)
+        for dimensions, data_ids in data_ids_to_expand.items():
+            with 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:
+                    self.set_data_id(node_key, expanded_data_id)
+        # Hold on to any records that we had to query for.
+        self._dimension_data = attacher.records
+
+    def get_dimension_data(self) -> list[DimensionRecordSet]:
+        """Return the dimension records attached to data IDs."""
+        return list(self._dimension_data.values())