lsst-daf-butler 29.2025.2000__tar.gz → 29.2025.2100__tar.gz

{lsst_daf_butler-29.2025.2000/python/lsst_daf_butler.egg-info → lsst_daf_butler-29.2025.2100}/PKG-INFO

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

@@ -90,6 +90,10 @@ class SpecificButlerDataset:
     dataset: DatasetRef | None
 
 
+class _DeprecatedDefault:
+    """Default value for a deprecated parameter."""
+
+
 class Butler(LimitedButler):  # numpydoc ignore=PR02
     """Interface for data butler and factory for Butler instances.
 
@@ -1288,7 +1292,13 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
         raise NotImplementedError()
 
     @abstractmethod
-    def removeRuns(self, names: Iterable[str], unstore: bool = True) -> None:
+    def removeRuns(
+        self,
+        names: Iterable[str],
+        unstore: bool | type[_DeprecatedDefault] = _DeprecatedDefault,
+        *,
+        unlink_from_chains: bool = False,
+    ) -> None:
         """Remove one or more `~CollectionType.RUN` collections and the
         datasets within them.
 
@@ -1301,7 +1311,13 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
             they are present, and attempt to rollback the registry deletions if
             datastore deletions fail (which may not always be possible).  If
             `False`, datastore records for these datasets are still removed,
-            but any artifacts (e.g. files) will not be.
+            but any artifacts (e.g. files) will not be. This parameter is now
+            deprecated and no longer has any effect. Files are always deleted
+            from datastores unless they were ingested using full URIs.
+        unlink_from_chains : `bool`, optional
+            If `True` remove the RUN collection from any chains prior to
+            removing the RUN. If `False` the removal will fail if any chains
+            still refer to the RUN.
 
         Raises
         ------
@@ -1374,7 +1390,14 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
         raise NotImplementedError()
 
     @abstractmethod
-    def ingest_zip(self, zip_file: ResourcePathExpression, transfer: str = "auto") -> None:
+    def ingest_zip(
+        self,
+        zip_file: ResourcePathExpression,
+        transfer: str = "auto",
+        *,
+        transfer_dimensions: bool = False,
+        dry_run: bool = False,
+    ) -> None:
         """Ingest a Zip file into this butler.
 
         The Zip file must have been created by `retrieve_artifacts_zip`.
@@ -1385,10 +1408,17 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
             Path to the Zip file.
         transfer : `str`, optional
             Method to use to transfer the Zip into the datastore.
+        transfer_dimensions : `bool`, optional
+            If `True`, dimension record data associated with the new datasets
+            will be transferred from the Zip file, if present.
+        dry_run : `bool`, optional
+            If `True` the ingest will be processed without any modifications
+            made to the target butler and as if the target butler did not
+            have any of the datasets.
 
         Notes
         -----
-        Run collections are created as needed.
+        Run collections and dataset types are created as needed.
         """
         raise NotImplementedError()
 

{lsst_daf_butler-29.2025.2000 → lsst_daf_butler-29.2025.2100}/python/lsst/daf/butler/_butler_collections.py

@@ -108,6 +108,10 @@ class ButlerCollections(ABC, Sequence):
         """Collection defaults associated with this butler."""
         raise NotImplementedError("Defaults must be implemented by a subclass")
 
+    def __str__(self) -> str:
+        """Return string representation."""
+        return f"{self.__class__.__name__}(defaults={self.defaults})"
+
     @abstractmethod
     def extend_chain(self, parent_collection_name: str, child_collection_names: str | Iterable[str]) -> None:
         """Add children to the end of a CHAINED collection.

{lsst_daf_butler-29.2025.2000 → lsst_daf_butler-29.2025.2100}/python/lsst/daf/butler/cli/cmd/commands.py

@@ -829,6 +829,12 @@ def export_calibs(*args: Any, **kwargs: Any) -> None:
 @repo_argument(required=True)
 @click.argument("zip", required=True)
 @transfer_option()
+@transfer_dimensions_option(
+    default=False, help="Attempt to register missing dimension records during ingest."
+)
+@click.option(
+    "--dry-run/--no-dry-run", default=False, help="Enable dry run mode and do not ingest any datasets."
+)
 def ingest_zip(**kwargs: Any) -> None:
     """Ingest a Zip file created by retrieve-artifacts.
 

