lsst-daf-butler 29.2025.4200__tar.gz → 29.2025.4400__tar.gz

{lsst_daf_butler-29.2025.4200/python/lsst_daf_butler.egg-info → lsst_daf_butler-29.2025.4400}/PKG-INFO

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

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/_dataset_association.py

@@ -71,7 +71,7 @@ class DatasetAssociation:
         cls,
         result: GeneralQueryResults,
         dataset_type: DatasetType,
-        collection_info: Mapping[str, CollectionInfo],
+        collection_info: Mapping[str, CollectionInfo] | None = None,
     ) -> Iterator[DatasetAssociation]:
         """Construct dataset associations from the result of general query.
 
@@ -84,16 +84,25 @@ class DatasetAssociation:
             "timespan" dataset fields for ``dataset_type``.
         dataset_type : `DatasetType`
             Dataset type, query has to include this dataset type.
-        collection_info : `~collections.abc.Mapping` [`str`, `CollectionInfo`]
+        collection_info : `~collections.abc.Mapping` \
+                [`str`, `CollectionInfo`], optional
             Mapping from collection name to information about it for all
-            collections that may appear in the query results.
+            collections that may appear in the query results.  If not provided,
+            timespans for `~CollectionType.RUN` and `~CollectionType.TAGGED`
+            collections will be bounded, instead of `None`; this is actually
+            more consistent with how those timespans are used elsewhere in the
+            query system, but is a change from how `DatasetAssocation` has
+            historically worked.
         """
         timespan_key = f"{dataset_type.name}.timespan"
         collection_key = f"{dataset_type.name}.collection"
         for _, refs, row_dict in result.iter_tuples(dataset_type):
             collection = row_dict[collection_key]
             timespan = row_dict[timespan_key]
-            if collection_info[collection].type is not CollectionType.CALIBRATION:
+            if (
+                collection_info is not None
+                and collection_info[collection].type is not CollectionType.CALIBRATION
+            ):
                 # This behavior is for backwards compatibility only; in most
                 # contexts it makes sense to consider the timespan of a RUN
                 # or TAGGED collection to be unbounded, not None, and that's

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/_registry_shim.py

@@ -266,14 +266,20 @@ class RegistryShim(RegistryBase):
         # Docstring inherited from a base class.
         return self._registry.insertDatasets(datasetType, dataIds, run, expand, idGenerationMode)
 
-    def _importDatasets(self, datasets: Iterable[DatasetRef], expand: bool = True) -> list[DatasetRef]:
+    def _importDatasets(
+        self, datasets: Iterable[DatasetRef], expand: bool = True, assume_new: bool = False
+    ) -> list[DatasetRef]:
         # Docstring inherited from a base class.
-        return self._registry._importDatasets(datasets, expand)
+        return self._registry._importDatasets(datasets, expand, assume_new)
 
     def getDataset(self, id: DatasetId) -> DatasetRef | None:
         # Docstring inherited from a base class.
         return self._registry.getDataset(id)
 
+    def _fetch_run_dataset_ids(self, run: str) -> list[DatasetId]:
+        # Docstring inherited.
+        return self._registry._fetch_run_dataset_ids(run)
+
     def removeDatasets(self, refs: Iterable[DatasetRef]) -> None:
         # Docstring inherited from a base class.
         self._registry.removeDatasets(refs)

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/configs/datastores/formatters.yaml

@@ -87,6 +87,7 @@ SpectractorSpectrum: lsst.atmospec.formatters.SpectractorSpectrumFormatter
 SpectractorImage: lsst.atmospec.formatters.SpectractorImageFormatter
 SpectractorFitParameters: lsst.atmospec.formatters.SpectractorFitParametersFormatter
 ScarletModelData: lsst.meas.extensions.scarlet.io.ScarletModelFormatter
+LsstScarletModelData: lsst.meas.extensions.scarlet.io.ScarletModelFormatter
 MetricMeasurementBundle: lsst.daf.butler.formatters.json.JsonFormatter
 MultipleCellCoadd: lsst.cell_coadds.CellCoaddFitsFormatter
 NNModelPackagePayload: lsst.meas.transiNet.modelPackages.NNModelPackageFormatter

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/configs/storageClasses.yaml

