lsst-daf-butler 29.2025.4100__tar.gz → 29.2025.4200__tar.gz

{lsst_daf_butler-29.2025.4100/python/lsst_daf_butler.egg-info → lsst_daf_butler-29.2025.4200}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-daf-butler
-Version: 29.2025.4100
+Version: 29.2025.4200
 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-29.2025.4100 → lsst_daf_butler-29.2025.4200}/python/lsst/daf/butler/_dataset_association.py

@@ -29,15 +29,17 @@ from __future__ import annotations
 
 __all__ = ("DatasetAssociation",)
 
-from collections.abc import Iterator
+from collections.abc import Iterator, Mapping
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
+from ._collection_type import CollectionType
 from ._dataset_ref import DatasetRef
 from ._dataset_type import DatasetType
 from ._timespan import Timespan
 
 if TYPE_CHECKING:
+    from ._butler_collections import CollectionInfo
     from .queries._general_query_results import GeneralQueryResults
 
 
@@ -66,7 +68,10 @@ class DatasetAssociation:
 
     @classmethod
     def from_query_result(
-        cls, result: GeneralQueryResults, dataset_type: DatasetType
+        cls,
+        result: GeneralQueryResults,
+        dataset_type: DatasetType,
+        collection_info: Mapping[str, CollectionInfo],
     ) -> Iterator[DatasetAssociation]:
         """Construct dataset associations from the result of general query.
 
@@ -79,11 +84,22 @@ class DatasetAssociation:
             "timespan" dataset fields for ``dataset_type``.
         dataset_type : `DatasetType`
             Dataset type, query has to include this dataset type.
+        collection_info : `~collections.abc.Mapping` [`str`, `CollectionInfo`]
+            Mapping from collection name to information about it for all
+            collections that may appear in the query results.
         """
         timespan_key = f"{dataset_type.name}.timespan"
         collection_key = f"{dataset_type.name}.collection"
         for _, refs, row_dict in result.iter_tuples(dataset_type):
-            yield DatasetAssociation(refs[0], row_dict[collection_key], row_dict[timespan_key])
+            collection = row_dict[collection_key]
+            timespan = row_dict[timespan_key]
+            if collection_info[collection].type is not CollectionType.CALIBRATION:
+                # This behavior is for backwards compatibility only; in most
+                # contexts it makes sense to consider the timespan of a RUN
+                # or TAGGED collection to be unbounded, not None, and that's
+                # what the query results we're iterating over do.
+                timespan = None
+            yield DatasetAssociation(refs[0], collection, timespan)
 
     def __lt__(self, other: Any) -> bool:
         # Allow sorting of associations

{lsst_daf_butler-29.2025.4100 → lsst_daf_butler-29.2025.4200}/python/lsst/daf/butler/_registry_shim.py

@@ -36,6 +36,7 @@ from typing import TYPE_CHECKING, Any
 from ._collection_type import CollectionType
 from ._dataset_ref import DatasetId, DatasetIdGenEnum, DatasetRef
 from ._dataset_type import DatasetType
+from ._exceptions import CalibrationLookupError
 from ._storage_class import StorageClassFactory
 from ._timespan import Timespan
 from .dimensions import (
@@ -48,7 +49,9 @@ from .dimensions import (
 )
 from .registry._collection_summary import CollectionSummary
 from .registry._defaults import RegistryDefaults
+from .registry._exceptions import NoDefaultCollectionError
 from .registry._registry_base import RegistryBase
+from .registry.queries._query_common import resolve_collections
 
 if TYPE_CHECKING:
     from .direct_butler import DirectButler
@@ -182,13 +185,76 @@ class RegistryShim(RegistryBase):
         *,
         collections: CollectionArgType | None = None,
         timespan: Timespan | None = None,
+        datastore_records: bool = False,
         **kwargs: Any,
     ) -> DatasetRef | None:
         # Docstring inherited from a base class.
