lsst-daf-butler 29.2025.3200__tar.gz → 29.2025.3400__tar.gz

{lsst_daf_butler-29.2025.3200/python/lsst_daf_butler.egg-info → lsst_daf_butler-29.2025.3400}/PKG-INFO

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

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/_butler.py

@@ -2040,7 +2040,7 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
             raise EmptyQueryResultError(list(result.explain_no_results()))
         return dimension_records
 
-    def _query_all_datasets(
+    def query_all_datasets(
         self,
         collections: str | Iterable[str] | None = None,
         *,

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/_dataset_type.py

@@ -38,6 +38,7 @@ from typing import TYPE_CHECKING, Any, ClassVar
 from pydantic import BaseModel, StrictBool, StrictStr
 
 from ._config_support import LookupKey
+from ._exceptions import UnknownComponentError
 from ._storage_class import StorageClass, StorageClassFactory
 from .dimensions import DimensionGroup
 from .json import from_json_pydantic, to_json_pydantic
@@ -492,7 +493,9 @@ class DatasetType:
         """
         if component in self.storageClass.allComponents():
             return self.nameWithComponent(self.name, component)
-        raise KeyError(f"Requested component ({component}) not understood by this DatasetType ({self})")
+        raise UnknownComponentError(
+            f"Requested component ({component}) not understood by this DatasetType ({self})"
+        )
 
     def makeCompositeDatasetType(self) -> DatasetType:
         """Return a composite dataset type from the component.

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/_exceptions.py

@@ -41,6 +41,7 @@ __all__ = (
     "InvalidQueryError",
     "MissingCollectionError",
     "MissingDatasetTypeError",
+    "UnknownComponentError",
     "ValidationError",
 )
 
@@ -170,6 +171,14 @@ class MissingDatasetTypeError(DatasetTypeError, KeyError, ButlerUserError):
     error_type = "missing_dataset_type"
 
 
+class UnknownComponentError(KeyError, ButlerUserError):
+    """Exception raised when the requested component of a DatasetType is not
+    known.
+    """
+
+    error_type = "unknown_component"
+
+
 class DatasetTypeNotSupportedError(RuntimeError):
     """A `DatasetType` is not handled by this routine.
 
@@ -227,6 +236,7 @@ _USER_ERROR_TYPES: tuple[type[ButlerUserError], ...] = (
     MissingDatasetTypeError,
     UnimplementedQueryError,
     UnknownButlerUserError,
+    UnknownComponentError,
 )
 _USER_ERROR_MAPPING = {e.error_type: e for e in _USER_ERROR_TYPES}
 assert len(_USER_ERROR_MAPPING) == len(_USER_ERROR_TYPES), (

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/dimensions/_coordinate.py

@@ -1005,10 +1005,12 @@ class _FullTupleDataCoordinate(_BasicTupleDataCoordinate):
         dimensions = self.universe.conform(dimensions)
         if self._dimensions == dimensions:
             return self
-        return DataCoordinate.from_full_values(
-            dimensions,
-            tuple(self[k] for k in dimensions.data_coordinate_keys),
-        )
+
+        try:
+            values = tuple(self[k] for k in dimensions.data_coordinate_keys)
+        except KeyError as e:
+            raise DimensionNameError(f"Data ID is missing value for dimension {str(e)}.")
+        return DataCoordinate.from_full_values(dimensions, values)
 
     def union(self, other: DataCoordinate) -> DataCoordinate:
         # Docstring inherited from DataCoordinate.

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/direct_butler/_direct_butler.py

@@ -1490,7 +1490,7 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
             names = [info.name for info in collections_info]
 
             # Get all the datasets from these runs.
-            refs = self._query_all_datasets(names, find_first=False, limit=None)
+            refs = self.query_all_datasets(names, find_first=False, limit=None)
 
         # Call pruneDatasets since we are deliberately removing
         # datasets in chunks from the RUN collections rather than

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/registry/dimensions/static.py

@@ -468,7 +468,7 @@ class StaticDimensionRecordStorageManager(DimensionRecordStorageManager):
                 distinct=True,
             ).into_joins_builder(postprocessing=None)
         if not element.has_own_table:
-            raise NotImplementedError(f"Cannot join dimension element {element} with no table.")
+            raise UnimplementedQueryError(f"Cannot join dimension element {element} with no table.")
         table = self._tables[element.name]
         result = SqlJoinsBuilder(db=self._db, from_clause=table)
         for dimension_name, column_name in zip(element.required.names, element.schema.required.names):
@@ -1055,7 +1055,7 @@ class _CommonSkyPixMediatedOverlapsVisitor(OverlapsVisitor):
         # Reject spatial constraints that are nested inside OR or NOT, because
         # the postprocessing needed for those would be a lot harder.
         if flags & PredicateVisitFlags.INVERTED or flags & PredicateVisitFlags.HAS_OR_SIBLINGS:
-            raise NotImplementedError(
+            raise UnimplementedQueryError(
                 "Spatial overlap constraints nested inside OR or NOT are not supported."
             )
         # Delegate to super just because that's good practice with
@@ -1114,7 +1114,7 @@ class _CommonSkyPixMediatedOverlapsVisitor(OverlapsVisitor):
                 )
                 skypix = element
             case _:
-                raise NotImplementedError(
+                raise UnimplementedQueryError(
                     f"Spatial overlap constraint for dimension {element} not supported."
                 )
         # Convert the region-overlap constraint into a skypix

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/remote_butler/server/_config.py

@@ -30,6 +30,7 @@ from __future__ import annotations
 from collections.abc import Iterator
 from contextlib import contextmanager
 from functools import cache
+from typing import Literal
 
 from pydantic import AnyHttpUrl, BaseModel
 from pydantic_settings import BaseSettings, SettingsConfigDict
@@ -57,9 +58,12 @@ class ButlerServerConfig(BaseSettings):
     repositories: dict[str, RepositoryConfig]
     """Mapping from repository name to configuration for the repository."""
 
-    gafaelfawr_url: AnyHttpUrl
+    gafaelfawr_url: AnyHttpUrl | Literal["DISABLED"]
     """URL to the top-level HTTP path where Gafaelfawr can be found (e.g.
     "https://data-int.lsst.cloud").
+
+    This can instead be the special string "DISABLED" to turn off all features
+    requiring Gafaelfawr integration.
     """
 
     authentication: AuthenticationMode
@@ -69,6 +73,10 @@ class ButlerServerConfig(BaseSettings):
     as static files from the `configs/` HTTP route.
     """
 
+    @property
+    def gafaelfawr_enabled(self) -> bool:
+        return self.gafaelfawr_url != "DISABLED"
+
 
 _config: ButlerServerConfig | None = None
 

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/remote_butler/server/_dependencies.py

@@ -27,8 +27,8 @@
 
 from typing import Annotated
 
-from fastapi import Depends, HTTPException
-from safir.dependencies.gafaelfawr import auth_delegated_token_dependency, auth_dependency
+from fastapi import Depends, Header, HTTPException
+from safir.dependencies.gafaelfawr import auth_delegated_token_dependency
 
 from lsst.daf.butler import LabeledButlerFactory
 
@@ -65,9 +65,29 @@ async def authorizer_dependency() -> GafaelfawrGroupAuthorizer:
     return _authorizer
 
 
+async def user_name_dependency(x_auth_request_user: Annotated[str | None, Header()] = None) -> str | None:
+    """Retrieve the user name from Gafaelfawr authentication headers.
+
+    Parameters
+    ----------
+    x_auth_request_user : FastAPI header
+        Header provided by FastAPI.
+
+    Returns
+    -------
+    user_name : `str` | `None`
+        The user name, if Gafaelfawr is available on this environment.  `None`
+        if Gafaelfawr is not available.
+    """
+    if x_auth_request_user is None and load_config().gafaelfawr_enabled:
+        raise HTTPException(status_code=403, detail="Required X-Auth-Request-User header was not provided")
+
+    return x_auth_request_user
+
+
 async def repository_authorization_dependency(
     repository: str,
-    user_name: Annotated[str, Depends(auth_dependency)],
+    user_name: Annotated[str | None, Depends(user_name_dependency)],
     user_token: Annotated[str, Depends(auth_delegated_token_dependency)],
     authorizer: Annotated[GafaelfawrGroupAuthorizer, Depends(authorizer_dependency)],
 ) -> None:
@@ -87,6 +107,7 @@ async def repository_authorization_dependency(
     authorizer : `GafaelfawrGroupAuthorizer`
         Authorization client that will be used to verify group membership.
     """
+    assert user_name is not None, "Gafaelfawr user name header should have been populated."
     if not await authorizer.is_user_authorized_for_repository(
         repository=repository, user_name=user_name, user_token=user_token
     ):

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/remote_butler/server/_server.py

@@ -62,13 +62,16 @@ def create_app() -> FastAPI:
     # factory_dependency().
     default_api_path = "/api/butler"
     prefix = f"{default_api_path}/repo/{{repository}}"
+    auth_dependencies = [Depends(repository_authorization_dependency)]
+    if not config.gafaelfawr_enabled:
+        auth_dependencies = []
     for router in (external_router, query_router):
         app.include_router(
             router,
             prefix=prefix,
             # Verify that users have permission to access repository-specific
             # resources.
-            dependencies=[Depends(repository_authorization_dependency)],
+            dependencies=auth_dependencies,
             # document that 422 responses will include a JSON-formatted error
             # message, from `butler_exception_handler()` below.
             responses={422: {"model": ErrorResponseModel}},

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/remote_butler/server/handlers/_external_query.py

@@ -35,7 +35,6 @@ from typing import Annotated, NamedTuple
 
 from fastapi import APIRouter, Depends
 from fastapi.responses import StreamingResponse
-from safir.dependencies.gafaelfawr import auth_dependency
 
 from lsst.daf.butler import Butler, DataCoordinate, DimensionGroup
 from lsst.daf.butler.remote_butler.server_models import (
@@ -56,7 +55,7 @@ from ...._exceptions import InvalidQueryError
 from ...._query_all_datasets import QueryAllDatasetsParameters, query_all_datasets
 from ....queries import Query
 from ....queries.driver import QueryDriver, QueryTree
-from .._dependencies import factory_dependency
+from .._dependencies import factory_dependency, user_name_dependency
 from .._factory import Factory
 from ._query_serialization import convert_query_page
 from ._query_streaming import StreamingQuery, execute_streaming_query
@@ -93,7 +92,7 @@ class _StreamQueryDriverExecute(StreamingQuery[_QueryContext]):
 async def query_execute(
     request: QueryExecuteRequestModel,
     factory: Annotated[Factory, Depends(factory_dependency)],
-    user_name: Annotated[str, Depends(auth_dependency)],
+    user_name: Annotated[str | None, Depends(user_name_dependency)],
 ) -> StreamingResponse:
     query = _StreamQueryDriverExecute(request, factory)
     return await execute_streaming_query(query, user_name)
@@ -140,7 +139,7 @@ class _StreamQueryAllDatasets(StreamingQuery[_QueryAllDatasetsContext]):
 async def query_all_datasets_execute(
     request: QueryAllDatasetsRequestModel,
     factory: Annotated[Factory, Depends(factory_dependency)],
-    user_name: Annotated[str, Depends(auth_dependency)],
+    user_name: Annotated[str | None, Depends(user_name_dependency)],
 ) -> StreamingResponse:
     query = _StreamQueryAllDatasets(request, factory)
     return await execute_streaming_query(query, user_name)

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/remote_butler/server/handlers/_query_limits.py

@@ -56,7 +56,7 @@ class QueryLimits:
         self._active_queries = 0
         self._active_users: Counter[str] = Counter()
 
-    async def enforce_query_limits(self, user: str) -> None:
+    async def enforce_query_limits(self, user: str | None) -> None:
         if self._active_queries >= _MAXIMUM_CONCURRENT_STREAMING_QUERIES:
             await _block_retry_for_unit_test()
             raise HTTPException(
@@ -70,7 +70,7 @@ class QueryLimits:
         # replica, which is a non-deterministic but small number.
         # There will be some backpressure from the 429 responses as they
         # attempt to bounce to other replicas on retry.
-        if self._active_users[user] >= 2:
+        if user is not None and self._active_users[user] >= 2:
             _LOG.warning(f"User '{user}' is running many queries simultaneously.")
             raise HTTPException(
                 status_code=429,  # too many requests
@@ -80,14 +80,16 @@ class QueryLimits:
             )
 
     @asynccontextmanager
-    async def track_query(self, user: str) -> AsyncIterator[None]:
+    async def track_query(self, user: str | None) -> AsyncIterator[None]:
         try:
             self._active_queries += 1
-            self._active_users[user] += 1
+            if user is not None:
+                self._active_users[user] += 1
             await _block_query_for_unit_test()
             yield
         finally:
-            self._active_users[user] -= 1
+            if user is not None:
+                self._active_users[user] -= 1
             self._active_queries -= 1
 
 

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/remote_butler/server/handlers/_query_streaming.py

@@ -73,7 +73,7 @@ class StreamingQuery(Protocol[_TContext]):
         """
 
 
-async def execute_streaming_query(query: StreamingQuery, user: str) -> StreamingResponse:
+async def execute_streaming_query(query: StreamingQuery, user: str | None) -> StreamingResponse:
     """Run a query, streaming the response incrementally, one page at a time,
     as newline-separated chunks of JSON.
 
@@ -83,7 +83,7 @@ async def execute_streaming_query(query: StreamingQuery, user: str) -> Streaming
         Callers should define a class implementing the ``StreamingQuery``
         protocol to specify the inner logic that will be called during
         query execution.
-    user : `str`
+    user : `str`, optional
         Name of user running the query -- used to enforce usage limits.
 
     Returns
@@ -125,7 +125,7 @@ async def execute_streaming_query(query: StreamingQuery, user: str) -> Streaming
     )
 
 
-async def _stream_query_pages(query: StreamingQuery, user: str) -> AsyncIterator[str]:
+async def _stream_query_pages(query: StreamingQuery, user: str | None) -> AsyncIterator[str]:
     """Stream the query output with one page object per line, as
     newline-delimited JSON records in the "JSON Lines" format
     (https://jsonlines.org/).

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/script/queryDatasets.py

@@ -31,7 +31,7 @@ import warnings
 from collections import defaultdict
 from collections.abc import Iterable, Iterator
 from contextlib import contextmanager
-from itertools import groupby
+from itertools import chain, groupby
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -39,7 +39,7 @@ from astropy.table import Table as AstropyTable
 
 from .._butler import Butler
 from .._exceptions import MissingDatasetTypeError
-from .._query_all_datasets import DatasetsPage, QueryAllDatasetsParameters, query_all_datasets
+from .._query_all_datasets import QueryAllDatasetsParameters
 from ..cli.utils import sortAstropyTable
 from ..utils import has_globs
 
@@ -297,9 +297,10 @@ class QueryDatasets:
             query_func = self._query_single_dataset_type
 
         try:
-            with query_func(query_collections, limit) as pages:
+            with query_func(query_collections, limit) as ref_iter:
                 datasets_found = 0
-                for dataset_type, refs in _chunk_by_dataset_type(pages):
+                for dataset_type, chunk in groupby(ref_iter, lambda ref: ref.datasetType.name):
+                    refs = list(chunk)
                     datasets_found += len(refs)
                     if warn_limit and limit is not None and datasets_found >= limit:
                         # We asked for one too many so must remove that from
@@ -324,24 +325,24 @@ class QueryDatasets:
     @contextmanager
     def _query_multiple_dataset_types(
         self, collections: list[str], limit: int | None
-    ) -> Iterator[Iterator[DatasetsPage]]:
-        with self.butler.query() as query:
-            args = QueryAllDatasetsParameters(
-                collections=collections,
-                find_first=self._find_first,
-                name=self._dataset_type_glob,
-                where=self._where,
-                limit=limit,
-                data_id={},
-                bind={},
-                with_dimension_records=self._with_dimension_records,
-            )
-            yield query_all_datasets(self.butler, query, args)
+    ) -> Iterator[Iterator[DatasetRef]]:
+        args = QueryAllDatasetsParameters(
+            collections=collections,
+            find_first=self._find_first,
+            name=self._dataset_type_glob,
+            where=self._where,
+            limit=limit,
+            data_id={},
+            bind={},
+            with_dimension_records=self._with_dimension_records,
+        )
+        with self.butler._query_all_datasets_by_page(args) as iterator:
+            yield chain.from_iterable(iterator)
 
     @contextmanager
     def _query_single_dataset_type(
         self, collections: list[str], limit: int | None
-    ) -> Iterator[Iterator[DatasetsPage]]:
+    ) -> Iterator[Iterator[DatasetRef]]:
         assert len(self._dataset_type_glob) == 1
         dataset_type = self._dataset_type_glob[0]
 
@@ -355,15 +356,4 @@ class QueryDatasets:
             with_dimension_records=self._with_dimension_records,
         )
 
-        yield iter([DatasetsPage(dataset_type=dataset_type, data=refs)])
-
-
-def _chunk_by_dataset_type(pages: Iterator[DatasetsPage]) -> Iterator[DatasetsPage]:
-    # For each dataset type in the results, collect all the refs into a
-    # single page.  This assumes that in the original iterator, the pages
-    # for each dataset type are contiguous.
-    for dataset_type, chunk in groupby(pages, lambda page: page.dataset_type):
-        refs = []
-        for page in chunk:
-            refs.extend(page.data)
-        yield DatasetsPage(dataset_type, refs)
+        yield iter(refs)

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/tests/butler_queries.py

@@ -2377,7 +2377,7 @@ class ButlerQueryTests(ABC, TestCaseMixin):
         butler = self.make_butler("base.yaml", "datasets.yaml")
 
         # Make sure that refs are coming out well-formed.
-        datasets = butler._query_all_datasets("imported_r", where="detector = 2", instrument="Cam1")
+        datasets = butler.query_all_datasets("imported_r", where="detector = 2", instrument="Cam1")
         datasets.sort(key=lambda ref: ref.datasetType.name)
         self.assertEqual(len(datasets), 2)
         bias = datasets[0]
@@ -2396,29 +2396,29 @@ class ButlerQueryTests(ABC, TestCaseMixin):
         self.assertEqual(flat.id, UUID("c1296796-56c5-4acf-9b49-40d920c6f840"))
 
         # Querying for everything finds everything.
-        results = butler._query_all_datasets("*", find_first=False)
+        results = butler.query_all_datasets("*", find_first=False)
         self.assertEqual(len(results), 13)
 
         # constraining by data ID works
         detector_1_ids = ("d0bb04cd-d697-4a83-ba53-cdfcd58e3a0c", "e15ab039-bc8b-4135-87c5-90902a7c0b22")
-        results = butler._query_all_datasets(
+        results = butler.query_all_datasets(
             "*", data_id={"detector": 1, "instrument": "Cam1"}, find_first=False
         )
         self.assertCountEqual(detector_1_ids, _ref_uuids(results))
 
         # bind values work.
-        results = butler._query_all_datasets(
+        results = butler.query_all_datasets(
             "*", where="detector=:my_bind and instrument='Cam1'", bind={"my_bind": 1}, find_first=False
         )
         self.assertCountEqual(detector_1_ids, _ref_uuids(results))
 
         # find_first requires ordered collections.
         with self.assertRaisesRegex(InvalidQueryError, "Can not use wildcards"):
-            results = butler._query_all_datasets("*")
+            results = butler.query_all_datasets("*")
 
         butler.collections.register("chain", CollectionType.CHAINED)
         butler.collections.redefine_chain("chain", ["imported_g", "imported_r"])
-        results = butler._query_all_datasets(
+        results = butler.query_all_datasets(
             "chain", where="detector=2 and instrument = 'Cam1'", find_first=True
         )
         # find_first searches the collection chain in order.
@@ -2435,47 +2435,47 @@ class ButlerQueryTests(ABC, TestCaseMixin):
         )
 
         # collection searches work.
-        results = butler._query_all_datasets(
+        results = butler.query_all_datasets(
             "*g", where="detector=1 and instrument = 'Cam1'", find_first=False
         )
         self.assertEqual(_ref_uuids(results), ["e15ab039-bc8b-4135-87c5-90902a7c0b22"])
 
         # we raise for missing collections with explicit names.
         with self.assertRaises(MissingCollectionError):
-            results = butler._query_all_datasets("nonexistent")
+            results = butler.query_all_datasets("nonexistent")
         # we don't raise for collection wildcard searches that find nothing.
-        results = butler._query_all_datasets("nonexistent*", find_first=False)
+        results = butler.query_all_datasets("nonexistent*", find_first=False)
         self.assertEqual(results, [])
 
         # dataset type searches work.
-        results = butler._query_all_datasets(
+        results = butler.query_all_datasets(
             "*", name="b*", where="detector=1 and instrument = 'Cam1'", find_first=False
         )
         self.assertEqual(_ref_uuids(results), ["e15ab039-bc8b-4135-87c5-90902a7c0b22"])
 
         # Missing dataset types raise.
         with self.assertRaises(MissingDatasetTypeError):
-            results = butler._query_all_datasets("chain", name=["notfound", "flat"])
+            results = butler.query_all_datasets("chain", name=["notfound", "flat"])
         with self.assertRaises(MissingDatasetTypeError):
-            results = butler._query_all_datasets("chain", name="notfound*")
+            results = butler.query_all_datasets("chain", name="notfound*")
 
         # Limit of 3 lands at the boundary of a dataset type.
         # Limit of 4 is in the middle of a dataset type.
         for limit in [3, 4]:
             with self.subTest(limit=limit):
-                results = butler._query_all_datasets("imported_g", limit=limit)
+                results = butler.query_all_datasets("imported_g", limit=limit)
                 self.assertEqual(len(results), limit)
                 with self.assertLogs(level="WARNING") as log:
-                    results = butler._query_all_datasets("imported_g", limit=-limit)
+                    results = butler.query_all_datasets("imported_g", limit=-limit)
                     self.assertEqual(len(results), limit)
                 self.assertIn("requested limit", log.output[0])
 
-        results = butler._query_all_datasets("imported_g", limit=0)
+        results = butler.query_all_datasets("imported_g", limit=0)
         self.assertEqual(len(results), 0)
 
         # 'where' constraints that don't apply to all dataset types follow the
         # same rules as query_datasets.
-        results = butler._query_all_datasets(
+        results = butler.query_all_datasets(
             "*", where="detector = 2 and band = 'g' and instrument = 'Cam1'", find_first=False
         )
         self.assertCountEqual(
@@ -2491,7 +2491,7 @@ class ButlerQueryTests(ABC, TestCaseMixin):
 
         # Default collections and data ID apply.
         butler.registry.defaults = RegistryDefaults(collections="imported_g")
-        results = butler._query_all_datasets(where="detector = 2")
+        results = butler.query_all_datasets(where="detector = 2")
         self.assertCountEqual(
             _ref_uuids(results),
             ["51352db4-a47a-447c-b12d-a50b206b17cd", "60c8a65c-7290-4c38-b1de-e3b1cdcf872d"],

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/python/lsst/daf/butler/tests/server.py

@@ -15,9 +15,9 @@ from lsst.daf.butler.remote_butler.server import create_app
 from lsst.daf.butler.remote_butler.server._config import ButlerServerConfig, RepositoryConfig, mock_config
 from lsst.daf.butler.remote_butler.server._dependencies import (
     auth_delegated_token_dependency,
-    auth_dependency,
     butler_factory_dependency,
     reset_dependency_caches,
+    user_name_dependency,
 )
 from lsst.resources import ResourcePath
 from lsst.resources.s3utils import clean_test_environment_for_s3, getS3Client
@@ -148,7 +148,7 @@ def create_test_server(
                 app.dependency_overrides[butler_factory_dependency] = lambda: server_butler_factory
                 # In an actual deployment, these headers would be provided by
                 # the Gafaelfawr ingress.
-                app.dependency_overrides[auth_dependency] = lambda: "mock-username"
+                app.dependency_overrides[user_name_dependency] = lambda: "mock-username"
                 app.dependency_overrides[auth_delegated_token_dependency] = lambda: "mock-delegated-token"
 
                 # Using TestClient in a context manager ensures that it uses

lsst_daf_butler-29.2025.3400/python/lsst/daf/butler/version.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "29.2025.3400"

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400/python/lsst_daf_butler.egg-info}/PKG-INFO

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

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/tests/test_datasets.py

@@ -42,6 +42,7 @@ from lsst.daf.butler import (
     SerializedDatasetRefContainerV1,
     StorageClass,
     StorageClassFactory,
+    UnknownComponentError,
 )
 from lsst.daf.butler.datastore.stored_file_info import StoredFileInfo
 from lsst.daf.butler.datastores.file_datastore.retrieve_artifacts import ZipIndex
@@ -516,9 +517,12 @@ class DatasetTypeTestCase(unittest.TestCase):
         self.assertEqual(datasetTypeComponentB.parentStorageClass, storageClass)
         self.assertIsNone(datasetTypeComposite.parentStorageClass)
 
-        with self.assertRaises(KeyError):
+        with self.assertRaises(UnknownComponentError):
             datasetTypeComposite.makeComponentDatasetType("compF")
 
+        with self.assertRaises(UnknownComponentError):
+            datasetTypeComposite.componentTypeName("unknown")
+
 
 class DatasetRefTestCase(unittest.TestCase):
     """Test for DatasetRef."""

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/tests/test_dimensions.py

@@ -48,6 +48,7 @@ from lsst.daf.butler import (
     DimensionConfig,
     DimensionElement,
     DimensionGroup,
+    DimensionNameError,
     DimensionPacker,
     DimensionUniverse,
     NamedKeyDict,
@@ -797,6 +798,10 @@ class DataCoordinateTestCase(unittest.TestCase):
                         self.assertEqual(dataId, newDataId)
                         self.assertTrue(newDataId.hasFull())
 
+        coord = DataCoordinate.standardize({"instrument": "HSC"}, universe=self.allDataIds.universe)
+        with self.assertRaises(DimensionNameError):
+            coord.subset(["detector"])
+
     def testUnion(self):
         """Test `DataCoordinate.union`."""
         # Make test groups to combine; mostly random, but with a few explicit

{lsst_daf_butler-29.2025.3200 → lsst_daf_butler-29.2025.3400}/tests/test_server.py

@@ -631,6 +631,7 @@ class ButlerClientServerAuthorizationTestCase(unittest.TestCase):
         """Test server running in CADC auth mode."""
         with mock_config() as config:
             config.authentication = "cadc"
+            config.gafaelfawr_url = "DISABLED"
             with create_test_server(TESTDIR, server_config=config) as instance:
                 self.assertIsInstance(instance.remote_butler._connection.auth, CadcAuthenticationProvider)
 

lsst_daf_butler-29.2025.3200/python/lsst/daf/butler/version.py

@@ -1,2 +0,0 @@
-__all__ = ["__version__"]
-__version__ = "29.2025.3200"