{lsst_daf_butler-29.2025.2000 → lsst_daf_butler-29.2025.2100}/python/lsst/daf/butler/datastore/_datastore.py

@@ -1082,7 +1082,7 @@ class Datastore(metaclass=ABCMeta):
         raise NotImplementedError()
 
     @abstractmethod
-    def ingest_zip(self, zip_path: ResourcePath, transfer: str | None) -> None:
+    def ingest_zip(self, zip_path: ResourcePath, transfer: str | None, *, dry_run: bool = False) -> None:
         """Ingest an indexed Zip file and contents.
 
         The Zip file must have an index file as created by `retrieveArtifacts`.
@@ -1093,6 +1093,10 @@ class Datastore(metaclass=ABCMeta):
             Path to the Zip file.
         transfer : `str`
             Method to use for transferring the Zip file into the datastore.
+        dry_run : `bool`, optional
+            If `True` the ingest will be processed without any modifications
+            made to the target datastore and as if the target datastore did not
+            have any of the datasets.
         """
         raise NotImplementedError()
 
@@ -1504,7 +1508,7 @@ class NullDatastore(Datastore):
     def getURI(self, datasetRef: DatasetRef, predict: bool = False) -> ResourcePath:
         raise FileNotFoundError("This is a no-op datastore that can not access a real datastore")
 