@@ -412,6 +412,13 @@ storageClasses:
     parameters:
       - blend_id
     delegate: lsst.meas.extensions.scarlet.io.ScarletModelDelegate
+  LsstScarletModelData:
+    pytype: lsst.meas.extensions.scarlet.io.LsstScarletModelData
+    converters:
+      lsst.scarlet.lite.io.model_data.ScarletModelData: lsst.meas.extensions.scarlet.io.utils.scarlet_model_to_lsst_scarlet_model
+    parameters:
+      - blend_id
+    delegate: lsst.meas.extensions.scarlet.io.ScarletModelDelegate
   MetricMeasurementBundle:
     pytype: lsst.analysis.tools.interfaces.MetricMeasurementBundle
   MultipleCellCoadd:

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/datastores/fileDatastore.py

@@ -1874,7 +1874,7 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
 
         # Have to handle trustGetRequest mode by checking for the existence
         # of the missing refs on disk.
-        if missing_refs:
+        if missing_refs and not predict:
             dataset_existence = self._mexists_check_expected(missing_refs, None)
             really_missing = set()
             not_missing = set()
@@ -3218,7 +3218,7 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
             return ref
         dataset_type = self._retrieve_dataset_method(ref.datasetType.name)
         if dataset_type is not None:
-            ref = ref.overrideStorageClass(dataset_type.storageClass)
+            ref = ref.overrideStorageClass(dataset_type.storageClass_name)
         return ref
 
     def get_opaque_table_definitions(self) -> Mapping[str, DatastoreOpaqueTable]:

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/direct_butler/_direct_butler.py

@@ -2107,7 +2107,7 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
         dry_run: bool = False,
     ) -> _ImportDatasetsInfo:
         # Docstring inherited.
-        if not self.isWriteable():
+        if not self.isWriteable() and not dry_run:
             raise TypeError("Butler is read-only.")
 
         # Will iterate through the refs multiple times so need to convert
@@ -2312,7 +2312,7 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
     ) -> collections.abc.Collection[DatasetRef]:
         # Docstring inherited.
         source_refs = list(source_refs)
-        if not self.isWriteable():
+        if not self.isWriteable() and not dry_run:
             raise TypeError("Butler is read-only.")
 
         progress = Progress("lsst.daf.butler.Butler.transfer_from", level=VERBOSE)

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/json.py

@@ -68,7 +68,7 @@ def to_json_pydantic(self: SupportsSimple, minimal: bool = False) -> str:
 
 def from_json_pydantic(
     cls_: type[SupportsSimple],
-    json_str: str,
+    json_str: str | bytes | bytearray,
     universe: DimensionUniverse | None = None,
     registry: Registry | None = None,
 ) -> SupportsSimple:
