lsst-daf-butler 30.2026.100__tar.gz → 30.2026.300__tar.gz

{lsst_daf_butler-30.2026.100/python/lsst_daf_butler.egg-info → lsst_daf_butler-30.2026.300}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-daf-butler
-Version: 30.2026.100
+Version: 30.2026.300
 Summary: An abstraction layer for reading and writing astronomical data to datastores.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License-Expression: BSD-3-Clause OR GPL-3.0-or-later

{lsst_daf_butler-30.2026.100 → lsst_daf_butler-30.2026.300}/python/lsst/daf/butler/_butler.py

@@ -1566,7 +1566,7 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
 
     @abstractmethod
     def transfer_dimension_records_from(
-        self, source_butler: LimitedButler | Butler, source_refs: Iterable[DatasetRef]
+        self, source_butler: LimitedButler | Butler, source_refs: Iterable[DatasetRef | DataCoordinate]
     ) -> None:
         """Transfer dimension records to this Butler from another Butler.
 
@@ -1578,10 +1578,9 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
             `Butler` whose registry will be used to expand data IDs. If the
             source refs contain coordinates that are used to populate other
             records then this will also need to be a full `Butler`.
-        source_refs : iterable of `DatasetRef`
-            Datasets defined in the source butler whose dimension records
-            should be transferred to this butler. In most circumstances.
-            transfer is faster if the dataset refs are expanded.
+        source_refs : iterable of `DatasetRef` or `DataCoordinate`
+            Datasets or data IDs defined in the source butler whose dimension
+            records should be transferred to this butler.
         """
         raise NotImplementedError()
 
@@ -2227,3 +2226,7 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
     @abstractmethod
     def close(self) -> None:
         raise NotImplementedError()
+
+    @abstractmethod
+    def _expand_data_ids(self, data_ids: Iterable[DataCoordinate]) -> list[DataCoordinate]:
+        raise NotImplementedError()

{lsst_daf_butler-30.2026.100 → lsst_daf_butler-30.2026.300}/python/lsst/daf/butler/_butler_metrics.py

@@ -29,12 +29,15 @@ from __future__ import annotations
 
 from collections.abc import Callable, Iterator
 from contextlib import contextmanager
+from typing import Concatenate, ParamSpec
 
 from pydantic import BaseModel
 
 from lsst.utils.logging import LsstLoggers
 from lsst.utils.timer import time_this
 
+P = ParamSpec("P")
+
 
 class ButlerMetrics(BaseModel):
     """Metrics collected during Butler operations."""
@@ -45,18 +48,26 @@ class ButlerMetrics(BaseModel):
     time_in_get: float = 0.0
     """Wall-clock time, in seconds, spent in get()."""
 
+    time_in_ingest: float = 0.0
+    """Wall-clock time, in seconds, spent in ingest()."""
+
     n_get: int = 0
     """Number of datasets retrieved with get()."""
 
     n_put: int = 0
     """Number of datasets stored with put()."""
 
+    n_ingest: int = 0
+    """Number of datasets ingested."""
+
     def reset(self) -> None:
         """Reset all metrics."""
         self.time_in_put = 0.0
         self.time_in_get = 0.0
+        self.time_in_ingest = 0.0
         self.n_get = 0
         self.n_put = 0
