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

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

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

@@ -347,13 +347,13 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
                     without_datastore=without_datastore,
                 )
             case ButlerType.REMOTE:
-                from .remote_butler import RemoteButlerFactory
+                from .remote_butler._factory import RemoteButlerFactory
 
                 # Assume this is being created by a client who would like
                 # default caching of remote datasets.
                 factory = RemoteButlerFactory.create_factory_from_config(butler_config)
                 return factory.create_butler_with_credentials_from_environment(
-                    butler_options=options, use_disabled_datastore_cache=False
+                    butler_options=options, enable_datastore_cache=True
                 )
             case _:
                 raise TypeError(f"Unknown Butler type '{butler_type}'")

{lsst_daf_butler-29.2025.3000 → lsst_daf_butler-29.2025.3200}/python/lsst/daf/butler/_labeled_butler_factory.py

@@ -198,9 +198,9 @@ def _create_direct_butler_factory(config: ButlerConfig, preload_unsafe_caches: b
 
 
 def _create_remote_butler_factory(config: ButlerConfig) -> _FactoryFunction:
-    import lsst.daf.butler.remote_butler
+    import lsst.daf.butler.remote_butler._factory
 
-    factory = lsst.daf.butler.remote_butler.RemoteButlerFactory.create_factory_from_config(config)
+    factory = lsst.daf.butler.remote_butler._factory.RemoteButlerFactory.create_factory_from_config(config)
 
     def create_butler(access_token: str | None) -> Butler:
         if access_token is None:

{lsst_daf_butler-29.2025.3000 → lsst_daf_butler-29.2025.3200}/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.3000 → lsst_daf_butler-29.2025.3200}/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.3000 → lsst_daf_butler-29.2025.3200}/python/lsst/daf/butler/datastore/_datastore.py

@@ -66,8 +66,8 @@ if TYPE_CHECKING:
     from .._dataset_ref import DatasetId, DatasetRef
     from .._dataset_type import DatasetType
     from .._storage_class import StorageClass
+    from ..datastores.file_datastore.get import DatasetLocationInformation
     from ..datastores.file_datastore.retrieve_artifacts import ArtifactIndexInfo
-    from ..datastores.fileDatastoreClient import FileDatastoreGetPayload
     from ..registry.interfaces import DatasetIdRef, DatastoreRegistryBridgeManager
     from .record_data import DatastoreRecordData
     from .stored_file_info import StoredDatastoreItemInfo
@@ -614,8 +614,8 @@ class Datastore(FileTransferSource, metaclass=ABCMeta):
         """
         raise NotImplementedError("Must be implemented by subclass")
 
-    def prepare_get_for_external_client(self, ref: DatasetRef) -> FileDatastoreGetPayload | None:
-        """Retrieve serializable data that can be used to execute a ``get()``.
+    def prepare_get_for_external_client(self, ref: DatasetRef) -> list[DatasetLocationInformation] | None:
+        """Retrieve data that can be used to execute a ``get()``.
 
         Parameters
         ----------
@@ -624,11 +624,9 @@ class Datastore(FileTransferSource, metaclass=ABCMeta):
 
         Returns
         -------
-        payload : `object` | `None`
-            Serializable payload containing the information needed to perform a
-            get() operation.  This payload may be sent over the wire to another
-            system to perform the get().  Returns `None` if the dataset is not
-            known to this datastore.
+        payload : `list` [ `DatasetLocationInformation` ] | `None`
+            Information needed to perform a get() operation.  Returns `None` if
+            the dataset is not known to this datastore.
         """
         raise NotImplementedError()
 

{lsst_daf_butler-29.2025.3000 → lsst_daf_butler-29.2025.3200}/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.3000 → lsst_daf_butler-29.2025.3200}/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.3000 → lsst_daf_butler-29.2025.3200}/python/lsst/daf/butler/datastores/chainedDatastore.py

@@ -47,6 +47,7 @@ from lsst.daf.butler.datastore import (
 )
 from lsst.daf.butler.datastore.constraints import Constraints
 from lsst.daf.butler.datastore.record_data import DatastoreRecordData
+from lsst.daf.butler.datastores.file_datastore.get import DatasetLocationInformation
 from lsst.daf.butler.datastores.file_datastore.retrieve_artifacts import ArtifactIndexInfo, ZipIndex
 from lsst.resources import ResourcePath
 from lsst.utils import doImportType
@@ -61,8 +62,6 @@ if TYPE_CHECKING:
     from lsst.daf.butler.registry.interfaces import DatasetIdRef, DatastoreRegistryBridgeManager
     from lsst.resources import ResourcePathExpression
 
-    from .fileDatastoreClient import FileDatastoreGetPayload
-
 log = getLogger(__name__)
 
 
@@ -411,7 +410,7 @@ class ChainedDatastore(Datastore):
 
         raise FileNotFoundError(f"Dataset {ref} could not be found in any of the datastores")
 
