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

{lsst_daf_butler-29.2025.3100/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.3100
+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.3100 → 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.3100 → 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.3100 → 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.3100 → 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.3100 → 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.3100 → lsst_daf_butler-29.2025.3200}/python/lsst/daf/butler/tests/_examplePythonTypes.py

@@ -147,12 +147,7 @@ def _addFullStorageClass(butler: Butler, name: str, formatter: str, **kwargs: An
         previously found in the repository.
     """
     storageRegistry = butler._datastore.storageClassFactory
-
-    # Use the special constructor to allow a subclass of storage class
-    # to be created. This allows other test storage classes to inherit from
-    # this one.
-    storage_type = storageRegistry.makeNewStorageClass(name, None, **kwargs)
-    storage = storage_type()
+    storage = StorageClass(name, **kwargs)
     try:
         storageRegistry.registerStorageClass(storage)
     except ValueError:

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

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

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

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

@@ -484,19 +484,6 @@ class DatasetTypeTestCase(unittest.TestCase):
         self.assertEqual(datasetTypeOut, componentDatasetType)
         self.assertEqual(datasetTypeOut._parentStorageClassName, componentDatasetType._parentStorageClassName)
 
-        # Now with a storage class that is created by the factory
-        factoryStorageClassClass = StorageClassFactory.makeNewStorageClass("ParentClass")
-        factoryComponentStorageClassClass = StorageClassFactory.makeNewStorageClass("ComponentClass")
-        componentDatasetType = DatasetType(
-            DatasetType.nameWithComponent(datasetTypeName, "comp"),
-            dimensions,
-            factoryComponentStorageClassClass(),
-            parentStorageClass=factoryStorageClassClass(),
-        )
-        datasetTypeOut = pickle.loads(pickle.dumps(componentDatasetType))
-        self.assertEqual(datasetTypeOut, componentDatasetType)
-        self.assertEqual(datasetTypeOut._parentStorageClassName, componentDatasetType._parentStorageClassName)
-
     def test_composites(self) -> None:
         """Test components within composite DatasetTypes."""
         storageClassA = StorageClass("compA")

{lsst_daf_butler-29.2025.3100 → lsst_daf_butler-29.2025.3200}/tests/test_dimension_record_containers.py

@@ -457,12 +457,12 @@ class DimensionRecordContainersTestCase(unittest.TestCase):
         del model1.root["patch"][-1]
         model2 = SerializableDimensionData.model_validate_json(model1.model_dump_json())
         with self.butler.query() as query:
-            attacher = DimensionDataAttacher(
+            attacher1 = DimensionDataAttacher(
                 deserializers=model2.make_deserializers(self.universe),
                 cache=query._driver._dimension_record_cache,
                 dimensions=dimensions,
             )
-            expanded_data_ids_2 = attacher.attach(dimensions, thin_data_ids, query=query)
+            expanded_data_ids_2 = attacher1.attach(dimensions, thin_data_ids, query=query)
         # This equality check is necessary but not sufficient for this test,
         # because DataCoordinate equality doesn't look at records.
         self.assertEqual(expanded_data_ids_1, expanded_data_ids_2)
@@ -476,19 +476,29 @@ class DimensionRecordContainersTestCase(unittest.TestCase):
         }
         self.assertGreater(len(all_values), 1)
         self.assertEqual(len(all_identities), len(all_values), msg=str(all_identities))
-        # Attach data IDs with the same attacher again, after clearing out its
-        # deserializers.  The cached records should all be present, and it
+        # Serialize and round-trip again, via attacher.serialized(), and attach
+        # all records again.
+        model3 = attacher1.serialized()
+        attacher2 = DimensionDataAttacher(
+            deserializers=model3.make_deserializers(self.universe), dimensions=dimensions
+        )
+        expanded_data_ids_4 = attacher2.attach(dimensions, thin_data_ids)
+        self.assertEqual(expanded_data_ids_1, expanded_data_ids_4)
+        for a, b in zip(expanded_data_ids_1, expanded_data_ids_4):
+            self.assertEqual(dict(a.records), dict(b.records))
+        # Attach data IDs with the original attacher again, after clearing out
+        # its deserializers.  The cached records should all be present, and it
         # should work without any butler queries.
-        attacher.deserializers.clear()
-        expanded_data_ids_3 = attacher.attach(dimensions, thin_data_ids)
+        attacher1.deserializers.clear()
+        expanded_data_ids_3 = attacher1.attach(dimensions, thin_data_ids)
         self.assertEqual(expanded_data_ids_1, expanded_data_ids_3)
         for a, b in zip(expanded_data_ids_1, expanded_data_ids_3):
             self.assertEqual(dict(a.records), dict(b.records))
         # Delete a record and try again to check error-handling.
-        removed_patch_data_id = next(iter(attacher.records["patch"])).dataId
-        attacher.records["patch"].remove(removed_patch_data_id)
+        removed_patch_data_id = next(iter(attacher1.records["patch"])).dataId
+        attacher1.records["patch"].remove(removed_patch_data_id)
         with self.assertRaisesRegex(LookupError, r"No dimension record.*patch.*"):
-            attacher.attach(dimensions, thin_data_ids)
+            attacher1.attach(dimensions, thin_data_ids)
 
 
 if __name__ == "__main__":

{lsst_daf_butler-29.2025.3100 → lsst_daf_butler-29.2025.3200}/tests/test_quantumBackedButler.py

@@ -45,6 +45,7 @@ from lsst.daf.butler import (
     RegistryConfig,
     StorageClass,
 )
+from lsst.daf.butler.datastore.record_data import DatastoreRecordData
 from lsst.daf.butler.datastores.file_datastore.retrieve_artifacts import ZipIndex
 from lsst.daf.butler.direct_butler import DirectButler
 from lsst.daf.butler.registry import _RegistryFactory
@@ -454,6 +455,23 @@ class QuantumBackedButlerTestCase(unittest.TestCase):
             data = self.butler.get(ref)
             self.assertEqual(data, {"data": cast(int, ref.dataId["detector"]) ** 3})
 
+    def test_record_data_merge_mappings(self):
+        """Test DatastoreRecordData.merge_mappings."""
+        r1 = self.butler._datastore.export_records(self.input_refs)
+        r2 = self.butler._datastore.export_records(self.init_inputs_refs)
+        r3 = self.butler._datastore.export_records(self.input_refs)  # intentional duplicate
+        merged = DatastoreRecordData.merge_mappings(r1, r2, r3)
+        self.assertEqual(merged.keys(), r1.keys() | r2.keys())
+        for datastore_name in merged.keys():
+            if datastore_name in r1:
+                self.assertGreaterEqual(
+                    merged[datastore_name].records.keys(), r1[datastore_name].records.keys()
+                )
+            if datastore_name in r2:
+                self.assertGreaterEqual(
+                    merged[datastore_name].records.keys(), r2[datastore_name].records.keys()
+                )
+
 
 if __name__ == "__main__":
     unittest.main()

{lsst_daf_butler-29.2025.3100 → lsst_daf_butler-29.2025.3200}/tests/test_storageClass.py

@@ -270,11 +270,10 @@ class StorageClassFactoryTestCase(unittest.TestCase):
         # Check component inheritance
         exposure = factory.getStorageClass("Exposure")
         exposureF = factory.getStorageClass("ExposureF")
-        self.assertIsInstance(exposureF, type(exposure))
-        self.assertIsInstance(exposure.components["image"], type(image))
-        self.assertNotIsInstance(exposure.components["image"], type(imageF))
-        self.assertIsInstance(exposureF.components["image"], type(image))
-        self.assertIsInstance(exposureF.components["image"], type(imageF))
+        self.assertEqual(exposure.components["image"], image)
+        self.assertNotEqual(exposure.components["image"], imageF)
+        self.assertNotEqual(exposureF.components["image"], image)
+        self.assertEqual(exposureF.components["image"], imageF)
         self.assertIn("wcs", exposure.components)
         self.assertIn("wcs", exposureF.components)
 
@@ -290,14 +289,6 @@ class StorageClassFactoryTestCase(unittest.TestCase):
         param2.remove("param3")
         self.assertEqual(param1, param2)
 
-        # Check that we can't have a new StorageClass that does not
-        # inherit from StorageClass
-        with self.assertRaises(ValueError):
-            factory.makeNewStorageClass("ClassName", baseClass=StorageClassFactory)
-
-        sc = factory.makeNewStorageClass("ClassName")
-        self.assertIsInstance(sc(), StorageClass)
-
     def testPickle(self):
         """Test that we can pickle storageclasses."""
         className = "TestImage"

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

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