+        self.n_ingest = 0
 
     def increment_get(self, duration: float) -> None:
         """Increment time for get().
@@ -80,13 +91,31 @@ class ButlerMetrics(BaseModel):
         self.time_in_put += duration
         self.n_put += 1
 
+    def increment_ingest(self, duration: float, n_datasets: int) -> None:
+        """Increment time and datasets for ingest().
+
+        Parameters
+        ----------
+        duration : `float`
+            Duration to add to the ingest() statistics.
+        n_datasets : `int`
+            Number of datasets to be ingested for this call.
+        """
+        self.time_in_ingest += duration
+        self.n_ingest += n_datasets
+
     @contextmanager
     def _timer(
-        self, handler: Callable[[float], None], log: LsstLoggers | None = None, msg: str | None = None
+        self,
+        handler: Callable[Concatenate[float, P], None],
+        log: LsstLoggers | None = None,
+        msg: str | None = None,
+        *args: P.args,
+        **kwargs: P.kwargs,
     ) -> Iterator[None]:
         with time_this(log=log, msg=msg) as timer:
             yield
-        handler(timer.duration)
+        handler(timer.duration, *args, **kwargs)
 
     @contextmanager
     def instrument_get(self, log: LsstLoggers | None = None, msg: str | None = None) -> Iterator[None]:
@@ -115,3 +144,21 @@ class ButlerMetrics(BaseModel):
         """
         with self._timer(self.increment_put, log=log, msg=msg):
             yield
+
+    @contextmanager
+    def instrument_ingest(
+        self, n_datasets: int, log: LsstLoggers | None = None, msg: str | None = None
+    ) -> Iterator[None]:
+        """Run code and increment ingest statistics.
+
+        Parameters
+        ----------
+        n_datasets : `int`
+            Number of datasets being ingested.
+        log : `logging.Logger` or `None`
+            Logger to use for any timing information.
+        msg : `str` or `None`
+            Any message to be included in log output.
+        """
+        with self._timer(self.increment_ingest, n_datasets=n_datasets, log=log, msg=msg):
+            yield

{lsst_daf_butler-30.2026.100 → lsst_daf_butler-30.2026.300}/python/lsst/daf/butler/_labeled_butler_factory.py

@@ -30,7 +30,9 @@ from __future__ import annotations
 __all__ = ("LabeledButlerFactory", "LabeledButlerFactoryProtocol")
 
 from collections.abc import Mapping
-from typing import Protocol
+from contextlib import AbstractContextManager
+from logging import getLogger
+from typing import Any, Literal, Protocol, Self
 
 from lsst.resources import ResourcePathExpression
 
@@ -40,6 +42,8 @@ from ._butler_repo_index import ButlerRepoIndex
 from ._utilities.named_locks import NamedLocks
 from ._utilities.thread_safe_cache import ThreadSafeCache
 
+_LOG = getLogger(__name__)
+
 
 class LabeledButlerFactoryProtocol(Protocol):
     """Callable to retrieve a butler from a label."""
@@ -47,7 +51,7 @@ class LabeledButlerFactoryProtocol(Protocol):
     def __call__(self, label: str) -> Butler: ...
 
 
-class LabeledButlerFactory:
+class LabeledButlerFactory(AbstractContextManager):
     """Factory for efficiently instantiating Butler instances from the
     repository index file.  This is intended for use from long-lived services
     that want to instantiate a separate Butler instance for each end user
@@ -60,6 +64,9 @@ class LabeledButlerFactory:
         files.  If not provided, defaults to the global repository index
         configured by the ``DAF_BUTLER_REPOSITORY_INDEX`` environment variable
         --  see `ButlerRepoIndex`.
+    writeable : `bool`, optional
+        If `True`, Butler instances created by this factory will be writeable.
+        If `False` (the default), instances will be read-only.
 
     Notes
     -----
@@ -76,11 +83,12 @@ class LabeledButlerFactory:
     safely be used by separate threads.
     """
 
-    def __init__(self, repositories: Mapping[str, str] | None = None) -> None:
+    def __init__(self, repositories: Mapping[str, str] | None = None, writeable: bool = False) -> None:
         if repositories is None:
             self._repositories = None
         else:
             self._repositories = dict(repositories)
+        self._writeable = writeable
 
         self._factories = ThreadSafeCache[str, _ButlerFactory]()
         self._initialization_locks = NamedLocks()
