lsst-daf-butler 29.2025.3100__tar.gz → 29.2025.3300__tar.gz

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

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

@@ -129,11 +129,6 @@ class LimitedButler(ABC):
         obj : `object`
             The dataset.
 
-        Raises
-        ------
-        AmbiguousDatasetError
-            Raised if the supplied `DatasetRef` is unresolved.
-
         Notes
         -----
         In a `LimitedButler` the only allowable way to specify a dataset is
@@ -326,7 +321,7 @@ class LimitedButler(ABC):
             Whether the dataset artifact exists in the datastore and can be
             retrieved.
         """
-        return self._datastore.exists(ref)
+        return self.stored_many([ref])[ref]
 
     def stored_many(
         self,

{lsst_daf_butler-29.2025.3100 → lsst_daf_butler-29.2025.3300}/python/lsst/daf/butler/_storage_class.py

@@ -39,6 +39,8 @@ from collections.abc import Callable, Collection, Mapping, Sequence, Set
 from threading import RLock
 from typing import Any
 
+import pydantic
+
 from lsst.utils import doImportType
 from lsst.utils.classes import Singleton
 from lsst.utils.introspection import get_full_type_name
@@ -57,6 +59,18 @@ class StorageClassConfig(ConfigSubset):
     defaultConfigFile = "storageClasses.yaml"
 
 
+class _StorageClassModel(pydantic.BaseModel):
+    """Model class used to validate storage class configuration."""
+
+    pytype: str | None = None
+    inheritsFrom: str | None = None
+    components: dict[str, str] = pydantic.Field(default_factory=dict)
+    derivedComponents: dict[str, str] = pydantic.Field(default_factory=dict)
+    parameters: list[str] = pydantic.Field(default_factory=list)
+    delegate: str | None = None
+    converters: dict[str, str] = pydantic.Field(default_factory=dict)
+
+
 class StorageClass:
     """Class describing how a label maps to a particular Python type.
 
@@ -81,17 +95,9 @@ class StorageClass:
         that python type to the valid type of this storage class.
     """
 
-    _cls_name: str = "BaseStorageClass"
-    _cls_components: dict[str, StorageClass] | None = None
-    _cls_derivedComponents: dict[str, StorageClass] | None = None
-    _cls_parameters: Set[str] | Sequence[str] | None = None
-    _cls_delegate: str | None = None
-    _cls_pytype: type | str | None = None
-    _cls_converters: dict[str, str] | None = None
-
     def __init__(
         self,
-        name: str | None = None,
+        name: str = "",
         pytype: type | str | None = None,
         components: dict[str, StorageClass] | None = None,
         derivedComponents: dict[str, StorageClass] | None = None,
@@ -99,23 +105,8 @@ class StorageClass:
         delegate: str | None = None,
         converters: dict[str, str] | None = None,
     ):
-        if name is None:
-            name = self._cls_name
-        if pytype is None:
-            pytype = self._cls_pytype
-        if components is None:
-            components = self._cls_components
-        if derivedComponents is None:
-            derivedComponents = self._cls_derivedComponents
-        if parameters is None:
-            parameters = self._cls_parameters
-        if delegate is None:
-            delegate = self._cls_delegate
-
         # Merge converters with class defaults.
         self._converters = {}
-        if self._cls_converters is not None:
-            self._converters.update(self._cls_converters)
         if converters:
             self._converters.update(converters)
 
@@ -634,7 +625,6 @@ class StorageClassFactory(metaclass=Singleton):
 
     def __init__(self, config: StorageClassConfig | str | None = None):
         self._storageClasses: dict[str, StorageClass] = {}
-        self._configs: list[StorageClassConfig] = []
         self._lock = RLock()
 
         # Always seed with the default config
@@ -657,40 +647,15 @@ class StorageClassFactory(metaclass=Singleton):
 
 StorageClasses
 --------------
-{sep.join(f"{s}: {self._storageClasses[s]!r}" for s in sorted(self._storageClasses))}
+{sep.join(f"{self._storageClasses[s]!r}" for s in sorted(self._storageClasses))}
 """
 
-    def __contains__(self, storageClassOrName: StorageClass | str) -> bool:
-        """Indicate whether the storage class exists in the factory.
-
-        Parameters
-        ----------
-        storageClassOrName : `str` or `StorageClass`
-            If `str` is given existence of the named StorageClass
-            in the factory is checked. If `StorageClass` is given
-            existence and equality are checked.
-
-        Returns
-        -------
-        in : `bool`
-            True if the supplied string is present, or if the supplied
-            `StorageClass` is present and identical.
-
-        Notes
-        -----
-        The two different checks (one for "key" and one for "value") based on
-        the type of the given argument mean that it is possible for
-        StorageClass.name to be in the factory but StorageClass to not be
-        in the factory.
-        """
+    def __contains__(self, storageClassOrName: object) -> bool:
         with self._lock:
             if isinstance(storageClassOrName, str):
                 return storageClassOrName in self._storageClasses