@@ -78,7 +78,7 @@ def from_json_pydantic(
     ----------
     cls_ : `type` of `SupportsSimple`
         The Python type being created.
-    json_str : `str`
+    json_str : `str` or `bytes` or `bytearray`
         The JSON string representing this object.
     universe : `DimensionUniverse` or `None`, optional
         The universe required to instantiate some models. Required if

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/registry/_registry.py

@@ -631,57 +631,55 @@ class Registry(ABC):
         self,
         datasets: Iterable[DatasetRef],
         expand: bool = True,
+        assume_new: bool = False,
     ) -> list[DatasetRef]:
         """Import one or more datasets into the `Registry`.
 
-        Difference from `insertDatasets` method is that this method accepts
-        `DatasetRef` instances which should already be resolved and have a
-        dataset ID. If registry supports globally-unique dataset IDs (e.g.
-        `uuid.UUID`) then datasets which already exist in the registry will be
-        ignored if imported again.
+        This differs from `insertDatasets` method in that this method accepts
+        `DatasetRef` instances, which already have a dataset ID.
 
         Parameters
         ----------
         datasets : `~collections.abc.Iterable` of `DatasetRef`
             Datasets to be inserted. All `DatasetRef` instances must have
-            identical ``datasetType`` and ``run`` attributes. ``run``
+            identical ``run`` attributes. ``run``
             attribute can be `None` and defaults to ``self.defaults.run``.
             Datasets can specify ``id`` attribute which will be used for
-            inserted datasets. All dataset IDs must have the same type
-            (`int` or `uuid.UUID`), if type of dataset IDs does not match
-            configured backend then IDs will be ignored and new IDs will be
-            generated by backend.
+            inserted datasets.
+            Datasets can be of multiple dataset types, but all the dataset
+            types must have the same set of dimensions.
         expand : `bool`, optional
             If `True` (default), expand data IDs as they are inserted.  This is
             necessary in general, but it may be disabled if the caller can
             guarantee this is unnecessary.
+        assume_new : `bool`, optional
+            If `True`, assume datasets are new.  If `False`, datasets that are
+            identical to an existing one are ignored.
 
         Returns
         -------
         refs : `list` of `DatasetRef`
-            Resolved `DatasetRef` instances for all given data IDs (in the same
-            order). If any of ``datasets`` has an ID which already exists in
-            the database then it will not be inserted or updated, but a
-            resolved `DatasetRef` will be returned for it in any case.
+            `DatasetRef` instances for all given data IDs (in the same order).
+            If any of ``datasets`` has an ID which already exists in the
+            database then it will not be inserted or updated, but a
+            `DatasetRef` will be returned for it in any case.
 
         Raises
         ------
         lsst.daf.butler.registry.NoDefaultCollectionError
             Raised if ``run`` is `None` and ``self.defaults.run`` is `None`.
         lsst.daf.butler.registry.DatasetTypeError
-            Raised if datasets correspond to more than one dataset type or
-            dataset type is not known to registry.
+            Raised if a dataset type is not known to registry.
         lsst.daf.butler.registry.ConflictingDefinitionError
             If a dataset with the same dataset type and data ID as one of those
-            given already exists in ``run``.
+            given already exists in ``run``, or if ``assume_new=True`` and at
+            least one dataset is not new.
         lsst.daf.butler.registry.MissingCollectionError
             Raised if ``run`` does not exist in the registry.
 
         Notes
         -----
-        This method is considered package-private and internal to Butler
-        implementation. Clients outside daf_butler package should not use this
-        method.
+        This method is considered middleware-internal.
         """
         raise NotImplementedError()
 
@@ -702,6 +700,27 @@ class Registry(ABC):
         """
         raise NotImplementedError()
 
+    @abstractmethod
+    def _fetch_run_dataset_ids(self, run: str) -> list[DatasetId]:
+        """Return the IDs of all datasets in the given ``RUN``
+        collection.
+
+        Parameters
+        ----------
+        run : `str`
+            Name of the collection.
+
+        Returns
+        -------
+        dataset_ids : `list` [`uuid.UUID`]
+            List of dataset IDs.
+
+        Notes
+        -----
+        This is a middleware-internal interface.
+        """
+        raise NotImplementedError()
+
     @abstractmethod
     def removeDatasets(self, refs: Iterable[DatasetRef]) -> None:
         """Remove datasets from the Registry.

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/registry/datasets/byDimensions/_manager.py

@@ -617,6 +617,14 @@ class ByDimensionsDatasetRecordStorageManagerUUID(DatasetRecordStorageManager):
             dataset_type_names = set(get_dataset_type_name(dt) for dt in dataset_types)
         return self._summaries.fetch_summaries(collections, dataset_type_names, self._dataset_type_from_row)
 
+    def fetch_run_dataset_ids(self, run: RunRecord) -> list[DatasetId]:
+        # Docstring inherited.
+        sql = sqlalchemy.select(self._static.dataset.c.id).where(
+            self._static.dataset.c[self._run_key_column] == run.key
+        )
+        with self._db.query(sql) as result:
+            return list(result.scalars())
+
     def ingest_date_dtype(self) -> type:
         """Return type of the ``ingest_date`` column."""
         schema_version = self.newSchemaVersion()
@@ -698,7 +706,7 @@ class ByDimensionsDatasetRecordStorageManagerUUID(DatasetRecordStorageManager):
             for dataId, row in zip(data_id_list, rows, strict=True)
         ]
 
-    def import_(self, run: RunRecord, refs: list[DatasetRef]) -> None:
+    def import_(self, run: RunRecord, refs: list[DatasetRef], assume_new: bool = False) -> None:
         # Docstring inherited from DatasetRecordStorageManager.
         if not refs:
             # Just in case an empty mapping is provided we want to avoid