@@ -88,6 +96,16 @@ class LabeledButlerFactory:
         # This may be overridden by unit tests.
         self._preload_unsafe_direct_butler_caches = True
 
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> Literal[False]:
+        try:
+            self.close()
+        except Exception:
+            _LOG.exception("An exception occurred during LabeledButlerFactory.close()")
+        return False
+
     def bind(self, access_token: str | None) -> LabeledButlerFactoryProtocol:
         """Create a callable factory function for generating Butler instances
         with out needing to specify access tokans again.
@@ -109,7 +127,7 @@ class LabeledButlerFactory:
 
         return create
 
-    def create_butler(self, *, label: str, access_token: str | None) -> Butler:
+    def create_butler(self, label: str, *, access_token: str | None = None) -> Butler:
         """Create a Butler instance.
 
         Parameters
@@ -118,7 +136,7 @@ class LabeledButlerFactory:
             Label of the repository to instantiate, from the ``repositories``
             parameter to the `LabeledButlerFactory` constructor or the global
             repository index file.
-        access_token : `str` | `None`
+        access_token : `str` | `None`, optional
             Gafaelfawr access token used to authenticate to a Butler server.
             This is required for any repositories configured to use
             `RemoteButler`.  If you only use `DirectButler`, this may be
@@ -167,7 +185,9 @@ class LabeledButlerFactory:
 
         match butler_type:
             case ButlerType.DIRECT:
-                return _DirectButlerFactory(config, self._preload_unsafe_direct_butler_caches)
+                return _DirectButlerFactory(
+                    config, self._preload_unsafe_direct_butler_caches, self._writeable
+                )
             case ButlerType.REMOTE:
                 return _RemoteButlerFactory(config)
             case _:
@@ -189,12 +209,12 @@ class _ButlerFactory(Protocol):
 
 
 class _DirectButlerFactory(_ButlerFactory):
-    def __init__(self, config: ButlerConfig, preload_unsafe_caches: bool) -> None:
+    def __init__(self, config: ButlerConfig, preload_unsafe_caches: bool, writeable: bool) -> None:
         import lsst.daf.butler.direct_butler
 
         # Create a 'template' Butler that will be cloned when callers request
         # an instance.
-        self._butler = Butler.from_config(config)
+        self._butler = Butler.from_config(config, writeable=writeable)
         assert isinstance(self._butler, lsst.daf.butler.direct_butler.DirectButler)
 
         # Load caches so that data is available in cloned instances without

{lsst_daf_butler-30.2026.100 → lsst_daf_butler-30.2026.300}/python/lsst/daf/butler/configs/datastores/formatters.yaml

@@ -100,3 +100,4 @@ VisitBackgroundModel: lsst.daf.butler.formatters.json.JsonFormatter
 VignettingCorrection: lsst.ts.observatory.control.utils.extras.vignetting_storage.VignettingCorrectionFormatter
 SSPAuxiliaryFile: lsst.pipe.tasks.sspAuxiliaryFile.SSPAuxiliaryFileFormatter
 VisitGeometry: lsst.daf.butler.formatters.json.JsonFormatter
+ProvenanceQuantumGraph: lsst.pipe.base.quantum_graph.formatter.ProvenanceFormatter

{lsst_daf_butler-30.2026.100 → lsst_daf_butler-30.2026.300}/python/lsst/daf/butler/configs/storageClasses.yaml

@@ -443,3 +443,18 @@ storageClasses:
     pytype: lsst.pipe.tasks.sspAuxiliaryFile.SSPAuxiliaryFile
   VisitGeometry:
     pytype: lsst.obs.base.visit_geometry.VisitGeometry
