lsst-daf-butler 29.2025.4100__py3-none-any.whl → 29.2025.4200__py3-none-any.whl

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/_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/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/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/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/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/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/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/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/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/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(

lsst/daf/butler/remote_butler/authentication/cadc.py

@@ -27,28 +27,80 @@
 
 from __future__ import annotations
 
+import os
+from fnmatch import fnmatchcase
+from urllib.parse import urlparse
+
 from .interface import RemoteButlerAuthenticationProvider
 
 
 class CadcAuthenticationProvider(RemoteButlerAuthenticationProvider):
-    """Provide HTTP headers required for authenticating the user at the
-    Canadian Astronomy Data Centre.
+    """
+    Represents an authentication provider for remote Butler services specific
+    to CADC connection requirements.
+
+    This class handles the creation and management of authentication headers
+    required for interaction with remote Butler services by handling bearer
+    tokens. It ensures that the object is pickleable as it may need to be
+    serialized and transferred between processes for file transfer operations.
+
+    Parameters
+    ----------
+    access_token : `str`
+        The bearer token used for authentication with CADC StorageInventory.
     """
 
     # NOTE -- This object needs to be pickleable. It will sometimes be
     # serialized and transferred to another process to execute file transfers.
 
-    def __init__(self) -> None:
-        # TODO: Load authentication information somehow
-        pass
+    def __init__(self, access_token: str):
+        # Access tokens are opaque bearer tokens. See https://sqr-069.lsst.io/
+        self._headers = {"Authorization": f"Bearer {access_token}"}
+
+    @staticmethod
+    def create_from_environment(server_url: str) -> CadcAuthenticationProvider:
+        access_token = _get_authentication_token_from_environment(server_url)
+        if access_token is None:
+            raise RuntimeError(
+                "Attempting to connect to Butler server,"
+                " but no access credentials were found in the environment."
+            )
+        return CadcAuthenticationProvider(access_token)
 
     def get_server_headers(self) -> dict[str, str]:
-        # TODO: I think you mentioned that you might not require
-        # authentication for the Butler server REST API initially --
-        # if so, you can leave this blank.
         return {}
 
     def get_datastore_headers(self) -> dict[str, str]:
-        # TODO: Supply the headers needed to access the Storage Inventory
-        # system.
-        return {"Authorization": "Bearer stub"}
+        return self._headers
+
+
+_SERVER_WHITELIST = ["*.cadc-ccda.hia-hia.nrc-cnrc.gc.ca", "*.canfar.net", "host.docker.internal"]
+_CADC_TOKEN_ENVIRONMENT_KEY = "CADC_TOKEN"
+
+
+def _get_authentication_token_from_environment(server_url: str) -> str | None:
+    """
+    Retrieve an authentication token from the environment.
+
+    This function checks if the provided server URL's hostname matches any
+    pattern in the server whitelist and if a valid token is available in
+    the environment variable. If both conditions are satisfied, the token is
+    returned; otherwise, None is returned.
+
+    Parameters
+    ----------
+        server_url (str): The URL of the server for which an authentication
+            token is being retrieved.
+
+    Returns
+    -------
+        str | None: The authentication token if available and hostname matches
+        the whitelist; otherwise, None.
+    """
+    hostname = urlparse(server_url.lower()).hostname
+    hostname_in_whitelist = any(hostname and fnmatchcase(hostname, pattern) for pattern in _SERVER_WHITELIST)
+    notebook_token = os.getenv(_CADC_TOKEN_ENVIRONMENT_KEY)
+    if hostname_in_whitelist and notebook_token:
+        return notebook_token
+
+    return None

lsst/daf/butler/script/removeCollections.py

@@ -34,7 +34,7 @@ from astropy.table import Table
 
 from .._butler import Butler
 from .._collection_type import CollectionType
-from ..registry import MissingCollectionError
+from ..registry import MissingCollectionError, OrphanedRecordError
 
 
 @dataclass
@@ -49,6 +49,9 @@ class RemoveCollectionResult:
     onConfirmation: Callable[[], None]
     # astropy table describing data that will be removed.
     removeCollectionsTable: Table
+    # astropy table describing collection chain references that will be
+    # removed.
+    removeChainsTable: Table
     # astropy table describing any run collections that will NOT be removed.
     runsTable: Table
 
@@ -61,12 +64,13 @@ class CollectionInfo:
 
     nonRunCollections: Table
     runCollections: Table
+    parentCollections: dict[str, tuple[str, ...]]
+    """Mapping from child collection name to the list of chained collections
+    names that contain it.
+    """
 
 
-def _getCollectionInfo(
-    repo: str,
-    collection: str,
-) -> CollectionInfo:
+def _getCollectionInfo(repo: str, collection: str, include_parents: bool) -> CollectionInfo:
     """Get the names and types of collections that match the collection
     string.
 
@@ -77,6 +81,9 @@ def _getCollectionInfo(
     collection : `str`
         The collection string to search for. Same as the `expression`
         argument to `registry.queryCollections`.
+    include_parents : `bool`
+        If `True`, will fetch the list of parent chained collections containing
+        the given collections.
 
     Returns
     -------
@@ -85,25 +92,27 @@ def _getCollectionInfo(
     """
     butler = Butler.from_config(repo, without_datastore=True)
     try:
-        collections_info = sorted(butler.collections.query_info(collection, include_chains=True))
+        collections_info = sorted(
+            butler.collections.query_info(collection, include_chains=True, include_parents=include_parents)
+        )
     except MissingCollectionError:
         # Hide the error and act like no collections should be removed.
         collections_info = []
     collections = Table(names=("Collection", "Collection Type"), dtype=(str, str))
     runCollections = Table(names=("Collection",), dtype=(str,))
+    parents: dict[str, tuple[str, ...]] = {}
     for collection_info in collections_info:
         if collection_info.type == CollectionType.RUN:
             runCollections.add_row((collection_info.name,))
         else:
             collections.add_row((collection_info.name, collection_info.type.name))
+            if include_parents and collection_info.parents is not None and len(collection_info.parents) > 0:
+                parents[collection_info.name] = tuple(collection_info.parents)
 
-    return CollectionInfo(collections, runCollections)
+    return CollectionInfo(collections, runCollections, parents)
 
 
-def removeCollections(
-    repo: str,
-    collection: str,
-) -> Table:
+def removeCollections(repo: str, collection: str, remove_from_parents: bool) -> RemoveCollectionResult:
     """Remove collections.
 
     Parameters
@@ -112,6 +121,10 @@ def removeCollections(
         Same as the ``config`` argument to ``Butler.__init__``.
     collection : `str`
         Same as the ``name`` argument to ``Registry.removeCollection``.
+    remove_from_parents : `bool`
+        If `True`, will remove the given collections from any chained
+        collections they belong to before removing the collection
+        itself.
 
     Returns
     -------
@@ -119,17 +132,37 @@ def removeCollections(
         Contains tables describing what will be removed, and
         run collections that *will not* be removed.
     """
-    collectionInfo = _getCollectionInfo(repo, collection)
+    collectionInfo = _getCollectionInfo(repo, collection, remove_from_parents)
 
     def _doRemove(collections: Table) -> None:
         """Perform the prune collection step."""
         butler = Butler.from_config(repo, writeable=True, without_datastore=True)
+
         for name in collections["Collection"]:
-            butler.collections.x_remove(name)
+            with butler.transaction():
+                for parent in collectionInfo.parentCollections.get(name, []):
+                    butler.collections.remove_from_chain(parent, name)
+                try:
+                    butler.collections.x_remove(name)
+                except OrphanedRecordError as e:
+                    e.add_note(
+                        "Add the --remove-from-parents flag to this command"
+                        " if you are sure this collection is no longer needed."
+                    )
+                    raise
+
+    remove_chains_table = Table(names=("Child Collection", "Parent Collection"), dtype=(str, str))
+    for child in sorted(collectionInfo.parentCollections.keys()):
+        parents = collectionInfo.parentCollections[child]
+        key = child
+        for parent in sorted(parents):
+            remove_chains_table.add_row((key, parent))
+            key = ""
 
     result = RemoveCollectionResult(
         onConfirmation=partial(_doRemove, collectionInfo.nonRunCollections),
         removeCollectionsTable=collectionInfo.nonRunCollections,
         runsTable=collectionInfo.runCollections,
+        removeChainsTable=remove_chains_table,
     )
     return result

lsst/daf/butler/tests/butler_queries.py

@@ -517,7 +517,13 @@ class ButlerQueryTests(ABC, TestCaseMixin):
             )
             self.assertEqual(
                 {row_tuple.raw_row["flat.timespan"] for row_tuple in row_tuples},
-                {Timespan(t1, t2), Timespan(t2, t3), Timespan(t3, None), Timespan.makeEmpty(), None},
+                {
+                    Timespan(t1, t2),
+                    Timespan(t2, t3),
+                    Timespan(t3, None),
+                    Timespan.makeEmpty(),
+                    Timespan(None, None),
+                },
             )
 
         dimensions = butler.dimensions["detector"].minimal_group
@@ -2101,6 +2107,39 @@ class ButlerQueryTests(ABC, TestCaseMixin):
                     (DataCoordinate.standardize(base_data_id, detector=3, exposure=3), bias3b),
                 ],
             )
+        # Query with an explicit timespan, but no calibration collections.
+        # This should succeed because the timespan for the dataset_tags tables
+        # are logically unbounded, not Null.
+        with butler.query() as query:
+            timespan_column = query.expression_factory["bias"].timespan
+            result = (
+                query.datasets("bias", collections=["imported_g"])
+                .where(instrument="Cam1", detector=2)
+                .where(
+                    timespan_column.overlaps(
+                        Timespan(begin=t1, end=t2),
+                    )
+                )
+            )
+            refs = list(result)
+            self.assertEqual([ref.id for ref in refs], [bias2a.id])
+
+        # Query with an explicit timespan and a RUN collection ahead of
+        # a CALIBRATION collection that would also match; the RUN collection
+        # should win.
+        with butler.query() as query:
+            timespan_column = query.expression_factory["bias"].timespan
+            result = (
+                query.datasets("bias", collections=["imported_g", collection])
+                .where(instrument="Cam1", detector=2)
+                .where(
+                    timespan_column.overlaps(
+                        Timespan(begin=t1, end=t2),
+                    )
+                )
+            )
+            refs = list(result)
+            self.assertEqual([ref.id for ref in refs], [bias2a.id])
 
         # Query in multiple collections, with one of the collections being a
         # calibration collection.  This triggers special cases related to

lsst/daf/butler/tests/server_available.py

@@ -0,0 +1,53 @@
+# 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
+
+__all__ = (
+    "butler_server_import_error",
+    "butler_server_is_available",
+)
+
+butler_server_is_available = True
+"""`True` if all dependencies required to use Butler server and RemoteButler
+are installed.
+"""
+
+butler_server_import_error = ""
+"""String containing a human-readable error message explaining why the server
+is not available, if ``butler_server_is_available`` is `False`.
+"""
+
+try:
+    # Dependencies required by Butler server and RemoteButler, but not
+    # available in LSST Pipelines Stack.
+    import fastapi  # noqa: F401
+    import httpx  # noqa: F401
+    import safir  # noqa: F401
+except ImportError as e:
+    butler_server_is_available = False
+    butler_server_import_error = f"Server libraries could not be loaded: {str(e)}"

lsst/daf/butler/timespan_database_representation.py

@@ -615,6 +615,10 @@ class _CompoundTimespanDatabaseRepresentation(TimespanDatabaseRepresentation):
         # Docstring inherited.
         if isinstance(other, sqlalchemy.sql.ColumnElement):
             return self.contains(other)
+
+        if self._is_null_literal() or other._is_null_literal():
+            return sqlalchemy.sql.null()
+
         return sqlalchemy.sql.and_(self._nsec[1] > other._nsec[0], other._nsec[1] > self._nsec[0])
 
     def contains(
@@ -653,5 +657,9 @@ class _CompoundTimespanDatabaseRepresentation(TimespanDatabaseRepresentation):
             nsec=(func(self._nsec[0]), func(self._nsec[1])), name=self._name
         )
 
+    def _is_null_literal(self) -> bool:
+        null = sqlalchemy.sql.null()
+        return self._nsec[0] is null and self._nsec[1] is null
+
 
 TimespanDatabaseRepresentation.Compound = _CompoundTimespanDatabaseRepresentation

lsst/daf/butler/transfers/_context.py

@@ -354,20 +354,9 @@ class RepoExportContext:
             collectionTypes = {CollectionType.TAGGED}
             if datasetType.isCalibration():
                 collectionTypes.add(CollectionType.CALIBRATION)
-            resolved_collections = self._butler.collections.query(
-                self._collections.keys(),
-                collection_types=collectionTypes,
-                flatten_chains=False,
-            )
-            with self._butler.query() as query:
-                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,
-                )
-                for association in DatasetAssociation.from_query_result(result, datasetType):
-                    if association.ref.id in self._dataset_ids:
-                        results[association.collection].append(association)
-
+            for association in self._butler.registry.queryDatasetAssociations(
+                datasetType, self._collections.keys(), collectionTypes=collectionTypes, flattenChains=False
+            ):
+                if association.ref.id in self._dataset_ids:
+                    results[association.collection].append(association)
         return results

lsst/daf/butler/version.py

@@ -1,2 +1,2 @@
 __all__ = ["__version__"]
-__version__ = "29.2025.4100"
+__version__ = "29.2025.4200"

{lsst_daf_butler-29.2025.4100.dist-info → lsst_daf_butler-29.2025.4200.dist-info}/METADATA

@@ -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.dist-info → lsst_daf_butler-29.2025.4200.dist-info}/RECORD

@@ -13,7 +13,7 @@ lsst/daf/butler/_column_tags.py,sha256=gwYOCYEVybICztwCxkZG3ely9ctK5UCBnn38am_ju
 lsst/daf/butler/_column_type_info.py,sha256=LpF3YmAwIBGqak51M7c-sDaGOWJInk9W3SKni4XGRm8,7163
 lsst/daf/butler/_config.py,sha256=urs7_ngiDXLCEs3ghOvwn7ob612c2O03KxafkRUERQ0,52100
 lsst/daf/butler/_config_support.py,sha256=scAJ8SWJnn0czerfSWX5bXMr0lwIyvKHDk4Pr81spQ0,14135
-lsst/daf/butler/_dataset_association.py,sha256=M1QNdpIc_Nm1cQqdSscYs4txnEwZFSiKqs8_xVE3NVo,3519
+lsst/daf/butler/_dataset_association.py,sha256=8GBIsTMz-XpL1LNiJs8xYIdQ53tmB6yz_m1TmADHxyw,4390
 lsst/daf/butler/_dataset_existence.py,sha256=iGWyQSav0KqyZWCNfug2vWUYYS3My2Br4AAKXtZ-_LU,3570
 lsst/daf/butler/_dataset_provenance.py,sha256=xqNOwVGDMtdPb6xE1cD4lNs9y5-ihLFx5bD8YWqmDs8,19201
 lsst/daf/butler/_dataset_ref.py,sha256=qN-eTAuPKWelt_CESWPucO4d5FC3XOal0EDAR0ZJLkw,40929
@@ -31,7 +31,7 @@ lsst/daf/butler/_named.py,sha256=-AvkTP5JIsCwj5tAmZO8epoRoF1_dGuz2aC0ItLg7-M,195
 lsst/daf/butler/_quantum.py,sha256=xqWk2mHLydf4VWpRTCR74eBjApESuaTb46_iOdLKFDo,25575
 lsst/daf/butler/_quantum_backed.py,sha256=PgrOmnUGvnRUSmwSU-dOzdgTahtmJZHh6gnW5oUnIZA,35583
 lsst/daf/butler/_query_all_datasets.py,sha256=Ev5LHI3Mq9a3XEB9bccX4n70EDQ6OVHhKqeHoThIkz8,7135
-lsst/daf/butler/_registry_shim.py,sha256=H4rhzuLp788LH3izFP7qRd2-D-FwHonH01kQmJNuKak,11730
+lsst/daf/butler/_registry_shim.py,sha256=8SSAXLBL2IAEJe8S9ktjaFZRs-8JaOs57n-rBk94uyQ,14839
 lsst/daf/butler/_standalone_datastore.py,sha256=ImgzPFAeG716zIzhnS-pPFMT0Hil7CxfIx9rELlfmRA,5149
 lsst/daf/butler/_storage_class.py,sha256=p74C-_QjYbcVFm6SdS0RYa_Gjmz9sJJ3JAA98llisdc,32997
 lsst/daf/butler/_storage_class_delegate.py,sha256=0fpDwQILeP0TcXP1W147Va4rX3qZhAyFpFkq6vrf6fo,16324
@@ -52,9 +52,9 @@ lsst/daf/butler/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lsst/daf/butler/pydantic_utils.py,sha256=2B0CfPxL8BHFn0ZXhVhqMGRob6eTSIDW-tQa3fe1jaA,13755
 lsst/daf/butler/repo_relocation.py,sha256=Ivhx2xU4slc53Z6RExhNnquMr2Hx-S8h62emmlXxyy8,3658
 lsst/daf/butler/time_utils.py,sha256=MVTfOFI2xt3IeA46pa-fWY2kJRwSzaQyq1uzeUABcTM,11805
-lsst/daf/butler/timespan_database_representation.py,sha256=MWDusjIQIL2RH1CDpWSW5sYvdHCJKzAfpg1rm1DfgEU,24302
+lsst/daf/butler/timespan_database_representation.py,sha256=rYeQ_vp6gneRjboqV-gvNW0DWhm1QJM-KnVzFTDVZ0I,24550
 lsst/daf/butler/utils.py,sha256=5u50COK5z4u31grOhmQF7mFz55biNLOvSMRdQjEdsjo,5140
-lsst/daf/butler/version.py,sha256=imQpc8l8n1Xj3guWKoFaXrBR3HnAY8jkMITBuZx-5DA,55
+lsst/daf/butler/version.py,sha256=loN_SewEappJtRr1bfMkUAloXYiZtM4w0O03FF5yeZQ,55
 lsst/daf/butler/_rubin/__init__.py,sha256=9z5kmc6LJ3C_iPFV46cvdlQ2qOGJbZh-2Ft5Z-rbE28,1569
 lsst/daf/butler/_rubin/file_datasets.py,sha256=P5_BIhxpVj9qfLuLiI2_dClMHsjO5Qm5oDXVr3WntNU,3607
 lsst/daf/butler/_utilities/__init__.py,sha256=vLzPZYAJ-9r1cnqsP64MVpFgSw2166yOpq0iPMSdAvw,1298
@@ -67,7 +67,7 @@ lsst/daf/butler/cli/cliLog.py,sha256=9W8TVd6Lx0WkKoAU599jZlpDu8ACoikPwdjEndX1_g4
 lsst/daf/butler/cli/progress.py,sha256=doJ0g7HfB1goUFk8H3_tliSchzmieufME0nIpHp4QSA,3600
 lsst/daf/butler/cli/utils.py,sha256=-aKqerxPPpPLf8bggV-9ISQNHbMX3-ZNx3nnIJB5GVA,47578
 lsst/daf/butler/cli/cmd/__init__.py,sha256=LPxSRh0zUcHFuoQSpA5RpUBAhMkQ56Zm64gHbXhI2QI,2358
-lsst/daf/butler/cli/cmd/_remove_collections.py,sha256=pHFXaiw8CJ8hMSsVvnvvpVx7OnFEeOiFNKN7v2sG-EE,3925
+lsst/daf/butler/cli/cmd/_remove_collections.py,sha256=El6Ug1HbcYNaDOvsO6WSH_RutIojHSwMOaX6XO42KDY,4639
 lsst/daf/butler/cli/cmd/_remove_runs.py,sha256=j40vvI8eAadRXtuBKuuLHPERnml_CXPlvmCTx6Y705Q,5756
 lsst/daf/butler/cli/cmd/commands.py,sha256=Co10QOnlMdSrPepaIABLCYaedx7SnsZ91zJTO9iIIUA,31872
 lsst/daf/butler/cli/opt/__init__.py,sha256=VUts6eyMPoxcaKSXv5wD4XISG3Igj625JK3AmSdTBtI,1376
@@ -129,7 +129,7 @@ lsst/daf/butler/dimensions/_universe.py,sha256=HYWtfdxu09aPaZV9AJb6qLvzF0ObVq903
 lsst/daf/butler/dimensions/construction.py,sha256=KKRBO_Nk6QvSMPlWGId0XHJw-EAzogwrWbwk5Yk7F3Q,6905
 lsst/daf/butler/dimensions/record_cache.py,sha256=9BIt4Sag4ERlz95RRxDseyIw17NjopoCPrgRpxi5MCk,3944
 lsst/daf/butler/direct_butler/__init__.py,sha256=8uPQWbFoKDpP2T2fvjV794JUITtdcDH9Zu6ZXq9cRjE,1329
-lsst/daf/butler/direct_butler/_direct_butler.py,sha256=o_Q5us_cPB75Ip4-lFPcmzeGMFdBq458wNmEyDdLCJs,116088
+lsst/daf/butler/direct_butler/_direct_butler.py,sha256=lzT-UcrlxnkqssZFjHdM-OuTMn7rbEBJ8I50OexPJlk,116087
 lsst/daf/butler/direct_butler/_direct_butler_collections.py,sha256=6XvdvYqNSPAwva8vgR1bEqF8vYTfaNXUW3sb03NRwOM,8143
 lsst/daf/butler/direct_query_driver/__init__.py,sha256=hurmYGcTsnlqR4Hkh2xO_M544eEpCGeIJte0GXY3RFQ,1443
 lsst/daf/butler/direct_query_driver/_driver.py,sha256=-6f77noT5M-foo0DanukpARrbKmsKbIkj3vyGhUkm1s,76269
@@ -155,7 +155,7 @@ lsst/daf/butler/queries/_base.py,sha256=lk_xLoN08nmxj0N5aKCm-qI5gWjq8lY3UaLuCWbd
 lsst/daf/butler/queries/_data_coordinate_query_results.py,sha256=S_81y4EkSJw34ekuiHW7RSl0LKNWoV-ZM-C5FLIM-nk,3913
 lsst/daf/butler/queries/_dataset_query_results.py,sha256=SAJsI-KQsEziaNtfu3Zdp0iX4zF2BoDIF4mtb-xvtxQ,5113
 lsst/daf/butler/queries/_dimension_record_query_results.py,sha256=N89s23jBhSMEbr0uxlhMZykiw91O1bLTbdzwv-0Az14,4405
-lsst/daf/butler/queries/_expression_strings.py,sha256=zRgKveojeAeLD-hwwD8qULwgNF27g_XCVK5MdMNfY7w,18486
+lsst/daf/butler/queries/_expression_strings.py,sha256=IDVN2Tcoh6LhfoDlEDvysQ1jF_SDDRxt0vOWwuSm3dQ,18487
 lsst/daf/butler/queries/_general_query_results.py,sha256=Q1-BQFS6V_Uihwdv1t77GOV1M8idZr63WpZMOOmDXT8,9780
 lsst/daf/butler/queries/_identifiers.py,sha256=f_GqZw87IsRsefb2Et0oNormV2t4VMsR9V79gNV7IlU,7913
 lsst/daf/butler/queries/_query.py,sha256=rYWzQyfLPOXvwtSNuug0eKAkD5guoW__aIocRwOPZWg,38830
@@ -183,14 +183,14 @@ lsst/daf/butler/registry/_config.py,sha256=ZFBf7TkRaCiysaaSQMswsPjcNlSyLz9T3fk8H
 lsst/daf/butler/registry/_defaults.py,sha256=PZqgwZbUw4egyWBRSuFbXUPo_U2Xm2X6uWWCDRTOUok,10848
 lsst/daf/butler/registry/_exceptions.py,sha256=R6CN8jRWyiy8uN3UMwSTRS0zTw77MyrE9R61v1M-dBE,3400
 lsst/daf/butler/registry/_registry.py,sha256=OoOT1B5VrxM9XJcjPA2kEhlsFgIW04jjoOQYHWdDI28,59617
-lsst/daf/butler/registry/_registry_base.py,sha256=ED0CyXcNNrhETlOXxALaha3IdqnQHSNvHxOUi8gkLMs,10102
+lsst/daf/butler/registry/_registry_base.py,sha256=z3GY5wU6F_gw_Kc3RkxguZ3_Pc2MIb2biqL3RlLFp7M,10495
 lsst/daf/butler/registry/_registry_factory.py,sha256=meBBGzmXMCp-xCPar1oAzFxLB8FjIKW_wE9Bsic_z4o,5418
 lsst/daf/butler/registry/attributes.py,sha256=YldNjsjVHFAy-pp--hAnRfN3yilnHKGaMfCCxd0Z4o0,5921
 lsst/daf/butler/registry/connectionString.py,sha256=MgZ_jdUAL9_8l7UFeYF0Fhvo6TBdVS1i67I939Kgd3U,5394
 lsst/daf/butler/registry/managers.py,sha256=gal-O39ViqsvrOJNWtFjdtWT2BCUaLYBvzf67blkPp8,21175
 lsst/daf/butler/registry/nameShrinker.py,sha256=7gnlYnRdeYc3XXSfrMnSyQrIZerDYVZeU8x4eppWDXI,1464
 lsst/daf/butler/registry/opaque.py,sha256=xbdOogqabRH3YaevIZ7_hbbTb54rCOGyC7Uq7SZNH-Q,9882
-lsst/daf/butler/registry/sql_registry.py,sha256=aNPHX-z0q3hkQEG4JDIvWSBozm3iU6Qmp1ClDi6YR2Y,78816
+lsst/daf/butler/registry/sql_registry.py,sha256=ORo1-rdAoICSCkhEpz_Sz1_9OnWxMmAJCRfyuGk0-0o,70629
 lsst/daf/butler/registry/versions.py,sha256=egvrctt_1wBzZgh8iSfySaQJQ9bkx_9bUJWkvvDZONQ,9331
 lsst/daf/butler/registry/wildcards.py,sha256=akMGgqDkVM0mQ9RAFENv0IrnoUyMP3mhODYXDaWIQ8o,20277
 lsst/daf/butler/registry/bridge/__init__.py,sha256=vLzPZYAJ-9r1cnqsP64MVpFgSw2166yOpq0iPMSdAvw,1298
@@ -206,7 +206,7 @@ lsst/daf/butler/registry/databases/sqlite.py,sha256=xW82mdbOoOOTBeuSYDQ9DiDPhnMG
 lsst/daf/butler/registry/datasets/__init__.py,sha256=vLzPZYAJ-9r1cnqsP64MVpFgSw2166yOpq0iPMSdAvw,1298
 lsst/daf/butler/registry/datasets/byDimensions/__init__.py,sha256=BG4C7mhKFbCzvfQSI31CIV_iTMc1gYL_LT4Plyu6LdE,1323
 lsst/daf/butler/registry/datasets/byDimensions/_dataset_type_cache.py,sha256=WdbU7ZTAqvpjyouIaKsEEi62P_0Y-zQZjdvzDahKLuw,9653
-lsst/daf/butler/registry/datasets/byDimensions/_manager.py,sha256=oGvCNB27Ahneu-83eDb2Djy3NFcAPhUNUkbollQOPNc,80781
+lsst/daf/butler/registry/datasets/byDimensions/_manager.py,sha256=WUKB2fGnM_zxjxAqRw2HCITmPvCULAd33lA70uIDdKQ,80797
 lsst/daf/butler/registry/datasets/byDimensions/summaries.py,sha256=MuRk2p6fAKhvjId3jWnuFzhqMnKNF31ugExD7a2g48k,18534
 lsst/daf/butler/registry/datasets/byDimensions/tables.py,sha256=40Z-kWTHAZNdxO-PxByidOtpEpTvnAtjsZLgChSI4SU,25537
 lsst/daf/butler/registry/dimensions/__init__.py,sha256=vLzPZYAJ-9r1cnqsP64MVpFgSw2166yOpq0iPMSdAvw,1298
@@ -259,25 +259,25 @@ lsst/daf/butler/registry/queries/expressions/parser/ply/lex.py,sha256=Y9SoJv-_0X
 lsst/daf/butler/registry/queries/expressions/parser/ply/yacc.py,sha256=aGhbTj66OEYILEApQtwyfDunWoAPJ3QWZu6mD8uEB3s,137077
 lsst/daf/butler/registry/tests/__init__.py,sha256=uWJM-8Yv52Ox6e9rKGTaTVRdJc3fIfAyI5WnZQp81EA,1349
 lsst/daf/butler/registry/tests/_database.py,sha256=0lbzjDUj3n2UPvAktiKcc3G1TE0TK867cASezUISN6I,65218
-lsst/daf/butler/registry/tests/_registry.py,sha256=uHdaEz8Wc9mhovN8T7MoHomrzTHiTwt7JjqTNwTjhfg,187719
+lsst/daf/butler/registry/tests/_registry.py,sha256=7s3x64ab6vIv_USJhtxmuaRSxfFDNqzJl1weOoMPneI,191668
 lsst/daf/butler/remote_butler/__init__.py,sha256=Q5TZrGeqEGspRyQYi4X2HX1PtkD7JyHe_metcjaSuAo,1377
 lsst/daf/butler/remote_butler/_collection_args.py,sha256=_ToE6jplUCzmmqwWvkl1cwrXRJkNU8Qrl2hqwIqHibw,4969
 lsst/daf/butler/remote_butler/_config.py,sha256=GIMYT-XW2AeGU0Ej_cHNFxeFzIGN0HqKxCwm_IkBoXM,1825
 lsst/daf/butler/remote_butler/_defaults.py,sha256=lja5yZVZKzzeEQeEkAQwtw0VDTpy5kQfAk5LmGhKlC4,2213
 lsst/daf/butler/remote_butler/_errors.py,sha256=zwXOhYBRkCXX7WMUdYDJTbnX-8cDNI4zBZxVoSY1YBs,1994
-lsst/daf/butler/remote_butler/_factory.py,sha256=IkSYL666XTKsA4IyHO-buOmn6srtFN7WoMyNZm57fmA,6786
+lsst/daf/butler/remote_butler/_factory.py,sha256=C5-PwIXBEhRl5pp9YI2Y9aO6ovz96cU_2p1STY3WXhE,6837
 lsst/daf/butler/remote_butler/_get.py,sha256=1yOJew2bbT8NEtWKvI7iJB4b1BPnijN2LwXckOLGunY,3553
 lsst/daf/butler/remote_butler/_http_connection.py,sha256=k1iCLa1jkfXAVg1FAo2rDwODMPn7HZEpbsdj5JnHC4M,12713
 lsst/daf/butler/remote_butler/_query_driver.py,sha256=ceVyFMcsPrdj_lZVqxCYbHEsv-zw5OjxEETS_s3Mexc,11030
 lsst/daf/butler/remote_butler/_query_results.py,sha256=mPiKb0OYDVL5GbiL-5iVb8JPhqGBNCzMyVrP8O-u1r4,3385
 lsst/daf/butler/remote_butler/_ref_utils.py,sha256=rVesx319JsTPIYCg59ZMT-thHlVrnPAqY0y8CJNo11Y,4958
 lsst/daf/butler/remote_butler/_registry.py,sha256=CXCthpDDxxGO1fHQTjCJOMNwUWvpJweWYe3jdlPbQbM,12914
-lsst/daf/butler/remote_butler/_remote_butler.py,sha256=dr_Rl-7KNyaBAA_Hx04vLQqe9nLn4ERnCRHTiULOzr0,30336
+lsst/daf/butler/remote_butler/_remote_butler.py,sha256=yg-TuWH1P7jRcJBqTbRzVjy6VZbJDVUHxbxxeoQEkn0,30465
 lsst/daf/butler/remote_butler/_remote_butler_collections.py,sha256=ZycaPncojNjzJEyHdPIlt8H7r-IxfJ_ipKWPhLx4Xfo,5561
 lsst/daf/butler/remote_butler/_remote_file_transfer_source.py,sha256=EdHJRFe0LHv7R1eT44ytlROTHXyWSQfT1shrUBVVVMg,4887
 lsst/daf/butler/remote_butler/server_models.py,sha256=CTiyXtSEw8AbmZiPMNs6qCHEkmiv9BRmRbVTWgeUfaA,14463
 lsst/daf/butler/remote_butler/authentication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lsst/daf/butler/remote_butler/authentication/cadc.py,sha256=22U3W_U3CXW2TfLEDxWoTt-CfAfTibVIugnbx8Mq8AY,2278
+lsst/daf/butler/remote_butler/authentication/cadc.py,sha256=5v6aX1I91rTnA6wmdth5fD0W0mOD_1mfV4_iQ1tVKXk,4234
 lsst/daf/butler/remote_butler/authentication/interface.py,sha256=inGPIq7pDLH8HRvlCIHiFGOwTSyNIethrTMDhPUBxYo,2000
 lsst/daf/butler/remote_butler/authentication/rubin.py,sha256=3Aw5M3CVG7uVfmaYgF4vM4aNiqoHcVGdS0_VTgroBx8,4560
 lsst/daf/butler/remote_butler/registry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -314,7 +314,7 @@ lsst/daf/butler/script/queryDatasetTypes.py,sha256=aHXCSgb2UxRh82jAKaVJYUuwC4vrf
 lsst/daf/butler/script/queryDatasets.py,sha256=nMgo_az4lfA7oqu3MKelFtbG8RF9k-9tmz6z-c57jrQ,14153
 lsst/daf/butler/script/queryDimensionRecords.py,sha256=9xjxEvrjycZE63m6v3ZzF0w2J329GIPip2GiqTGhwUs,4899
 lsst/daf/butler/script/register_dataset_type.py,sha256=FYxGYdvceF7_0Tg1ftR2Vr29OJ98snd7AFnqUr7fNk8,3123
-lsst/daf/butler/script/removeCollections.py,sha256=zCNnoiBBxG0_nRR55uQhaKxglRhTM7JL3uJ9lSMdopc,4789
+lsst/daf/butler/script/removeCollections.py,sha256=_RtmblbSUa_lTsDInHeIEpseBkPhnBGphoWrLv8ssMQ,6686
 lsst/daf/butler/script/removeDatasetType.py,sha256=aG4W8Nvne5TFPFtEUxpQ4KJ1C_pL_0BOxXDexhlr_BY,1910
 lsst/daf/butler/script/removeRuns.py,sha256=5rZeJ7O-ZAYNrh_a7FkDm84pn6Bs0VArjp0MiLSFFyg,5202
 lsst/daf/butler/script/retrieveArtifacts.py,sha256=7cT6yHEMQfuziGcqoOXFBH6cOJ7_3x4kLJldsFxIm3w,4783
@@ -324,7 +324,7 @@ lsst/daf/butler/tests/_datasetsHelper.py,sha256=LH1ZPuzSpRijAPtAiwBoSZZPzI-aSaHN
 lsst/daf/butler/tests/_dummyRegistry.py,sha256=CowulEeirnWwSJf-AnutvOLvGSr3ITgShlYj9f_IuYk,9509
 lsst/daf/butler/tests/_examplePythonTypes.py,sha256=oKuKhFkyipD7XCojlQR7D9xPyq6YS9nkB-U4_l07BIM,13281
 lsst/daf/butler/tests/_testRepo.py,sha256=MVkQwXJ5vI86--Npa7SDHRblpJC5pig6vpGxv-dgGvE,23755
-lsst/daf/butler/tests/butler_queries.py,sha256=4fTO5mHM3DwN_K1nYdcTNifUZM-DOs3nILBsQ-Z3hvg,121612
+lsst/daf/butler/tests/butler_queries.py,sha256=cw7WIDIhcxhvtKTXPW6HdY7X9TqCJbXTA9rfhXkpLeM,123190
 lsst/daf/butler/tests/cliCmdTestBase.py,sha256=6SsDIIttbvwi9TX7jkaPa8VuTvzO17hL6WGAm_T6uxM,6994
 lsst/daf/butler/tests/cliLogTestBase.py,sha256=sgpOMQV21ItF4ElE7Z1rMAi0rzAcBEOfe2Yu62bujBU,18325
 lsst/daf/butler/tests/deferredFormatter.py,sha256=EtUnxNy90n5ouESBbcFBLOt4mrHhmxvHS2vP6Y3dF0w,1920
@@ -334,6 +334,7 @@ lsst/daf/butler/tests/hybrid_butler_collections.py,sha256=XzuZzqKLKkVVY6Y96Rdrwk
 lsst/daf/butler/tests/hybrid_butler_registry.py,sha256=-xR5BuLIl3HA_bLVDMBZFFF0tPRHthttODbcfGAivMo,13393
 lsst/daf/butler/tests/postgresql.py,sha256=6-84OPoysRtsborTdsyu5HcVfVWZqHaU8azFPSxu0Wc,4331
 lsst/daf/butler/tests/server.py,sha256=crFS4weG5TEkf4N5m7ATxr7gRfTNeNzL3lXkyKyqdi8,9551
+lsst/daf/butler/tests/server_available.py,sha256=NC_G-vgrp8abDkXhoBmOBD-V_JutS12_gYBwqf0qgQY,2087
 lsst/daf/butler/tests/server_utils.py,sha256=sneYxThLhvc7KaFdHJXV15j-R3JtC6yOjDfVptJw6x4,2833
 lsst/daf/butler/tests/testFormatters.py,sha256=2q7t1t6G6aFjyiTPTEsXeHHdIMVH_tRWxHFpK3x_s1w,9575
 lsst/daf/butler/tests/utils.py,sha256=KRQT6wFYWrLdpI0UEiGq9T9LBZ5bEvo8Y12ocMxTTfE,15622
@@ -346,16 +347,16 @@ lsst/daf/butler/tests/registry_data/hsc-rc2-subset-v0.yaml,sha256=Y_Ihkoa2uZ2QSW
 lsst/daf/butler/tests/registry_data/spatial.py,sha256=KVh7b-iuJGdXloVLIGsR15P2jK87rcRJw7TyLVzH2j0,22787
 lsst/daf/butler/tests/registry_data/spatial.yaml,sha256=33X7e4XZ84jmSSYBvCKw6CxTPplL-83Bnk0vZi9PPZk,11262
 lsst/daf/butler/transfers/__init__.py,sha256=M1YcFszSkNB5hB2pZwwGXqbJE2dKt4YXDinW4s1iHI8,1371
-lsst/daf/butler/transfers/_context.py,sha256=1oOlKWj53bjcVioOIzRNPZSC_Q0dLDI_R4syI9gMOkg,16938
+lsst/daf/butler/transfers/_context.py,sha256=Ro_nf9NDw9IAr-Pw_NtcdotQKx34RbBbNubt20zwRXU,16449
 lsst/daf/butler/transfers/_interfaces.py,sha256=Ia1NqcFR5E-Ik4zsXEe2fuMtNCJj5Yfe_gVHLTBtJDw,7490
 lsst/daf/butler/transfers/_yaml.py,sha256=w_0GmrueuHVLfOfAXGHFBbWAl18tX6eSElbTC-2jRoc,32632
-lsst_daf_butler-29.2025.4100.dist-info/licenses/COPYRIGHT,sha256=k1Vq0-Be_K-puaeW4UZnckPjksEL-MJh4XKiWcjMxJE,312
-lsst_daf_butler-29.2025.4100.dist-info/licenses/LICENSE,sha256=pRExkS03v0MQW-neNfIcaSL6aiAnoLxYgtZoFzQ6zkM,232
-lsst_daf_butler-29.2025.4100.dist-info/licenses/bsd_license.txt,sha256=7MIcv8QRX9guUtqPSBDMPz2SnZ5swI-xZMqm_VDSfxY,1606
-lsst_daf_butler-29.2025.4100.dist-info/licenses/gpl-v3.0.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-lsst_daf_butler-29.2025.4100.dist-info/METADATA,sha256=JpxDaRocREFqVfxiPesMBeyGnQV00ftHxiircXn8UYs,3846
-lsst_daf_butler-29.2025.4100.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lsst_daf_butler-29.2025.4100.dist-info/entry_points.txt,sha256=XsRxyTK3c-jGlKVuVnbpch3gtaO0lAA_fS3i2NGS5rw,59
-lsst_daf_butler-29.2025.4100.dist-info/top_level.txt,sha256=eUWiOuVVm9wwTrnAgiJT6tp6HQHXxIhj2QSZ7NYZH80,5
-lsst_daf_butler-29.2025.4100.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lsst_daf_butler-29.2025.4100.dist-info/RECORD,,
+lsst_daf_butler-29.2025.4200.dist-info/licenses/COPYRIGHT,sha256=k1Vq0-Be_K-puaeW4UZnckPjksEL-MJh4XKiWcjMxJE,312
+lsst_daf_butler-29.2025.4200.dist-info/licenses/LICENSE,sha256=pRExkS03v0MQW-neNfIcaSL6aiAnoLxYgtZoFzQ6zkM,232
+lsst_daf_butler-29.2025.4200.dist-info/licenses/bsd_license.txt,sha256=7MIcv8QRX9guUtqPSBDMPz2SnZ5swI-xZMqm_VDSfxY,1606
+lsst_daf_butler-29.2025.4200.dist-info/licenses/gpl-v3.0.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+lsst_daf_butler-29.2025.4200.dist-info/METADATA,sha256=DkM04zD7-teIjvNEJkwxPBS70lH1n1BLRGBdP4B2PJE,3846
+lsst_daf_butler-29.2025.4200.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lsst_daf_butler-29.2025.4200.dist-info/entry_points.txt,sha256=XsRxyTK3c-jGlKVuVnbpch3gtaO0lAA_fS3i2NGS5rw,59
+lsst_daf_butler-29.2025.4200.dist-info/top_level.txt,sha256=eUWiOuVVm9wwTrnAgiJT6tp6HQHXxIhj2QSZ7NYZH80,5
+lsst_daf_butler-29.2025.4200.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lsst_daf_butler-29.2025.4200.dist-info/RECORD,,