-            elif (
-                isinstance(storageClassOrName, StorageClass)
-                and storageClassOrName.name in self._storageClasses
-            ):
-                return storageClassOrName == self._storageClasses[storageClassOrName.name]
+            elif isinstance(storageClassOrName, StorageClass):
+                return storageClassOrName.name in self._storageClasses
             return False
 
     def addFromConfig(self, config: StorageClassConfig | Config | str) -> None:
@@ -708,68 +673,54 @@ StorageClasses
         # components or parents before their classes are defined
         # we have a helper function that we can call recursively
         # to extract definitions from the configuration.
-        def processStorageClass(name: str, _sconfig: StorageClassConfig, msg: str = "") -> None:
-            # Maybe we've already processed this through recursion
+        def processStorageClass(name: str, _sconfig: StorageClassConfig, msg: str = "") -> StorageClass:
+            # This might have already been processed through recursion, or
+            # already present in the factory.
             if name not in _sconfig:
-                return
-            info = _sconfig.pop(name)
-
-            # Always create the storage class so we can ensure that
-            # we are not trying to overwrite with a different definition
-            components = None
-
-            # Extract scalar items from dict that are needed for
-            # StorageClass Constructor
-            storageClassKwargs = {k: info[k] for k in ("pytype", "delegate", "parameters") if k in info}
-
-            if "converters" in info:
-                storageClassKwargs["converters"] = info["converters"].toDict()
-
-            for compName in ("components", "derivedComponents"):
-                if compName not in info:
-                    continue
-                components = {}
-                for cname, ctype in info[compName].items():
-                    if ctype not in self:
-                        processStorageClass(ctype, sconfig, msg)
-                    components[cname] = self.getStorageClass(ctype)
-
-                # Fill in other items
-                storageClassKwargs[compName] = components
-
-            # Create the new storage class and register it
-            baseClass = None
-            if "inheritsFrom" in info:
-                baseName = info["inheritsFrom"]
-
-                # The inheritsFrom feature requires that the storage class
-                # being inherited from is itself a subclass of StorageClass
-                # that was created with makeNewStorageClass. If it was made
-                # and registered with a simple StorageClass constructor it
-                # cannot be used here and we try to recreate it.
-                if baseName in self:
-                    baseClass = type(self.getStorageClass(baseName))
-                    if baseClass is StorageClass:
-                        log.warning(
-                            "Storage class %s is requested to inherit from %s but that storage class "
-                            "has not been defined to be a subclass of StorageClass and so can not "
-                            "be used. Attempting to recreate parent class from current configuration.",
-                            name,
-                            baseName,
-                        )
-                        processStorageClass(baseName, sconfig, msg)
-                else:
-                    processStorageClass(baseName, sconfig, msg)
-                baseClass = type(self.getStorageClass(baseName))
-                if baseClass is StorageClass:
-                    raise TypeError(
-                        f"Configuration for storage class {name} requests to inherit from "
-                        f" storage class {baseName} but that class is not defined correctly."
-                    )
-
-            newStorageClassType = self.makeNewStorageClass(name, baseClass, **storageClassKwargs)
-            newStorageClass = newStorageClassType()
-            self.registerStorageClass(newStorageClass, msg=msg)
+                return self.getStorageClass(name)
+            try:
+                model = _StorageClassModel.model_validate(_sconfig.pop(name))
+            except Exception as err:
+                err.add_note(msg)
+                raise
+            components: dict[str, StorageClass] = {}
+            derivedComponents: dict[str, StorageClass] = {}
+            parameters: set[str] = set()
+            delegate: str | None = None
+            converters: dict[str, str] = {}
+            if model.inheritsFrom is not None:
+                base = processStorageClass(model.inheritsFrom, _sconfig, msg + f"; processing base of {name}")
+                pytype = base._pytypeName
+                components.update(base.components)
+                derivedComponents.update(base.derivedComponents)
+                parameters.update(base.parameters)
+                delegate = base._delegateClassName
+                converters.update(base.converters)
+            if model.pytype is not None:
+                pytype = model.pytype
+            for k, v in model.components.items():
+                components[k] = processStorageClass(
+                    v, _sconfig, msg + f"; processing component {k} of {name}"
+                )
+            for k, v in model.derivedComponents.items():
+                derivedComponents[k] = processStorageClass(
+                    v, _sconfig, msg + f"; processing derivedCmponent {k} of {name}"
+                )
+            parameters.update(model.parameters)
+            if model.delegate is not None:
+                delegate = model.delegate
+            converters.update(model.converters)
+            result = StorageClass(
+                name=name,
+                pytype=pytype,
+                components=components,
+                derivedComponents=derivedComponents,
+                parameters=parameters,
+                delegate=delegate,
+                converters=converters,
+            )
+            self.registerStorageClass(result, msg=msg)
+            return result
 
         # In case there is a problem, construct a context message for any
         # error reporting.