-        return self._registry.findDataset(
-            datasetType, dataId, collections=collections, timespan=timespan, **kwargs
+        if not isinstance(datasetType, DatasetType):
+            datasetType = self.getDatasetType(datasetType)
+
+        dataId = DataCoordinate.standardize(
+            dataId,
+            dimensions=datasetType.dimensions,
+            universe=self.dimensions,
+            defaults=self.defaults.dataId,
+            **kwargs,
         )
 
+        with self._butler.query() as query:
+            resolved_collections = resolve_collections(self._butler, collections)
+            if not resolved_collections:
+                if collections is None:
+                    raise NoDefaultCollectionError("No collections provided, and no default collections set")
+                else:
+                    return None
+
+            if datasetType.isCalibration() and timespan is None:
+                # Filter out calibration collections, because with no timespan
+                # we have no way of selecting a dataset from them.
+                collection_info = self._butler.collections.query_info(
+                    resolved_collections, flatten_chains=True
+                )
+                resolved_collections = [
+                    info.name for info in collection_info if info.type != CollectionType.CALIBRATION
+                ]
+                if not resolved_collections:
+                    return None
+
+            result = query.datasets(datasetType, resolved_collections, find_first=True).limit(2)
+            dataset_type_name = result.dataset_type.name
+            # Search only on the 'required' dimensions for the dataset type.
+            # Any extra values provided by the user are ignored.
+            minimal_data_id = DataCoordinate.standardize(
+                dataId.subset(datasetType.dimensions.required).required, universe=self.dimensions
+            )
+            result = result.where(minimal_data_id)
+            if (
+                datasetType.isCalibration()
+                and timespan is not None
+                and (timespan.begin is not None or timespan.end is not None)
+            ):
+                timespan_column = query.expression_factory[dataset_type_name].timespan
+                result = result.where(timespan_column.overlaps(timespan))
+
+            datasets = list(result)
+            if len(datasets) == 1:
+                ref = datasets[0]
+                if dataId.hasRecords():
+                    ref = ref.expanded(dataId)
+                # Propagate storage class from user-provided DatasetType, which
+                # may not match the definition in the database.
+                ref = ref.overrideStorageClass(datasetType.storageClass_name)
+                if datastore_records:
+                    ref = self._registry.get_datastore_records(ref)
+                return ref
+            elif len(datasets) == 0:
+                return None
+            else:
+                raise CalibrationLookupError(
+                    f"Ambiguous calibration lookup for {datasetType} with timespan {timespan}"
+                    f" in collections {resolved_collections}."
+                )
+
     def insertDatasets(
         self,
         datasetType: DatasetType | str,

{lsst_daf_butler-29.2025.4100 → lsst_daf_butler-29.2025.4200}/python/lsst/daf/butler/cli/cmd/_remove_collections.py

@@ -41,6 +41,8 @@ from ..utils import ButlerCommand
 noNonRunCollectionsMsg = "No non-RUN collections were found."
 willRemoveCollectionMsg = "The following collections will be removed:"
 removedCollectionsMsg = "Removed collections"
+willRemoveCollectionChainsMsg = "Collections to be removed from their parent collection chains:"
+removedCollectionChainsMsg = "Removed collections from their parent collection chains:"
 canNotRemoveFoundRuns = "The following RUN collections were found but can NOT be removed by this command:"
 didNotRemoveFoundRuns = "Found RUN collections but they can NOT be removed by this command:"
 abortedMsg = "Aborted."
@@ -53,6 +55,11 @@ abortedMsg = "Aborted."
 )
 @confirm_option()
 @options_file_option()
+@click.option(
+    "--remove-from-parents",
+    is_flag=True,
+    help="Forcibly remove the collection even if it is still referenced from collection chains.",
+)
 def remove_collections(**kwargs: Any) -> None:  # numpydoc ignore=PR01
     """Remove one or more non-RUN collections.
 
@@ -73,6 +80,10 @@ def remove_collections(**kwargs: Any) -> None:  # numpydoc ignore=PR01
             result.removeCollectionsTable.pprint_all(align="<")
         else:
             print("\n" + noNonRunCollectionsMsg)
+        if len(result.removeChainsTable):
+            print("\n" + willRemoveCollectionChainsMsg)
+            result.removeChainsTable.pprint_all(align="<")
+            print()
         if len(result.runsTable):
             print("\n" + canNotRemoveFoundRuns)
             result.runsTable.pprint_all(align="<")
@@ -86,6 +97,10 @@ def remove_collections(**kwargs: Any) -> None:  # numpydoc ignore=PR01
         else:
             print("\n" + removedCollectionsMsg + ":\n")
             result.removeCollectionsTable.pprint_all(align="<")
+            if len(result.removeChainsTable):
+                print("\n" + removedCollectionChainsMsg)
+                result.removeChainsTable.pprint_all(align="<")
+                print()
             if len(result.runsTable):
                 print("\n" + didNotRemoveFoundRuns)
                 result.runsTable.pprint_all(align="<")

{lsst_daf_butler-29.2025.4100 → lsst_daf_butler-29.2025.4200}/python/lsst/daf/butler/direct_butler/_direct_butler.py

@@ -1302,7 +1302,7 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
 
         data_id, kwargs = self._rewrite_data_id(data_id, parent_type, **kwargs)
 
-        ref = self._registry.findDataset(
+        ref = self.registry.findDataset(
             parent_type,
             data_id,
             collections=collections,

{lsst_daf_butler-29.2025.4100 → lsst_daf_butler-29.2025.4200}/python/lsst/daf/butler/queries/_expression_strings.py

@@ -241,7 +241,7 @@ class _ConversionVisitor(TreeVisitor[_VisitorResult]):
 
     def visitBind(self, name: str, node: Node) -> _VisitorResult:
         if name not in self.context.bind:
-            raise InvalidQueryError("Name {name!r} is not in the bind map.")
+            raise InvalidQueryError(f"Name {name!r} is not in the bind map.")
         # Logic in visitIdentifier handles binds.
         return self.visitIdentifier(name, node)
 

{lsst_daf_butler-29.2025.4100 → lsst_daf_butler-29.2025.4200}/python/lsst/daf/butler/registry/_registry_base.py

@@ -231,20 +231,28 @@ class RegistryBase(Registry):
         collectionTypes: Iterable[CollectionType] = CollectionType.all(),
         flattenChains: bool = False,
     ) -> Iterator[DatasetAssociation]:
-        # queryCollections only accepts DatasetType.
         if isinstance(datasetType, str):
             datasetType = self.getDatasetType(datasetType)
-        resolved_collections = self.queryCollections(
-            collections, datasetType=datasetType, collectionTypes=collectionTypes, flattenChains=flattenChains
-        )
         with self._butler.query() as query:
+            resolved_collections = self.queryCollections(
+                collections,
+                datasetType=datasetType,
+                collectionTypes=collectionTypes,
+                flattenChains=flattenChains,
+            )
+            # It's annoyingly difficult to just do the collection query once,
+            # since query_info doesn't accept all the expression types that
+            # queryCollections does.  But it's all cached anyway.
+            collection_info = {
+                info.name: info for info in self._butler.collections.query_info(resolved_collections)
+            }
             query = query.join_dataset_search(datasetType, resolved_collections)
             result = query.general(
                 datasetType.dimensions,
                 dataset_fields={datasetType.name: {"dataset_id", "run", "collection", "timespan"}},
                 find_first=False,
             )
-            yield from DatasetAssociation.from_query_result(result, datasetType)
+            yield from DatasetAssociation.from_query_result(result, datasetType, collection_info)
 
     def _resolve_dataset_types(self, dataset_types: object | None) -> list[str]:
         if dataset_types is None:

{lsst_daf_butler-29.2025.4100 → lsst_daf_butler-29.2025.4200}/python/lsst/daf/butler/registry/datasets/byDimensions/_manager.py

@@ -1425,7 +1425,7 @@ class ByDimensionsDatasetRecordStorageManagerUUID(DatasetRecordStorageManager):
             )
             if "timespan" in fields:
                 tags_builder.joins.timespans[fields_key] = self._db.getTimespanRepresentation().fromLiteral(
-                    None
+                    Timespan(None, None)
                 )
         calibs_builder: SqlSelectBuilder | None = None
         if CollectionType.CALIBRATION in collection_types:

{lsst_daf_butler-29.2025.4100 → lsst_daf_butler-29.2025.4200}/python/lsst/daf/butler/registry/sql_registry.py

@@ -36,7 +36,7 @@ import logging
 import warnings
 from collections import defaultdict
 from collections.abc import Iterable, Iterator, Mapping, Sequence
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 import sqlalchemy
 
@@ -44,16 +44,10 @@ from lsst.resources import ResourcePathExpression
 from lsst.utils.iteration import ensure_iterable
 
 from .._collection_type import CollectionType
-from .._column_tags import DatasetColumnTag
 from .._config import Config
 from .._dataset_ref import DatasetId, DatasetIdGenEnum, DatasetRef
 from .._dataset_type import DatasetType
-from .._exceptions import (
-    CalibrationLookupError,
-    DataIdValueError,
-    DimensionNameError,
-    InconsistentDataIdError,
-)
+from .._exceptions import DataIdValueError, DimensionNameError, InconsistentDataIdError
 from .._storage_class import StorageClassFactory
 from .._timespan import Timespan
 from ..dimensions import (
@@ -90,7 +84,6 @@ if TYPE_CHECKING:
     from .._butler_config import ButlerConfig
     from ..datastore._datastore import DatastoreOpaqueTable
     from ..datastore.stored_file_info import StoredDatastoreItemInfo
-    from ..registry._registry import CollectionArgType
     from ..registry.interfaces import (
         CollectionRecord,
         Database,
@@ -830,169 +823,6 @@ class SqlRegistry:
         """
         return True
 
-    def findDataset(
-        self,
-        datasetType: DatasetType | str,
-        dataId: DataId | None = None,
-        *,
-        collections: CollectionArgType | None = None,
-        timespan: Timespan | None = None,
-        datastore_records: bool = False,
-        **kwargs: Any,
-    ) -> DatasetRef | None:
-        """Find a dataset given its `DatasetType` and data ID.
-
-        This can be used to obtain a `DatasetRef` that permits the dataset to
-        be read from a `Datastore`. If the dataset is a component and can not
-        be found using the provided dataset type, a dataset ref for the parent
-        will be returned instead but with the correct dataset type.
-
-        Parameters
-        ----------
-        datasetType : `DatasetType` or `str`
-            A `DatasetType` or the name of one.  If this is a `DatasetType`
-            instance, its storage class will be respected and propagated to
-            the output, even if it differs from the dataset type definition
-            in the registry, as long as the storage classes are convertible.
-        dataId : `dict` or `DataCoordinate`, optional
-            A `dict`-like object containing the `Dimension` links that identify
-            the dataset within a collection.
-        collections : collection expression, optional
-            An expression that fully or partially identifies the collections to
-            search for the dataset; see
-            :ref:`daf_butler_collection_expressions` for more information.
-            Defaults to ``self.defaults.collections``.
-        timespan : `Timespan`, optional
-            A timespan that the validity range of the dataset must overlap.
-            If not provided, any `~CollectionType.CALIBRATION` collections
-            matched by the ``collections`` argument will not be searched.
-        datastore_records : `bool`, optional
-            Whether to attach datastore records to the `DatasetRef`.
-        **kwargs
-            Additional keyword arguments passed to
-            `DataCoordinate.standardize` to convert ``dataId`` to a true
-            `DataCoordinate` or augment an existing one.
-
-        Returns
-        -------
-        ref : `DatasetRef`
-            A reference to the dataset, or `None` if no matching Dataset
-            was found.
-
-        Raises
-        ------
-        lsst.daf.butler.registry.NoDefaultCollectionError
-            Raised if ``collections`` is `None` and
-            ``self.defaults.collections`` is `None`.
-        LookupError
-            Raised if one or more data ID keys are missing.
-        lsst.daf.butler.registry.MissingDatasetTypeError
-            Raised if the dataset type does not exist.
-        lsst.daf.butler.registry.MissingCollectionError
-            Raised if any of ``collections`` does not exist in the registry.
-
-        Notes
-        -----
-        This method simply returns `None` and does not raise an exception even
-        when the set of collections searched is intrinsically incompatible with
-        the dataset type, e.g. if ``datasetType.isCalibration() is False``, but
-        only `~CollectionType.CALIBRATION` collections are being searched.
-        This may make it harder to debug some lookup failures, but the behavior
-        is intentional; we consider it more important that failed searches are
-        reported consistently, regardless of the reason, and that adding
-        additional collections that do not contain a match to the search path
-        never changes the behavior.
-
-        This method handles component dataset types automatically, though most
-        other registry operations do not.
-        """
-        if collections is None:
-            if not self.defaults.collections:
-                raise NoDefaultCollectionError(
-                    "No collections provided to findDataset, and no defaults from registry construction."
-                )
-            collections = self.defaults.collections
-        backend = queries.SqlQueryBackend(self._db, self._managers, self.dimension_record_cache)
-        with backend.caching_context():
-            collection_wildcard = CollectionWildcard.from_expression(collections, require_ordered=True)
-            if collection_wildcard.empty():
-                return None
-            matched_collections = backend.resolve_collection_wildcard(collection_wildcard)
-            resolved_dataset_type = backend.resolve_single_dataset_type_wildcard(datasetType)
-            dataId = DataCoordinate.standardize(
-                dataId,
-                dimensions=resolved_dataset_type.dimensions,
-                universe=self.dimensions,
-                defaults=self.defaults.dataId,
-                **kwargs,
-            )
-            governor_constraints = {name: {cast(str, dataId[name])} for name in dataId.dimensions.governors}
-            (filtered_collections,) = backend.filter_dataset_collections(
-                [resolved_dataset_type],
-                matched_collections,
-                governor_constraints=governor_constraints,
-            ).values()
-            if not filtered_collections:
-                return None
-            if timespan is None:
-                filtered_collections = [
-                    collection_record
-                    for collection_record in filtered_collections
-                    if collection_record.type is not CollectionType.CALIBRATION
-                ]
-            if filtered_collections:
-                requested_columns = {"dataset_id", "run", "collection"}
-                with backend.context() as context:
-                    predicate = context.make_data_coordinate_predicate(
-                        dataId.subset(resolved_dataset_type.dimensions), full=False
-                    )
-                    if timespan is not None:
-                        requested_columns.add("timespan")
-                        predicate = predicate.logical_and(
-                            context.make_timespan_overlap_predicate(
-                                DatasetColumnTag(resolved_dataset_type.name, "timespan"), timespan
-                            )
-                        )
-                    relation = backend.make_dataset_query_relation(
-                        resolved_dataset_type, filtered_collections, requested_columns, context
-                    ).with_rows_satisfying(predicate)
-                    rows = list(context.fetch_iterable(relation))
-            else:
-                rows = []
-            if not rows:
-                return None
-            elif len(rows) == 1:
-                best_row = rows[0]
-            else:
-                rank_by_collection_key = {record.key: n for n, record in enumerate(filtered_collections)}
-                collection_tag = DatasetColumnTag(resolved_dataset_type.name, "collection")
-                row_iter = iter(rows)
-                best_row = next(row_iter)
-                best_rank = rank_by_collection_key[best_row[collection_tag]]
-                have_tie = False
-                for row in row_iter:
-                    if (rank := rank_by_collection_key[row[collection_tag]]) < best_rank:
-                        best_row = row
-                        best_rank = rank
-                        have_tie = False
-                    elif rank == best_rank:
-                        have_tie = True
-                        assert timespan is not None, "Rank ties should be impossible given DB constraints."
-                if have_tie:
-                    raise CalibrationLookupError(
-                        f"Ambiguous calibration lookup for {resolved_dataset_type.name} in collections "
-                        f"{collection_wildcard.strings} with timespan {timespan}."
-                    )
-            reader = queries.DatasetRefReader(
-                resolved_dataset_type,
-                translate_collection=lambda k: self._managers.collections[k].name,
-            )
-            ref = reader.read(best_row, data_id=dataId)
-            if datastore_records:
-                ref = self.get_datastore_records(ref)
-
-            return ref
-
     @transactional
     def insertDatasets(
         self,

{lsst_daf_butler-29.2025.4100 → lsst_daf_butler-29.2025.4200}/python/lsst/daf/butler/registry/tests/_registry.py

@@ -550,6 +550,11 @@ class RegistryTests(ABC):
                 "bias", instrument="Cam1", detector=2, collections=["empty", "imported_r", "imported_g"]
             ),
         )