@@ -721,7 +729,6 @@ class ByDimensionsDatasetRecordStorageManagerUUID(DatasetRecordStorageManager):
             "Table cache should have been populated when looking up dataset types"
         )
         tags_table = self._get_tags_table(dynamic_tables)
-
         # Current timestamp, type depends on schema version.
         if self._use_astropy_ingest_date:
             # Astropy `now()` precision should be the same as `now()` which
@@ -729,11 +736,8 @@ class ByDimensionsDatasetRecordStorageManagerUUID(DatasetRecordStorageManager):
             timestamp = sqlalchemy.sql.literal(astropy.time.Time.now(), type_=ddl.AstropyTimeNsecTai)
         else:
             timestamp = sqlalchemy.sql.literal(datetime.datetime.now(datetime.UTC))
-
-        # We'll insert all new rows into a temporary table
-        table_spec = makeTagTableSpec(dimensions, type(self._collections), constraints=False)
         collection_fkey_name = self._collections.getCollectionForeignKeyName()
-        tmpRows = [
+        tags_rows = [
             {
                 "dataset_type_id": dataset_type_storage[ref.datasetType.name].dataset_type_id,
                 collection_fkey_name: run.key,
@@ -742,9 +746,29 @@ class ByDimensionsDatasetRecordStorageManagerUUID(DatasetRecordStorageManager):
             }
             for ref in refs
         ]
+        if assume_new:
+            self._import_new(run, refs, dataset_type_storage, tags_table, tags_rows, timestamp)
+        else:
+            self._import_guarded(
+                run, refs, dimensions, dataset_type_storage, tags_table, tags_rows, timestamp
+            )
+
+    def _import_guarded(
+        self,
+        run: RunRecord,
+        refs: list[DatasetRef],
+        dimensions: DimensionGroup,
+        dataset_type_storage: dict[str, _DatasetRecordStorage],
+        tags_table: sqlalchemy.Table,
+        tags_rows: list[dict[str, object]],
+        timestamp: sqlalchemy.BindParameter[astropy.time.Time | datetime.datetime],
+    ) -> None:
+        # We'll insert all new rows into a temporary table
+        table_spec = makeTagTableSpec(dimensions, type(self._collections), constraints=False)
+        collection_fkey_name = self._collections.getCollectionForeignKeyName()
         with self._db.transaction(for_temp_tables=True), self._db.temporary_table(table_spec) as tmp_tags:
             # store all incoming data in a temporary table
-            self._db.insert(tmp_tags, *tmpRows)
+            self._db.insert(tmp_tags, *tags_rows)
             # There are some checks that we want to make for consistency
             # of the new datasets with existing ones.
             self._validate_import(dimensions, tags_table, tmp_tags, run)
@@ -764,17 +788,19 @@ class ByDimensionsDatasetRecordStorageManagerUUID(DatasetRecordStorageManager):
                     timestamp.label("ingest_date"),
                 ),
             )
-            # Update the summary tables for this collection in case this
-            # is the first time this dataset type or these governor values
-            # will be inserted there.
-            summary = CollectionSummary()
-            summary.add_datasets(refs)
-            self._summaries.update(
-                run, [storage.dataset_type_id for storage in dataset_type_storage.values()], summary
-            )
+            self._update_summaries(run, refs, dataset_type_storage)
             # Copy from temp table into tags table.
             self._db.insert(tags_table, select=tmp_tags.select())
 
+    def _update_summaries(
+        self, run: RunRecord, refs: list[DatasetRef], dataset_type_storage: dict[str, _DatasetRecordStorage]
+    ) -> None:
+        summary = CollectionSummary()
+        summary.add_datasets(refs)
+        self._summaries.update(
+            run, [storage.dataset_type_id for storage in dataset_type_storage.values()], summary
+        )
+
     def _validate_import(
         self,
         dimensions: DimensionGroup,
@@ -899,6 +925,29 @@ class ByDimensionsDatasetRecordStorageManagerUUID(DatasetRecordStorageManager):
                     f"but ID {row.new_dataset_id} in new collection {new_collection!r}."
                 )
 