-    def ingest_zip(self, zip_path: ResourcePath, transfer: str | None) -> None:
+    def ingest_zip(self, zip_path: ResourcePath, transfer: str | None, *, dry_run: bool = False) -> None:
         raise NotImplementedError("Can only ingest a Zip into a real datastore.")
 
     def retrieveArtifacts(

{lsst_daf_butler-29.2025.2000 → lsst_daf_butler-29.2025.2100}/python/lsst/daf/butler/datastores/chainedDatastore.py

@@ -32,7 +32,6 @@ from __future__ import annotations
 __all__ = ("ChainedDatastore",)
 
 import itertools
-import logging
 import time
 import warnings
 from collections.abc import Callable, Collection, Iterable, Mapping, Sequence
@@ -51,13 +50,14 @@ from lsst.daf.butler.datastore.record_data import DatastoreRecordData
 from lsst.daf.butler.datastores.file_datastore.retrieve_artifacts import ArtifactIndexInfo, ZipIndex
 from lsst.resources import ResourcePath
 from lsst.utils import doImportType
+from lsst.utils.logging import getLogger
 
 if TYPE_CHECKING:
     from lsst.daf.butler import Config, DatasetProvenance, DatasetType, LookupKey, StorageClass
     from lsst.daf.butler.registry.interfaces import DatasetIdRef, DatastoreRegistryBridgeManager
     from lsst.resources import ResourcePathExpression
 
-log = logging.getLogger(__name__)
+log = getLogger(__name__)
 
 
 class _IngestPrepData(Datastore.IngestPrepData):
@@ -912,7 +912,7 @@ class ChainedDatastore(Datastore):
 
         return merged_artifact_map
 
-    def ingest_zip(self, zip_path: ResourcePath, transfer: str | None) -> None:
+    def ingest_zip(self, zip_path: ResourcePath, transfer: str | None, *, dry_run: bool = False) -> None:
         """Ingest an indexed Zip file and contents.
 
         The Zip file must have an index file as created by `retrieveArtifacts`.
@@ -923,6 +923,10 @@ class ChainedDatastore(Datastore):
             Path to the Zip file.
         transfer : `str`
             Method to use for transferring the Zip file into the datastore.
+        dry_run : `bool`, optional
+            If `True` the ingest will be processed without any modifications
+            made to the target datastore and as if the target datastore did not
+            have any of the datasets.
 
         Notes
         -----
@@ -966,7 +970,7 @@ class ChainedDatastore(Datastore):
                 log.debug("Datastore %s skipping zip ingest due to constraints", datastore.name)
                 continue
             try:
-                datastore.ingest_zip(zip_path, transfer=transfer)
+                datastore.ingest_zip(zip_path, transfer=transfer, dry_run=dry_run)
             except NotImplementedError:
                 continue
             except Exception as e:
@@ -1239,102 +1243,65 @@ class ChainedDatastore(Datastore):
         dry_run: bool = False,
     ) -> tuple[set[DatasetRef], set[DatasetRef]]:
         # Docstring inherited
-        # mypy does not understand "type(self) is not type(source)"
-        if isinstance(source_datastore, ChainedDatastore):
-            # Both the source and destination are chained datastores.
-            source_datastores = tuple(source_datastore.datastores)
-        else:
-            # The source datastore is different, forward everything to the
-            # child datastores.
-            source_datastores = (source_datastore,)
-
         if not refs:
-            # Nothing to transfer.
             return set(), set()
 
-        # Need to know the set of all possible refs that could be transferred.
-        remaining_refs = set(refs)
-
-        missing_from_source: set[DatasetRef] | None = None
-        all_accepted = set()
+        # Assume that each child datastore knows how to look inside a chained
+        # datastore for compatible datastores (and so there is no need to
+        # unpack the source datastores here).
+        # Need to decide if a ref accepted by one datastore should be sent to
+        # later datastores (as is done in put()). More efficient to filter out
+        # accepted datasets.
+        if artifact_existence is None:
+            artifact_existence = {}
+        available_refs = set(refs)
+        accepted: set[DatasetRef] = set()
+        rejected: set[DatasetRef] = set()
         nsuccess = 0
-        for source_child in source_datastores:
-            # If we are reading from a chained datastore, it's possible that
-            # only a subset of the datastores know about the dataset. We can't
-            # ask the receiving datastore to copy it when it doesn't exist
-            # so we have to filter again based on what the source datastore
-            # understands.
-            known_to_source = source_child.knows_these(list(refs))
-
-            # Need to know that there is a possibility that some of these
-            # datasets exist but are unknown to the source datastore if
-            # trust is enabled.
-            if getattr(source_child, "trustGetRequest", False):
-                unknown = [ref for ref, known in known_to_source.items() if not known]
-                existence = source_child.mexists(unknown, artifact_existence)
-                for ref, exists in existence.items():
-                    known_to_source[ref] = exists
-
-            missing = {ref for ref, known in known_to_source.items() if not known}
-            if missing:
-                if missing_from_source is None:
-                    missing_from_source = missing
-                else:
-                    missing_from_source &= missing
-
-            # Try to transfer from each source datastore to each child
-            # datastore. Have to make sure we don't transfer something
-            # we've already transferred to this destination on later passes.
-
-            # Filter the initial list based on the datasets we have
-            # not yet transferred.
-            these_refs = []
-            for ref in refs:
-                if ref in remaining_refs and known_to_source[ref]:
-                    these_refs.append(ref)
-
-            if not these_refs:
-                # Already transferred all datasets known to this datastore.
-                continue
 
-            for datastore, constraints in zip(self.datastores, self.datastoreConstraints, strict=True):
-                if constraints is not None:
-                    filtered_refs = []
-                    for ref in these_refs:
-                        if constraints.isAcceptable(ref):
-                            filtered_refs.append(ref)
-                        else:
-                            log.debug("Rejecting ref by constraints: %s", ref)
-                else:
-                    filtered_refs = list(these_refs)
-                try:
-                    accepted, _ = datastore.transfer_from(
-                        source_child,
-                        filtered_refs,
-                        transfer,
-                        artifact_existence,
-                        dry_run=dry_run,
-                    )
-                except (TypeError, NotImplementedError):
-                    # The datastores were incompatible.
-                    continue
-                else:
-                    nsuccess += 1
+        log.debug("Initiating transfer to chained datastore %s from %s", self.name, source_datastore.name)
+        for datastore in self.datastores:
+            # Rejections from this datastore might be acceptances in the next.
+            # We add them all up but then recalculate at the end.
+            if not available_refs:
+                break
+            log.verbose("Transferring %d datasets to %s from chain", len(available_refs), datastore.name)
 
-                # Remove the accepted datasets from those remaining.
-                remaining_refs = remaining_refs - accepted
+            try:
+                current_accepted, current_rejected = datastore.transfer_from(
+                    source_datastore,
+                    available_refs,
+                    transfer=transfer,
+                    artifact_existence=artifact_existence,
+                    dry_run=dry_run,
+                )
+            except (TypeError, NotImplementedError):
+                # The datastores were incompatible.
+                continue
+            else:
+                nsuccess += 1
 
-                # Keep track of everything we have accepted.
-                all_accepted.update(accepted)
+                # Do not send accepted refs to later datastores.
+                available_refs -= current_accepted
 
-        if missing_from_source:
-            for ref in missing_from_source:
-                log.warning("Asked to transfer dataset %s but no file artifacts exist for it", ref)
+                accepted.update(current_accepted)
+                rejected.update(current_rejected)
 
         if nsuccess == 0:
             raise TypeError(f"None of the child datastores could accept transfers from {source_datastore!r}")
 
-        return all_accepted, remaining_refs
+        # It's not rejected if some other datastore accepted it.
+        rejected -= accepted
+        log.verbose(
+            "Finished transfer_from %s to %s with %d accepted, %d rejected from %d requested.",
+            source_datastore.name,
+            self.name,
+            len(accepted),
+            len(rejected),
+            len(refs),
+        )
+
+        return accepted, rejected
 
     def get_opaque_table_definitions(self) -> Mapping[str, DatastoreOpaqueTable]:
         # Docstring inherited from the base class.

{lsst_daf_butler-29.2025.2000 → lsst_daf_butler-29.2025.2100}/python/lsst/daf/butler/datastores/fileDatastore.py

@@ -34,6 +34,7 @@ __all__ = ("FileDatastore",)
 import contextlib
 import hashlib
 import logging
+import math
 from collections import defaultdict
 from collections.abc import Callable, Collection, Iterable, Mapping, Sequence
 from typing import TYPE_CHECKING, Any, ClassVar, cast
@@ -1559,7 +1560,8 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
                     # Single chunk but multiple files. Summarize.
                     log.log(
                         log_threshold,
-                        "Number of datasets found in datastore: %d out of %d datasets checked.",
+                        "Number of datasets found in datastore %s: %d out of %d datasets checked.",
+                        self.name,
                         n_found,
                         n_checked,
                     )
@@ -2158,7 +2160,7 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
 
         return artifact_map
 
-    def ingest_zip(self, zip_path: ResourcePath, transfer: str | None) -> None:
+    def ingest_zip(self, zip_path: ResourcePath, transfer: str | None, *, dry_run: bool = False) -> None:
         """Ingest an indexed Zip file and contents.
 
         The Zip file must have an index file as created by `retrieveArtifacts`.
@@ -2169,6 +2171,10 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
             Path to the Zip file.
         transfer : `str`
             Method to use for transferring the Zip file into the datastore.
+        dry_run : `bool`, optional
+            If `True` the ingest will be processed without any modifications
+            made to the target datastore and as if the target datastore did not
+            have any of the datasets.
 
         Notes
         -----
@@ -2219,9 +2225,12 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
                 tgtLocation.uri.dirname().mkdir()
 
             # Transfer the Zip file into the datastore.
-            tgtLocation.uri.transfer_from(
-                zip_path, transfer=transfer, transaction=self._transaction, overwrite=True
-            )
+            if not dry_run:
+                tgtLocation.uri.transfer_from(
+                    zip_path, transfer=transfer, transaction=self._transaction, overwrite=True
+                )
+            else:
+                log.info("Would be copying Zip from %s to %s", zip_path, tgtLocation)
 
         if tgtLocation is None:
             path_in_store = str(zip_path)
@@ -2239,7 +2248,10 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
             for id_ in index_info.ids:
                 artifacts.append((id_to_ref[id_], info))
 
-        self._register_datasets(artifacts, insert_mode=DatabaseInsertMode.INSERT)
+        if not dry_run:
+            self._register_datasets(artifacts, insert_mode=DatabaseInsertMode.INSERT)
+        else:
+            log.info("Would be registering %d artifacts from Zip into datastore", len(artifacts))
 
     def get(
         self,
@@ -2543,10 +2555,24 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
         removed = set()
         if refs:
             selected_ids = {ref.id for ref in refs}
-            n_chunks = 0
-            for chunk in chunk_iterable(selected_ids, chunk_size=50_000):
-                n_chunks += 1
-                log.verbose("Emptying trash for chunk %d of size %d", n_chunks, len(chunk))
+            chunk_size = 50_000
+            n_chunks = math.ceil(len(selected_ids) / chunk_size)
+            chunk_num = 0
+            for chunk in chunk_iterable(selected_ids, chunk_size=chunk_size):
+                chunk_num += 1
+                if n_chunks == 1:
+                    log.verbose(
+                        "Emptying datastore trash for %d dataset%s",
+                        len(chunk),
+                        "s" if len(chunk) != 1 else "",
+                    )
+                else:
+                    log.verbose(
+                        "Emptying datastore trash for chunk %d out of %d of size %d",
+                        chunk_num,
+                        n_chunks,
+                        len(chunk),
+                    )
                 removed.update(
                     self._empty_trash_subset(ignore_errors=ignore_errors, selected_ids=chunk, dry_run=dry_run)
                 )
@@ -2683,9 +2709,10 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
 
             if artifacts_to_keep:
                 log.verbose(
-                    "%d artifact%s were not deleted because they are associated with other datasets",
+                    "%d artifact%s %s not deleted because of association with other datasets",
                     len(artifacts_to_keep),
                     "s" if len(artifacts_to_keep) != 1 else "",
+                    "were" if len(artifacts_to_keep) != 1 else "was",
                 )
 
             if not artifacts_to_delete:
@@ -2763,20 +2790,7 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
         artifact_existence: dict[ResourcePath, bool] | None = None,
         dry_run: bool = False,
     ) -> tuple[set[DatasetRef], set[DatasetRef]]:
-        log.verbose("transfer_from %s to %s", source_datastore.name, self.name)
-        # Docstring inherited
-        if type(self) is not type(source_datastore):
-            raise TypeError(
-                f"Datastore mismatch between this datastore ({type(self)}) and the "
-                f"source datastore ({type(source_datastore)})."
-            )
-
-        # Be explicit for mypy
-        if not isinstance(source_datastore, FileDatastore):
-            raise TypeError(
-                "Can only transfer to a FileDatastore from another FileDatastore, not"
-                f" {type(source_datastore)}"
-            )
+        log.verbose("Transferring %d datasets from %s to %s", len(refs), source_datastore.name, self.name)
 
         # Stop early if "direct" transfer mode is requested. That would
         # require that the URI inside the source datastore should be stored
@@ -2788,6 +2802,128 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
                 " those files are controlled by the other datastore."
             )
 