+  ProvenanceQuantumGraph:
+    pytype: lsst.pipe.base.quantum_graph.ProvenanceQuantumGraph
+    parameters:
+      - import_mode   # lsst.pipe.base.pipeline_graph.TaskImportMode
+      - quanta  # iterable of uuid.UUID; quanta to read
+      - datasets  # iterable of uuid.UUID; datasets to read
+      - read_init_quanta  # bool, defaults to True; whether to read pre-exec-init info
+    derivedComponents:
+      packages: Packages  # ignores node parameters
+
+      # UUID keys can be quantum or data IDs (whichever is passed in via
+      # parameters).  Nested lists are attempts to run the quantum (last is
+      # most recent).
+      logs: StructuredDataDict  # dict[uuid.UUID, list[ButlerLogRecords]]
+      metadata: StructuredDataDict  # dict[uuid.UUID, list[TaskMetadata]]

{lsst_daf_butler-30.2026.100 → lsst_daf_butler-30.2026.300}/python/lsst/daf/butler/dimensions/_coordinate.py

@@ -755,6 +755,11 @@ class DataCoordinate:
     to_json = to_json_pydantic
     from_json: ClassVar[Callable[..., Self]] = cast(Callable[..., Self], classmethod(from_json_pydantic))
 
+    @property
+    def dataId(self) -> Self:
+        """Return this `DataCoordinate` instance, unmodified."""
+        return self
+
 
 DataId = DataCoordinate | Mapping[str, Any]
 """A type-annotation alias for signatures that accept both informal data ID

{lsst_daf_butler-30.2026.100 → lsst_daf_butler-30.2026.300}/python/lsst/daf/butler/direct_butler/_direct_butler.py

@@ -1822,12 +1822,25 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
                     f" Example: {existing_datasets[0]}"
                 )
 
+        # Calculate some statistics based on the given list of datasets.
+        n_files = len(datasets)
+        n_datasets = 0
+        for d in datasets:
+            n_datasets += len(d.refs)
+        sfiles = "s" if n_files != 1 else ""
+        srefs = "s" if n_datasets != 1 else ""
+
         # We use `datasets` rather `new_datasets` for the Registry
         # portion of this, to let it confirm that everything matches the
         # existing datasets.
         import_info = self._prepare_ingest_file_datasets(datasets, progress)
 
-        with self.transaction():
+        with (
+            self._metrics.instrument_ingest(
+                n_datasets, _LOG, msg=f"Ingesting {n_files} file{sfiles} with {n_datasets} dataset{srefs}"
+            ),
+            self.transaction(),
+        ):
             self._ingest_file_datasets(datasets, import_info, progress)
 
             # Bulk-insert everything into Datastore.
@@ -1982,7 +1995,7 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
             doImport(filename)  # type: ignore
 
     def transfer_dimension_records_from(
-        self, source_butler: LimitedButler | Butler, source_refs: Iterable[DatasetRef]
+        self, source_butler: LimitedButler | Butler, source_refs: Iterable[DatasetRef | DataCoordinate]
     ) -> None:
         # Allowed dimensions in the target butler.
         elements = frozenset(element for element in self.dimensions.elements if element.has_own_table)
@@ -2012,16 +2025,13 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
             source_butler, data_ids, allowed_elements
         )
 
-        can_query = True if isinstance(source_butler, Butler) else False
-
         additional_records: dict[DimensionElement, dict[DataCoordinate, DimensionRecord]] = defaultdict(dict)
         for original_element, record_mapping in primary_records.items():
             # Get dimensions that depend on this dimension.
             populated_by = self.dimensions.get_elements_populated_by(
                 self.dimensions[original_element.name]  # type: ignore
             )
-
-            for data_id in record_mapping.keys():
+            if populated_by:
                 for element in populated_by:
                     if element not in allowed_elements:
                         continue
@@ -2040,28 +2050,32 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
                         # have to be scanned.
                         continue
 
-                    if not can_query:
-                        raise RuntimeError(
-                            f"Transferring populated_by records like {element.name} requires a full Butler."
-                        )
+                    if record_mapping:
+                        if not isinstance(source_butler, Butler):
+                            raise RuntimeError(
+                                f"Transferring populated_by records like {element.name}"
+                                " requires a full Butler."
+                            )
 
-                    records = source_butler.query_dimension_records(  # type: ignore
-                        element.name,
-                        explain=False,
-                        **data_id.mapping,  # type: ignore
-                    )
-                    for record in records:
-                        additional_records[record.definition].setdefault(record.dataId, record)
+                        with source_butler.query() as query:
+                            records = query.join_data_coordinates(record_mapping.keys()).dimension_records(
+                                element.name
+                            )
+                            for record in records:
+                                additional_records[record.definition].setdefault(record.dataId, record)
 
         # The next step is to walk back through the additional records to
         # pick up any missing content (such as visit_definition needing to
         # know the exposure). Want to ensure we do not request records we
         # already have.
         missing_data_ids = set()
-        for name, record_mapping in additional_records.items():
+        for record_mapping in additional_records.values():
             for data_id in record_mapping.keys():
-                if data_id not in primary_records[name]:
-                    missing_data_ids.add(data_id)
+                for dimension in data_id.dimensions.required:
+                    element = source_butler.dimensions[dimension]
+                    dimension_key = data_id.subset(dimension)
+                    if dimension_key not in primary_records[element]:
+                        missing_data_ids.add(dimension_key)
 
         # Fill out the new records. Assume that these new records do not
         # also need to carry over additional populated_by records.
@@ -2078,19 +2092,19 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
     def _extract_dimension_records_from_data_ids(
         self,
         source_butler: LimitedButler | Butler,
-        data_ids: set[DataCoordinate],
+        data_ids: Iterable[DataCoordinate],
         allowed_elements: frozenset[DimensionElement],
     ) -> dict[DimensionElement, dict[DataCoordinate, DimensionRecord]]:
         dimension_records: dict[DimensionElement, dict[DataCoordinate, DimensionRecord]] = defaultdict(dict)
 
+        data_ids = set(data_ids)
+        if not all(data_id.hasRecords() for data_id in data_ids):
+            if isinstance(source_butler, Butler):
+                data_ids = source_butler._expand_data_ids(data_ids)
+            else:
+                raise TypeError("Input butler needs to be a full butler to expand DataId.")
+
         for data_id in data_ids:
-            # Need an expanded record, if not expanded that we need a full
-            # butler with registry (allow mocks with registry too).
-            if not data_id.hasRecords():
-                if registry := getattr(source_butler, "registry", None):
-                    data_id = registry.expandDataId(data_id)
-                else:
-                    raise TypeError("Input butler needs to be a full butler to expand DataId.")
             # If this butler doesn't know about a dimension in the source
             # butler things will break later.
             for element_name in data_id.dimensions.elements:
@@ -2569,6 +2583,9 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
         """Immediately load caches that are used for common operations."""
         self._registry.preload_cache(load_dimension_record_cache=load_dimension_record_cache)
 
+    def _expand_data_ids(self, data_ids: Iterable[DataCoordinate]) -> list[DataCoordinate]:
+        return self._registry.expand_data_ids(data_ids)
+
     _config: ButlerConfig
     """Configuration for this Butler instance."""
 

{lsst_daf_butler-30.2026.100 → lsst_daf_butler-30.2026.300}/python/lsst/daf/butler/logging.py

@@ -764,11 +764,17 @@ class ButlerLogRecords(MutableSequence[ButlerLogRecord]):
 
 
 class ButlerLogRecordHandler(StreamHandler):
-    """Python log handler that accumulates records."""
+    """Python log handler that accumulates records.
 