+    def _import_new(
+        self,
+        run: RunRecord,
+        refs: list[DatasetRef],
+        dataset_type_storage: dict[str, _DatasetRecordStorage],
+        tags_table: sqlalchemy.Table,
+        tags_rows: list[dict[str, object]],
+        timestamp: sqlalchemy.BindParameter[astropy.time.Time | datetime.datetime],
+    ) -> None:
+        static_rows = [
+            {
+                "id": ref.id,
+                "dataset_type_id": dataset_type_storage[ref.datasetType.name].dataset_type_id,
+                self._run_key_column: run.key,
+                "ingest_date": timestamp.value,
+            }
+            for ref in refs
+        ]
+        with self._db.transaction():
+            self._db.insert(self._static.dataset, *static_rows)
+            self._update_summaries(run, refs, dataset_type_storage)
+            self._db.insert(tags_table, *tags_rows)
+
     def delete(self, datasets: Iterable[DatasetId | DatasetRef]) -> None:
         # Docstring inherited from DatasetRecordStorageManager.
         # Only delete from common dataset table; ON DELETE foreign key clauses

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/registry/interfaces/_datasets.py

@@ -384,6 +384,23 @@ class DatasetRecordStorageManager(VersionedExtension):
         """
         raise NotImplementedError()
 
+    @abstractmethod
+    def fetch_run_dataset_ids(self, run: RunRecord) -> list[DatasetId]:
+        """Return the IDs of all datasets in the given ``RUN``
+        collection.
+
+        Parameters
+        ----------
+        run : `RunRecord`
+            Record describing the collection.
+
+        Returns
+        -------
+        dataset_ids : `list` [`uuid.UUID`]
+            List of dataset IDs.
+        """
+        raise NotImplementedError()
+
     @abstractmethod
     def ingest_date_dtype(self) -> type:
         """Return type of the ``ingest_date`` column."""
@@ -424,7 +441,7 @@ class DatasetRecordStorageManager(VersionedExtension):
         raise NotImplementedError()
 
     @abstractmethod
-    def import_(self, run: RunRecord, refs: list[DatasetRef]) -> None:
+    def import_(self, run: RunRecord, refs: list[DatasetRef], assume_new: bool = False) -> None:
         """Insert one or more dataset entries into the database.
 
         Parameters
@@ -435,6 +452,9 @@ class DatasetRecordStorageManager(VersionedExtension):
         refs : `list` [ `DatasetRef` ]
             List of datasets to be be inserted.  All of the ``DatasetRef``
             ``run`` attributes must match the ``run`` parameter.
+        assume_new : `bool`, optional
+            If `True`, assume all datasets are new and skip conflict resolution
+            logic.
         """
         raise NotImplementedError()
 

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/registry/queries/_query_common.py

@@ -58,6 +58,9 @@ class CommonQueryArguments:
     def replaceCollections(self, collections: list[str]) -> CommonQueryArguments:
         return dataclasses.replace(self, collections=collections)
 
+    def replaceDatasetTypes(self, dataset_types: list[str]) -> CommonQueryArguments:
+        return dataclasses.replace(self, dataset_types=dataset_types)
+
 
 _T = TypeVar("_T", bound=QueryResultsBase)
 _U = TypeVar("_U", bound=QueryResultsBase)

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/registry/queries/_query_datasets.py

@@ -119,7 +119,13 @@ class QueryDriverDatasetRefQueryResults(
 
     @property
     def dataIds(self) -> DataCoordinateQueryResults:
-        raise NotImplementedError()
+        from ._query_data_coordinates import QueryDriverDataCoordinateQueryResults
+
+        args = self._args.replaceDatasetTypes([self._dataset_type.name])
+
+        return QueryDriverDataCoordinateQueryResults(
+            self._butler, dimensions=self._dataset_type.dimensions, expanded=self._expanded, args=args
+        )
 
     def byParentDatasetType(self) -> Iterator[ParentDatasetQueryResults]:
         yield self

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/registry/sql_registry.py

@@ -919,14 +919,12 @@ class SqlRegistry:
         self,
         datasets: Iterable[DatasetRef],
         expand: bool = True,
+        assume_new: bool = False,
     ) -> list[DatasetRef]:
         """Import one or more datasets into the `Registry`.
 