-    def prepare_get_for_external_client(self, ref: DatasetRef) -> FileDatastoreGetPayload | None:
+    def prepare_get_for_external_client(self, ref: DatasetRef) -> list[DatasetLocationInformation] | None:
         datastore = self._get_matching_datastore(ref)
         if datastore is None:
             return None

{lsst_daf_butler-29.2025.3000 → lsst_daf_butler-29.2025.3200}/python/lsst/daf/butler/datastores/fileDatastore.py

@@ -89,10 +89,6 @@ from lsst.daf.butler.datastores.file_datastore.retrieve_artifacts import (
     determine_destination_for_retrieved_artifact,
     unpack_zips,
 )
-from lsst.daf.butler.datastores.fileDatastoreClient import (
-    FileDatastoreGetPayload,
-    FileDatastoreGetPayloadFileInfo,
-)
 from lsst.daf.butler.registry.interfaces import (
     DatabaseInsertMode,
     DatastoreRegistryBridge,
@@ -110,7 +106,6 @@ from lsst.utils.logging import VERBOSE, getLogger
 from lsst.utils.timer import time_this
 
 from ..datastore import FileTransferMap, FileTransferRecord
-from ..datastore.stored_file_info import make_datastore_path_relative
 
 if TYPE_CHECKING:
     from lsst.daf.butler import DatasetProvenance, LookupKey
@@ -2304,27 +2299,14 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
             allGetInfo, ref=ref, parameters=parameters, cache_manager=self.cacheManager
         )
 
-    def prepare_get_for_external_client(self, ref: DatasetRef) -> FileDatastoreGetPayload | None:
+    def prepare_get_for_external_client(self, ref: DatasetRef) -> list[DatasetLocationInformation] | None:
         # Docstring inherited
 
-        # 1 hour.  Chosen somewhat arbitrarily -- this is long enough that the
-        # client should have time to download a large file with retries if
-        # needed, but short enough that it will become obvious quickly that
-        # these URLs expire.
-        # From a strictly technical standpoint there is no reason this
-        # shouldn't be a day or more, but there seems to be a political issue
-        # where people think there is a risk of end users posting presigned
-        # URLs for people without access rights to download.
-        url_expiration_time_seconds = 1 * 60 * 60
-
         locations = self._get_dataset_locations_info(ref)
         if len(locations) == 0:
             return None
 
-        return FileDatastoreGetPayload(
-            datastore_type="file",
-            file_info=[_to_file_info_payload(info, url_expiration_time_seconds) for info in locations],
-        )
+        return locations
 
     @transactional
     def put(self, inMemoryDataset: Any, ref: DatasetRef, provenance: DatasetProvenance | None = None) -> None:
@@ -3229,17 +3211,3 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
     def get_opaque_table_definitions(self) -> Mapping[str, DatastoreOpaqueTable]:
         # Docstring inherited from the base class.
         return {self._opaque_table_name: DatastoreOpaqueTable(self.makeTableSpec(), StoredFileInfo)}
-
-
-def _to_file_info_payload(
-    info: DatasetLocationInformation, url_expiration_time_seconds: int
-) -> FileDatastoreGetPayloadFileInfo:
-    location, file_info = info
-
-    datastoreRecords = file_info.to_simple()
-    datastoreRecords.path = make_datastore_path_relative(datastoreRecords.path)
-
-    return FileDatastoreGetPayloadFileInfo(
-        url=location.uri.generate_presigned_get_url(expiration_time_seconds=url_expiration_time_seconds),
-        datastoreRecords=datastoreRecords,
-    )

{lsst_daf_butler-29.2025.3000 → lsst_daf_butler-29.2025.3200}/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.3000 → lsst_daf_butler-29.2025.3200}/python/lsst/daf/butler/remote_butler/__init__.py

@@ -25,6 +25,5 @@
 # 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 ._factory import *
 from ._http_connection import ButlerServerError
 from ._remote_butler import *

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

@@ -25,16 +25,24 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+from __future__ import annotations
+
+from typing import Literal, TypeAlias
+
 from pydantic import AnyHttpUrl, BaseModel
 
 
+class RemoteButlerConfigModel(BaseModel):
+    """ButlerConfig properties for RemoteButler."""
+
+    remote_butler: RemoteButlerOptionsModel
+
+
 class RemoteButlerOptionsModel(BaseModel):
     """Model representing the remote server connection."""
 
     url: AnyHttpUrl
+    authentication: AuthenticationMode = "rubin_science_platform"
 
 
-class RemoteButlerConfigModel(BaseModel):
-    """Configuration representing a remote butler."""
-
-    remote_butler: RemoteButlerOptionsModel
+AuthenticationMode: TypeAlias = Literal["rubin_science_platform", "cadc"]