-    def __init__(self) -> None:
+    Parameters
+    ----------
+    records : `ButlerLogRecords`, optional
+        Container to store logs in.
+    """
+
+    def __init__(self, records: ButlerLogRecords | None = None) -> None:
         super().__init__()
-        self.records = ButlerLogRecords([])
+        self.records = ButlerLogRecords([]) if records is None else records
 
     def emit(self, record: LogRecord) -> None:
         self.records.append(record)

lsst_daf_butler-30.2026.300/python/lsst/daf/butler/registry/expand_data_ids.py

@@ -0,0 +1,93 @@
+# This file is part of daf_butler.
+#
+# 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
+
+from collections import defaultdict
+from collections.abc import Iterable
+
+from ..dimensions import (
+    DataCoordinate,
+    DimensionDataAttacher,
+    DimensionGroup,
+    DimensionUniverse,
+)
+from ..dimensions.record_cache import DimensionRecordCache
+from ..queries import QueryFactoryFunction
+
+
+def expand_data_ids(
+    data_ids: Iterable[DataCoordinate],
+    universe: DimensionUniverse,
+    query_func: QueryFactoryFunction,
+    cache: DimensionRecordCache | None,
+) -> list[DataCoordinate]:
+    """Expand the given data IDs to look up implied dimension values and attach
+    dimension records.
+
+    Parameters
+    ----------
+    data_ids : `~collections.abc.Iterable` [ `DataCoordinate` ]
+        Data coordinates to be expanded.
+    universe : `DimensionUniverse`
+        Dimension universe associated with the given ``data_ids`` values.
+    query_func : QueryFactoryFunction
+        Function used to set up a Butler query context for looking up required
+        information from the database.
+    cache : `DimensionRecordCache` | None
+        Cache containing already-known dimension records.  May be `None` if a
+        cache is not available.
+
+    Returns
+    -------
+    expanded : `list` [ `DataCoordinate` ]
+        List of `DataCoordinate` instances in the same order as the input
+        values.  It is guaranteed that each `DataCoordinate` has
+        ``hasRecords()=True`` and ``hasFull()=True``.
+    """
+    output = list(data_ids)
+
+    grouped_by_dimensions: defaultdict[DimensionGroup, list[int]] = defaultdict(list)
+    for i, data_id in enumerate(data_ids):
+        if not data_id.hasRecords():
+            grouped_by_dimensions[data_id.dimensions].append(i)
+
+    if not grouped_by_dimensions:
+        # All given DataCoordinate values are already expanded.
+        return output
+
+    attacher = DimensionDataAttacher(
+        cache=cache,
+        dimensions=DimensionGroup.union(*grouped_by_dimensions.keys(), universe=universe),
+    )
+    for dimensions, indexes in grouped_by_dimensions.items():
+        with query_func() as query:
+            expanded = attacher.attach(dimensions, (output[index] for index in indexes), query)
+            for index, data_id in zip(indexes, expanded):
+                output[index] = data_id
+
+    return output

{lsst_daf_butler-30.2026.100 → lsst_daf_butler-30.2026.300}/python/lsst/daf/butler/registry/sql_registry.py

@@ -34,7 +34,6 @@ __all__ = ("SqlRegistry",)
 import contextlib
 import logging
 import warnings
-from collections import defaultdict
 from collections.abc import Iterable, Iterator, Mapping, Sequence
 from typing import TYPE_CHECKING, Any
 
@@ -54,7 +53,6 @@ from ..dimensions import (
     DataCoordinate,
     DataId,
     DimensionConfig,
-    DimensionDataAttacher,
     DimensionElement,
     DimensionGroup,
     DimensionRecord,
@@ -78,6 +76,7 @@ from ..registry.interfaces import ChainedCollectionRecord, ReadOnlyDatabaseError
 from ..registry.managers import RegistryManagerInstances, RegistryManagerTypes
 from ..registry.wildcards import CollectionWildcard, DatasetTypeWildcard
 from ..utils import transactional
+from .expand_data_ids import expand_data_ids
 
 if TYPE_CHECKING:
     from .._butler_config import ButlerConfig
@@ -1415,28 +1414,7 @@ class SqlRegistry:
         return DataCoordinate.standardize(keys, dimensions=standardized.dimensions).expanded(records=records)
 
     def expand_data_ids(self, data_ids: Iterable[DataCoordinate]) -> list[DataCoordinate]:
-        output = list(data_ids)
-
-        grouped_by_dimensions: defaultdict[DimensionGroup, list[int]] = defaultdict(list)
-        for i, data_id in enumerate(data_ids):
-            if not data_id.hasRecords():
-                grouped_by_dimensions[data_id.dimensions].append(i)
-
-        if not grouped_by_dimensions:
-            # All given DataCoordinate values are already expanded.
-            return output
-
-        attacher = DimensionDataAttacher(
-            cache=self.dimension_record_cache,
-            dimensions=DimensionGroup.union(*grouped_by_dimensions.keys(), universe=self.dimensions),
-        )
-        with self._query() as query:
-            for dimensions, indexes in grouped_by_dimensions.items():
-                expanded = attacher.attach(dimensions, (output[index] for index in indexes), query)
-                for index, data_id in zip(indexes, expanded):
-                    output[index] = data_id
-
-        return output
+        return expand_data_ids(data_ids, self.dimensions, self._query, self.dimension_record_cache)
 
     def expand_refs(self, dataset_refs: list[DatasetRef]) -> list[DatasetRef]:
         expanded_ids = self.expand_data_ids([ref.dataId for ref in dataset_refs])

{lsst_daf_butler-30.2026.100 → lsst_daf_butler-30.2026.300}/python/lsst/daf/butler/remote_butler/_remote_butler.py

@@ -65,6 +65,7 @@ from ..dimensions import DataCoordinate, DataIdValue, DimensionConfig, Dimension
 from ..queries import Query
 from ..queries.tree import make_column_literal
 from ..registry import CollectionArgType, NoDefaultCollectionError, Registry, RegistryDefaults
+from ..registry.expand_data_ids import expand_data_ids
 from ._collection_args import convert_collection_arg_to_glob_string_list
 from ._defaults import DefaultsHolder
 from ._get import convert_http_url_to_resource_path, get_dataset_as_python_object
@@ -633,7 +634,7 @@ class RemoteButler(Butler):  # numpydoc ignore=PR02
         raise NotImplementedError()
 
     def transfer_dimension_records_from(
-        self, source_butler: LimitedButler | Butler, source_refs: Iterable[DatasetRef]
+        self, source_butler: LimitedButler | Butler, source_refs: Iterable[DatasetRef | DataCoordinate]
     ) -> None:
         # Docstring inherited.
         raise NotImplementedError()
@@ -738,6 +739,9 @@ class RemoteButler(Butler):  # numpydoc ignore=PR02
     def close(self) -> None:
         pass
 
+    def _expand_data_ids(self, data_ids: Iterable[DataCoordinate]) -> list[DataCoordinate]:
+        return expand_data_ids(data_ids, self.dimensions, self.query, None)
+
     @property
     def _file_transfer_source(self) -> RemoteFileTransferSource:
         return RemoteFileTransferSource(self._connection)

{lsst_daf_butler-30.2026.100 → lsst_daf_butler-30.2026.300}/python/lsst/daf/butler/tests/hybrid_butler.py

@@ -338,7 +338,7 @@ class HybridButler(Butler):
         )
 
     def transfer_dimension_records_from(
-        self, source_butler: LimitedButler | Butler, source_refs: Iterable[DatasetRef]
+        self, source_butler: LimitedButler | Butler, source_refs: Iterable[DatasetRef | DataCoordinate]
     ) -> None:
         return self._direct_butler.transfer_dimension_records_from(source_butler, source_refs)
 
@@ -425,6 +425,9 @@ class HybridButler(Butler):
             source_butler, data_ids, allowed_elements
         )
 
+    def _expand_data_ids(self, data_ids: Iterable[DataCoordinate]) -> list[DataCoordinate]:
+        return self._remote_butler._expand_data_ids(data_ids)
+
     @property
     def collection_chains(self) -> ButlerCollections:
         return HybridButlerCollections(self)