@@ -778,68 +729,9 @@ StorageClasses
         log.debug("Adding definitions from config %s", ", ".join(files))
 
         with self._lock:
-            self._configs.append(sconfig)
             for name in list(sconfig.keys()):
                 processStorageClass(name, sconfig, context)
 
-    @staticmethod
-    def makeNewStorageClass(
-        name: str, baseClass: type[StorageClass] | None = StorageClass, **kwargs: Any
-    ) -> type[StorageClass]:
-        """Create a new Python class as a subclass of `StorageClass`.
-
-        Parameters
-        ----------
-        name : `str`
-            Name to use for this class.
-        baseClass : `type`, optional
-            Base class for this `StorageClass`. Must be either `StorageClass`
-            or a subclass of `StorageClass`. If `None`, `StorageClass` will
-            be used.
-        **kwargs
-            Additional parameter values to use as defaults for this class.
-            This can include ``components``, ``parameters``,
-            ``derivedComponents``, and ``converters``.
-
-        Returns
-        -------
-        newtype : `type` subclass of `StorageClass`
-            Newly created Python type.
-        """
-        if baseClass is None:
-            baseClass = StorageClass
-        if not issubclass(baseClass, StorageClass):
-            raise ValueError(f"Base class must be a StorageClass not {baseClass}")
-
-        # convert the arguments to use different internal names
-        clsargs = {f"_cls_{k}": v for k, v in kwargs.items() if v is not None}
-        clsargs["_cls_name"] = name
-
-        # Some container items need to merge with the base class values
-        # so that a child can inherit but override one bit.
-        # lists (which you get from configs) are treated as sets for this to
-        # work consistently.
-        for k in ("components", "parameters", "derivedComponents", "converters"):
-            classKey = f"_cls_{k}"
-            if classKey in clsargs:
-                baseValue = getattr(baseClass, classKey, None)
-                if baseValue is not None:
-                    currentValue = clsargs[classKey]
-                    if isinstance(currentValue, dict):
-                        newValue = baseValue.copy()
-                    else:
-                        newValue = set(baseValue)
-                    newValue.update(currentValue)
-                    clsargs[classKey] = newValue
-
-        # If we have parameters they should be a frozen set so that the
-        # parameters in the class can not be modified.
-        pk = "_cls_parameters"
-        if pk in clsargs:
-            clsargs[pk] = frozenset(clsargs[pk])
-
-        return type(f"StorageClass{name}", (baseClass,), clsargs)
-
     def getStorageClass(self, storageClassName: str) -> StorageClass:
         """Get a StorageClass instance associated with the supplied name.
 

{lsst_daf_butler-29.2025.3100 → lsst_daf_butler-29.2025.3300}/python/lsst/daf/butler/datastore/record_data.py

@@ -111,6 +111,28 @@ class DatastoreRecordData:
     """Opaque table data, indexed by dataset ID and grouped by opaque table
     name."""
 
+    @staticmethod
+    def merge_mappings(*args: Mapping[str, DatastoreRecordData]) -> dict[str, DatastoreRecordData]:
+        """Merge mappings of datastore record data.
+
+        Parameters
+        ----------
+        *args : `~collections.abc.Mapping` [ `str`, `DatastoreRecordData` ]
+            Mappings of record data, keyed by datastore name.
+
+        Returns
+        -------
+        merged : `~collections.abc.Mapping` [ `str`, `DatastoreRecordData` ]
+            Merged mapping of record data, keyed by datastore name.
+        """
+        result: dict[str, DatastoreRecordData] = {}
+        for arg in args:
+            for datastore_name, record_data in arg.items():
+                if datastore_name not in result:
+                    result[datastore_name] = DatastoreRecordData()
+                result[datastore_name].update(record_data)
+        return result
+
     def update(self, other: DatastoreRecordData) -> None:
         """Update contents of this instance with data from another instance.
 