-        Difference from `insertDatasets` method is that this method accepts
-        `DatasetRef` instances which should already be resolved and have a
-        dataset ID. If registry supports globally-unique dataset IDs (e.g.
-        `uuid.UUID`) then datasets which already exist in the registry will be
-        ignored if imported again.
+        This differs from `insertDatasets` method in that this method accepts
+        `DatasetRef` instances, which already have a dataset ID.
 
         Parameters
         ----------
@@ -942,14 +940,17 @@ class SqlRegistry:
             If `True` (default), expand data IDs as they are inserted.  This is
             necessary in general, but it may be disabled if the caller can
             guarantee this is unnecessary.
+        assume_new : `bool`, optional
+            If `True`, assume datasets are new.  If `False`, datasets that are
+            identical to an existing one are ignored.
 
         Returns
         -------
         refs : `list` of `DatasetRef`
-            Resolved `DatasetRef` instances for all given data IDs (in the same
-            order). If any of ``datasets`` has an ID which already exists in
-            the database then it will not be inserted or updated, but a
-            resolved `DatasetRef` will be returned for it in any case.
+            `DatasetRef` instances for all given data IDs (in the same order).
+            If any of ``datasets`` has an ID which already exists in the
+            database then it will not be inserted or updated, but a
+            `DatasetRef` will be returned for it in any case.
 
         Raises
         ------
@@ -959,15 +960,14 @@ class SqlRegistry:
             Raised if a dataset type is not known to registry.
         lsst.daf.butler.registry.ConflictingDefinitionError
             If a dataset with the same dataset type and data ID as one of those
-            given already exists in ``run``.
+            given already exists in ``run``, or if ``assume_new=True`` and at
+            least one dataset is not new.
         lsst.daf.butler.registry.MissingCollectionError
             Raised if ``run`` does not exist in the registry.
 
         Notes
         -----
-        This method is considered package-private and internal to Butler
-        implementation. Clients outside daf_butler package should not use this
-        method.
+        This method is considered middleware-internal.
         """
         datasets = list(datasets)
         if not datasets:
@@ -994,7 +994,7 @@ class SqlRegistry:
             _LOG.debug("Finished expanding data IDs")
 
         try:
-            self._managers.datasets.import_(runRecord, datasets)
+            self._managers.datasets.import_(runRecord, datasets, assume_new=assume_new)
             if self._managers.obscore:
                 self._managers.obscore.add_datasets(datasets)
         except sqlalchemy.exc.IntegrityError as err:
@@ -1003,7 +1003,8 @@ class SqlRegistry:
                 f"one or more datasets into collection '{run}'. "
                 "This probably means a dataset with the same data ID "
                 "and dataset type already exists, but it may also mean a "
-                "dimension row is missing."
+                "dimension row is missing, or the dataset was assumed to be "
+                "new when it was not."
             ) from err
         return datasets
 
@@ -1023,6 +1024,29 @@ class SqlRegistry:
         """
         return self._managers.datasets.getDatasetRef(id)
 