+        # If the input data ID was an expanded DataCoordinate with records,
+        # then the output ref has records, too.
+        expanded_id = registry.expandDataId({"instrument": "Cam1", "detector": 2})
+        expanded_ref = registry.findDataset("bias", expanded_id, collections=["imported_r"])
+        self.assertTrue(expanded_ref.dataId.hasRecords())
         # Search more than one collection, with one of them a CALIBRATION
         # collection.
         registry.registerCollection("Cam1/calib", CollectionType.CALIBRATION)
@@ -568,6 +573,18 @@ class RegistryTests(ABC):
                 timespan=timespan,
             ),
         )
+        self.assertEqual(
+            bias1,
+            registry.findDataset(
+                "bias",
+                instrument="Cam1",
+                detector=2,
+                # Calibration dataset type, with no calibration collection, but
+                # a timespan was provided.
+                collections=["imported_g"],
+                timespan=timespan,
+            ),
+        )
         self.assertEqual(
             bias2,
             registry.findDataset(
@@ -592,6 +609,82 @@ class RegistryTests(ABC):
                 "bias", instrument="Cam1", detector=2, collections=["empty", "Cam1/calib", "imported_g"]
             ),
         )
+        self.assertIsNone(
+            registry.findDataset("bias", instrument="Cam1", detector=2, collections=["Cam1/calib"])
+        )
+        # Test non-calibration dataset type.
+        registry.registerDatasetType(
+            DatasetType("noncalibration", ["instrument", "detector"], "int", universe=butler.dimensions)
+        )
+        (non_calibration_ref,) = registry.insertDatasets("noncalibration", dataIds=[dataId2], run=run)
+        self.assertIsNone(
+            registry.findDataset("noncalibration", instrument="Cam1", detector=2, collections=["imported_g"])
+        )
+        self.assertEqual(
+            non_calibration_ref,
+            registry.findDataset("noncalibration", instrument="Cam1", detector=2, collections=[run]),
+        )
+        # Timespan parameter is ignored for non-calibration dataset types.
+        self.assertIsNone(
+            registry.findDataset(
+                "noncalibration", instrument="Cam1", detector=2, collections=["imported_g"], timespan=timespan
+            )
+        )
+        self.assertEqual(
+            non_calibration_ref,
+            registry.findDataset(
+                "noncalibration", instrument="Cam1", detector=2, collections=[run], timespan=timespan
+            ),
+        )
+        self.assertEqual(
+            non_calibration_ref,
+            registry.findDataset(
+                "noncalibration",
+                instrument="Cam1",
+                detector=2,
+                collections=["Cam1/calib", run],
+                timespan=timespan,
+            ),
+        )
+        # Add a dataset type whose dimension group involves an "implied"
+        # dimension.  ("physical_filter" implies "band".)
+        registry.registerDatasetType(
+            DatasetType(
+                "dt_with_implied",
+                [
+                    "instrument",
+                    "physical_filter",
+                ],
+                "int",
+                universe=butler.dimensions,
+            )
+        )
+        data_id = {"instrument": "Cam1", "physical_filter": "Cam1-G"}
+        (implied_ref,) = registry.insertDatasets("dt_with_implied", dataIds=[data_id], run=run)
+        found_ref = registry.findDataset("dt_with_implied", data_id, collections=[run])
+        self.assertEqual(implied_ref, found_ref)
+        # The "full" data ID with implied values is looked up, even though we
+        # provided only the "required" values.
+        self.assertTrue(found_ref.dataId.hasFull())
+        # The search ignores excess data ID values beyond the 'required' set.
+        # This is not the correct band value for this physical_filter, but
+        # the mismatch is ignored.
+        self.assertEqual(
+            implied_ref,
+            registry.findDataset(
+                "dt_with_implied",
+                {"instrument": "Cam1", "physical_filter": "Cam1-G", "band": "r"},
+                collections=[run],
+            ),
+        )
+        # Correct band value, wrong physical_filter.
+        self.assertIsNone(
+            registry.findDataset(
+                "dt_with_implied",
+                {"instrument": "Cam1", "physical_filter": "Cam1-R1", "band": "g"},
+                collections=[run],
+            ),
+        )
 
     def testRemoveDatasetTypeSuccess(self):
         """Test that SqlRegistry.removeDatasetType works when there are no

{lsst_daf_butler-29.2025.4100 → lsst_daf_butler-29.2025.4200}/python/lsst/daf/butler/remote_butler/_factory.py

@@ -136,7 +136,7 @@ class RemoteButlerFactory:
         if self._config.authentication == "rubin_science_platform":
             auth = RubinAuthenticationProvider(access_token)
         elif self._config.authentication == "cadc":
-            auth = CadcAuthenticationProvider()
+            auth = CadcAuthenticationProvider(access_token)
         return self._create_butler(
             auth=auth, butler_options=butler_options, enable_datastore_cache=enable_datastore_cache
         )
@@ -151,7 +151,7 @@ class RemoteButlerFactory:
         if self._config.authentication == "rubin_science_platform":
             auth = RubinAuthenticationProvider.create_from_environment(self.server_url)
         elif self._config.authentication == "cadc":
-            auth = CadcAuthenticationProvider()
+            auth = CadcAuthenticationProvider.create_from_environment(self.server_url)
 
         return self._create_butler(
             auth=auth, butler_options=butler_options, enable_datastore_cache=enable_datastore_cache

{lsst_daf_butler-29.2025.4100 → lsst_daf_butler-29.2025.4200}/python/lsst/daf/butler/remote_butler/_remote_butler.py

@@ -60,7 +60,7 @@ from .._storage_class import StorageClass, StorageClassFactory
 from .._utilities.locked_object import LockedObject
 from ..datastore import DatasetRefURIs, DatastoreConfig
 from ..datastore.cache_manager import AbstractDatastoreCacheManager, DatastoreCacheManager
-from ..dimensions import DataIdValue, DimensionConfig, DimensionUniverse, SerializedDataId
+from ..dimensions import DataCoordinate, DataIdValue, DimensionConfig, DimensionUniverse, SerializedDataId
 from ..queries import Query
 from ..queries.tree import make_column_literal
 from ..registry import CollectionArgType, NoDefaultCollectionError, Registry, RegistryDefaults
@@ -435,6 +435,8 @@ class RemoteButler(Butler):  # numpydoc ignore=PR02
             return None
 
         ref = DatasetRef.from_simple(model.dataset_ref, universe=self.dimensions)
+        if isinstance(data_id, DataCoordinate) and data_id.hasRecords():
+            ref = ref.expanded(data_id)
         return apply_storage_class_override(ref, dataset_type, storage_class)
 
     def _retrieve_artifacts(