{lsst_daf_butler-29.2025.3100 → lsst_daf_butler-29.2025.3300}/python/lsst/daf/butler/datastore/stored_file_info.py

@@ -32,7 +32,7 @@ __all__ = ("SerializedStoredFileInfo", "StoredDatastoreItemInfo", "StoredFileInf
 import inspect
 from collections.abc import Iterable, Mapping
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import TYPE_CHECKING, Any
 
 import pydantic
 
@@ -209,8 +209,6 @@ class StoredFileInfo(StoredDatastoreItemInfo):
         compatibility, it remains a positional argument with no default).
     """
 
-    storageClassFactory: ClassVar[StorageClassFactory] = StorageClassFactory()
-
     def __init__(
         self,
         formatter: FormatterParameter,
@@ -268,7 +266,7 @@ class StoredFileInfo(StoredDatastoreItemInfo):
     @property
     def storageClass(self) -> StorageClass:
         """Storage class associated with this dataset."""
-        return self.storageClassFactory.getStorageClass(self.storage_class_name)
+        return StorageClassFactory().getStorageClass(self.storage_class_name)
 
     def rebase(self, ref: DatasetRef) -> StoredFileInfo:
         """Return a copy of the record suitable for a specified reference.

{lsst_daf_butler-29.2025.3100 → lsst_daf_butler-29.2025.3300}/python/lsst/daf/butler/dimensions/_record_set.py

@@ -753,7 +753,6 @@ class SerializableDimensionData(pydantic.RootModel):
         ]
 
 
-@dataclasses.dataclass
 class DimensionDataAttacher:
     """A helper class for attaching dimension records to data IDs.
 
@@ -786,7 +785,7 @@ class DimensionDataAttacher:
         dimensions: DimensionGroup | None = None,
     ):
         self.records = {record_set.element.name: record_set for record_set in records}
-        self.deserializers = {}
+        self.deserializers: dict[str, DimensionRecordSetDeserializer] = {}
         for deserializer in deserializers:
             self.deserializers[deserializer.element.name] = deserializer
             if deserializer.element.name not in self.records:
@@ -851,6 +850,54 @@ class DimensionDataAttacher:
 
         return [r.data_id.expanded(r.done) for r in records]
 
+    def serialized(
+        self, *, ignore: Iterable[str] = (), ignore_cached: bool = False, include_skypix: bool = False
+    ) -> SerializableDimensionData:
+        """Serialize all dimension data in this attacher, with deduplication
+        across fully- and partially-deserialized records.
+
+        Parameters
+        ----------
+        ignore : `~collections.abc.Iterable` [ `str` ], optional
+            Names of dimension elements that should not be serialized.
+        ignore_cached : `bool`, optional
+            If `True`, ignore all dimension elements for which
+            `DimensionElement.is_cached` is `True`.
+        include_skypix : `bool`, optional
+            If `True`, include skypix dimensions.  These are ignored by default
+            because they can always be recomputed from their IDs on-the-fly.
+
+        Returns
+        -------
+        serialized : `SerializedDimensionData`
+            Serialized dimension records.
+        """
+        from ._skypix import SkyPixDimension
+
+        ignore = set(ignore)
+        result = SerializableDimensionData()
+        for record_set in self.records.values():
+            if record_set.element.name in ignore:
+                continue
+            if not include_skypix and isinstance(record_set.element, SkyPixDimension):
+                continue
+            if ignore_cached and record_set.element.is_cached:
+                continue
+            serialized_records: dict[tuple[DataIdValue, ...], SerializedKeyValueDimensionRecord] = {}
+            if (deserializer := self.deserializers.get(record_set.element.name)) is not None:
+                for key, value in deserializer._mapping.items():
+                    serialized_record = list(key)
+                    serialized_record.extend(value)
+                    serialized_records[key] = serialized_record
+            for key, record in record_set._by_required_values.items():
+                if key not in serialized_records:
+                    serialized_records[key] = record.serialize_key_value()
+            result.root[record_set.element.name] = list(serialized_records.values())
+        if self.cache is not None and not ignore_cached:
+            for record_set in self.cache.values():
+                result.root[record_set.element.name] = record_set.serialize_records()
+        return result
+
 
 @dataclasses.dataclass
 class _InProgressRecordDicts:

{lsst_daf_butler-29.2025.3100 → lsst_daf_butler-29.2025.3300}/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.3100 → lsst_daf_butler-29.2025.3300}/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.3100 → lsst_daf_butler-29.2025.3300}/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.3100 → lsst_daf_butler-29.2025.3300}/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.3100 → lsst_daf_butler-29.2025.3300}/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.3100 → lsst_daf_butler-29.2025.3300}/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/).