+        if not refs:
+            return set(), set()
+
+        # Potentially can be transferring from a chain.
+        datastores = getattr(source_datastore, "datastores", [source_datastore])
+
+        incompatible: list[Datastore] = []
+        acceptable: list[FileDatastore] = []
+        for current_source in datastores:
+            if not isinstance(current_source, FileDatastore):
+                incompatible.append(current_source)
+            else:
+                acceptable.append(current_source)
+
+        if len(incompatible) == len(datastores):
+            if len(datastores) == 1:
+                raise TypeError(
+                    "Can only transfer to a FileDatastore from another FileDatastore, not"
+                    f" {get_full_type_name(source_datastore)}"
+                )
+            else:
+                types = [get_full_type_name(d) for d in datastores]
+                raise TypeError(
+                    f"ChainedDatastore encountered that had no FileDatastores. Had {','.join(types)}"
+                )
+
+        if len(acceptable) == 1:
+            # No need to filter in advance since there is only one usable
+            # source datastore.
+            return self._transfer_from(
+                acceptable[0], refs, transfer=transfer, artifact_existence=artifact_existence, dry_run=dry_run
+            )
+
+        # To avoid complaints from the transfer that the source does not have
+        # a ref, partition refs by source datastores, and any unknown to both
+        # are sent to any that support trustGetRequest.
+        unassigned_refs: set[DatasetRef] = set(refs)
+        known_refs: list[set[DatasetRef]] = []
+        for datastore in acceptable:
+            known_to_datastore = {ref for ref, known in datastore.knows_these(refs).items() if known}
+            known_refs.append(known_to_datastore)
+            unassigned_refs -= known_to_datastore
+
+        if unassigned_refs:
+            for datastore, refs_known_to_datastore in zip(acceptable, known_refs, strict=True):
+                if datastore.trustGetRequest:
+                    # Have to check each datastore in turn. If we do not do
+                    # this warnings will be issued further down for datasets
+                    # that are in one and not the other. The existence cache
+                    # will prevent repeat checks.
+                    exist_in_store = datastore.mexists(unassigned_refs, artifact_existence=artifact_existence)
+                    present = {ref for ref, exists in exist_in_store.items() if exists}
+                    refs_known_to_datastore.update(present)
+                    # Only transferring once so do not need to check later
+                    # datastores.
+                    unassigned_refs -= present
+                    log.debug(
+                        "Adding %d missing refs to list for transfer from %s", len(present), datastore.name
+                    )
+
+        if unassigned_refs:
+            log.warning(
+                "Encountered %d dataset%s where no file artifacts exist from the "
+                "source datastore and will be skipped.",
+                len(unassigned_refs),
+                "s" if len(unassigned_refs) != 1 else "",
+            )
+
+        # Once we have accepted refs from one datastore, do not need to try to
+        # transfer them again.
+        accepted: set[DatasetRef] = set()
+        rejected: set[DatasetRef] = set()
+        if artifact_existence is None:
+            artifact_existence = {}
+
+        for current_source, refs_to_transfer in zip(acceptable, known_refs, strict=True):
+            # Do not transfer if already transferred.
+            refs_to_transfer -= accepted
+            # No need to retry something that has already been rejected.
+            refs_to_transfer -= rejected
+
+            if not refs_to_transfer:
+                continue
+
+            log.verbose(
+                "Requesting transfer of %d dataset%s from datastore %s to %s",
+                len(refs_to_transfer),
+                "s" if len(refs_to_transfer) != 1 else "",
+                current_source.name,
+                self.name,
+            )
+            current_accepted, current_rejected = self._transfer_from(
+                current_source,
+                refs_to_transfer,
+                transfer=transfer,
+                artifact_existence=artifact_existence,
+                dry_run=dry_run,
+            )
+
+            accepted.update(current_accepted)
+            rejected.update(current_rejected)
+
+        log.verbose(
+            "Finished transfer_from %s to %s with %d accepted, %d rejected, %d requested",
+            source_datastore.name,
+            self.name,
+            len(accepted),
+            len(rejected),
+            len(refs),
+        )
+
+        return accepted, rejected
+
+    @transactional
+    def _transfer_from(
+        self,
+        source_datastore: FileDatastore,
+        refs: Collection[DatasetRef],
+        transfer: str = "auto",
+        artifact_existence: dict[ResourcePath, bool] | None = None,
+        dry_run: bool = False,
+    ) -> tuple[set[DatasetRef], set[DatasetRef]]:
         # Empty existence lookup if none given.
         if artifact_existence is None:
             artifact_existence = {}

{lsst_daf_butler-29.2025.2000 → lsst_daf_butler-29.2025.2100}/python/lsst/daf/butler/datastores/inMemoryDatastore.py

@@ -523,7 +523,7 @@ class InMemoryDatastore(GenericBaseDatastore[StoredMemoryItemInfo]):
             raise AssertionError(f"Unexpectedly got no URI for in-memory datastore for {ref}")
         return primary
 
-    def ingest_zip(self, zip_path: ResourcePath, transfer: str | None) -> None:
+    def ingest_zip(self, zip_path: ResourcePath, transfer: str | None, *, dry_run: bool = False) -> None:
         raise NotImplementedError("Can only ingest a Zip into a file datastore.")
 
     def retrieveArtifacts(