+    def _fetch_run_dataset_ids(self, run: str) -> list[DatasetId]:
+        """Return the IDs of all datasets in the given ``RUN``
+        collection.
+
+        Parameters
+        ----------
+        run : `str`
+            Name of the collection.
+
+        Returns
+        -------
+        dataset_ids : `list` [`uuid.UUID`]
+            List of dataset IDs.
+
+        Notes
+        -----
+        This is a middleware-internal interface.
+        """
+        run_record = self._managers.collections.find(run)
+        if not isinstance(run_record, RunRecord):
+            raise CollectionTypeError(f"{run!r} is not a RUN collection.")
+        return self._managers.datasets.fetch_run_dataset_ids(run_record)
+
     @transactional
     def removeDatasets(self, refs: Iterable[DatasetRef]) -> None:
         """Remove datasets from the Registry.

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/registry/tests/_registry.py

@@ -86,6 +86,7 @@ from .._exceptions import (
     OrphanedRecordError,
 )
 from ..interfaces import ButlerAttributeExistsError, ReadOnlyDatabaseError
+from ..queries import ParentDatasetQueryResults
 from ..sql_registry import SqlRegistry
 
 _T = TypeVar("_T")
@@ -502,6 +503,15 @@ class RegistryTests(ABC):
         registry.removeDatasets([ref])
         self.assertIsNone(registry.findDataset(datasetType, dataId, collections=[run]))
 
+    def test_fetch_run_dataset_ids(self):
+        butler = self.make_butler()
+        registry = butler._registry
+        self.load_data(butler, "base.yaml", "datasets.yaml")
+        dataset_ids = registry._fetch_run_dataset_ids("imported_r")
+        self.assertEqual(len(dataset_ids), 7)
+        refs = butler.query_all_datasets("imported_r")
+        self.assertCountEqual(dataset_ids, [ref.id for ref in refs])
+
     def testFindDataset(self):
         """Tests for `SqlRegistry.findDataset`."""
         butler = self.make_butler()
@@ -732,10 +742,15 @@ class RegistryTests(ABC):
         dataIdFlat1 = {"instrument": "Cam1", "detector": 1, "physical_filter": "Cam1-G", "band": "g"}
 
         ref = DatasetRef(datasetTypeBias, dataIdBias1, run="run0")
-        (ref1,) = registry._importDatasets([ref])
+        (ref1,) = registry._importDatasets([ref], assume_new=True)
         # UUID is used without change
         self.assertEqual(ref.id, ref1.id)
 
+        # Inserting this ref with assume_new=True should fail, since this
+        # dataset exists.
+        with self.assertRaises(ConflictingDefinitionError):
+            registry._importDatasets([ref], assume_new=True)
+
         # All different failure modes
         refs = (
             # Importing same DatasetRef with different dataset ID is an error
@@ -3925,11 +3940,10 @@ class RegistryTests(ABC):
         )
         self.assertIsNone(detectors[0].records["detector"].purpose)
 
-        datasets = list(
-            registry.queryDatasets(
-                "flat", collections="imported_g", where="instrument = 'Cam1' and detector <= 3"
-            ).expanded()
-        )
+        datasets_query = registry.queryDatasets(
+            "flat", collections="imported_g", where="instrument = 'Cam1' and detector <= 3"
+        ).expanded()
+        datasets = list(datasets_query)
         datasets.sort(key=lambda ref: ref.dataId["detector"])
         self.assertEqual(len(datasets), 2)
         self.assertEqual(datasets[0].id, uuid.UUID("60c8a65c-7290-4c38-b1de-e3b1cdcf872d"))
@@ -3938,6 +3952,13 @@ class RegistryTests(ABC):
         self.assertEqual(datasets[0].dataId.records["detector"].full_name, "Ab")
         self.assertEqual(datasets[1].dataId.records["detector"].full_name, "Ba")
         self.assertEqual(datasets[0].dataId.records["instrument"].visit_system, 1)
+        assert isinstance(datasets_query, ParentDatasetQueryResults)
+        data_ids = list(datasets_query.dataIds)
+        data_ids.sort(key=lambda data_id: data_id["detector"])
+        self.assertEqual(len(data_ids), 2)
+        self.assertEqual(data_ids[0].records["detector"].full_name, "Ab")
+        self.assertEqual(data_ids[1].records["detector"].full_name, "Ba")
+        self.assertEqual(data_ids[0].records["instrument"].visit_system, 1)
 
         # None of the datasets in the test data include any uncached
         # dimensions, so we have to set one up.

{lsst_daf_butler-29.2025.4200 → lsst_daf_butler-29.2025.4400}/python/lsst/daf/butler/remote_butler/_registry.py

@@ -224,12 +224,16 @@ class RemoteButlerRegistry(RegistryBase):
         self,
         datasets: Iterable[DatasetRef],
         expand: bool = True,
+        assume_new: bool = False,
     ) -> list[DatasetRef]:
         raise NotImplementedError()
 
     def getDataset(self, id: DatasetId) -> DatasetRef | None:
         return self._butler.get_dataset(id)
 
+    def _fetch_run_dataset_ids(self, run: str) -> list[DatasetId]:
+        raise NotImplementedError()
+
     def removeDatasets(self, refs: Iterable[DatasetRef]) -> None:
         raise NotImplementedError()