lsst-daf-butler 29.2025.1900__py3-none-any.whl → 29.2025.2000__py3-none-any.whl

lsst/daf/butler/direct_butler/_direct_butler.py

@@ -54,6 +54,7 @@ from sqlalchemy.exc import IntegrityError
 from lsst.resources import ResourcePath, ResourcePathExpression
 from lsst.utils.introspection import get_class_of
 from lsst.utils.logging import VERBOSE, getLogger
+from lsst.utils.timer import time_this
 
 from .._butler import Butler
 from .._butler_config import ButlerConfig
@@ -1464,14 +1465,25 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
                         refs.extend(query.datasets(dt, collections=name))
         with self._datastore.transaction(), self._registry.transaction():
             if unstore:
-                self._datastore.trash(refs)
+                with time_this(
+                    _LOG, msg="Marking %d datasets for removal to clear RUN collections", args=(len(refs),)
+                ):
+                    self._datastore.trash(refs)
             else:
                 self._datastore.forget(refs)
             for name in names:
-                self._registry.removeCollection(name)
+                with time_this(_LOG, msg="Removing registry entries for RUN collection %s", args=(name,)):
+                    self._registry.removeCollection(name)
         if unstore:
-            # Point of no return for removing artifacts
-            self._datastore.emptyTrash()
+            # Point of no return for removing artifacts. Restrict the trash
+            # emptying to the datasets from this specific collection rather
+            # than everything in the trash.
+            with time_this(
+                _LOG,
+                msg="Attempting to remove artifacts for %d datasets associated with RUN collections",
+                args=(len(refs),),
+            ):
+                self._datastore.emptyTrash(refs=refs)
 
     def pruneDatasets(
         self,
@@ -1518,13 +1530,20 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
         # Registry operations.
         with self._datastore.transaction(), self._registry.transaction():
             if unstore:
-                self._datastore.trash(refs)
+                with time_this(
+                    _LOG, msg="Marking %d datasets for removal to during pruning", args=(len(refs),)
+                ):
+                    self._datastore.trash(refs)
             if purge:
-                self._registry.removeDatasets(refs)
+                with time_this(_LOG, msg="Removing %d pruned datasets from registry", args=(len(refs),)):
+                    self._registry.removeDatasets(refs)
             elif disassociate:
                 assert tags, "Guaranteed by earlier logic in this function."
-                for tag in tags:
-                    self._registry.disassociate(tag, refs)
+                with time_this(
+                    _LOG, msg="Disassociating %d datasets from tagged collections", args=(len(refs),)
+                ):
+                    for tag in tags:
+                        self._registry.disassociate(tag, refs)
         # We've exited the Registry transaction, and apparently committed.
         # (if there was an exception, everything rolled back, and it's as if
         # nothing happened - and we never get here).
@@ -1535,8 +1554,14 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
         # deleting everything on disk and in private Datastore tables that is
         # in the dataset_location_trash table.
         if unstore:
-            # Point of no return for removing artifacts
-            self._datastore.emptyTrash()
+            # Point of no return for removing artifacts. Restrict the trash
+            # emptying to the refs that this call trashed.
+            with time_this(
+                _LOG,
+                msg="Attempting to remove artifacts for %d datasets associated with pruning",
+                args=(len(refs),),
+            ):
+                self._datastore.emptyTrash(refs=refs)
 
     @transactional
     def ingest_zip(self, zip_file: ResourcePathExpression, transfer: str = "auto") -> None:

lsst/daf/butler/registry/bridge/ephemeral.py

@@ -28,7 +28,7 @@ from __future__ import annotations
 
 __all__ = ("EphemeralDatastoreRegistryBridge",)
 
-from collections.abc import Iterable, Iterator
+from collections.abc import Collection, Iterable, Iterator
 from contextlib import contextmanager
 from typing import TYPE_CHECKING
 
@@ -100,28 +100,38 @@ class EphemeralDatastoreRegistryBridge(DatastoreRegistryBridge):
         records_table: OpaqueTableStorage | None = None,
         record_class: type[StoredDatastoreItemInfo] | None = None,
         record_column: str | None = None,
+        selected_ids: Collection[DatasetId] | None = None,
+        dry_run: bool = False,
     ) -> Iterator[tuple[Iterable[tuple[DatasetIdRef, StoredDatastoreItemInfo | None]], set[str] | None]]:
         # Docstring inherited from DatastoreRegistryBridge
         matches: Iterable[tuple[FakeDatasetRef, StoredDatastoreItemInfo | None]] = ()
+        trashed_ids = self._trashedIds
+
+        if selected_ids is not None:
+            trashed_ids = {tid for tid in trashed_ids if tid in selected_ids}
+
         if isinstance(records_table, OpaqueTableStorage):
             if record_class is None:
                 raise ValueError("Record class must be provided if records table is given.")
             matches = (
                 (FakeDatasetRef(id), record_class.from_record(record))
-                for id in self._trashedIds
+                for id in trashed_ids
                 for record in records_table.fetch(dataset_id=id)
             )
         else:
-            matches = ((FakeDatasetRef(id), None) for id in self._trashedIds)
+            matches = ((FakeDatasetRef(id), None) for id in trashed_ids)
 
         # Indicate to caller that we do not know about artifacts that
         # should be retained.
         yield ((matches, None))
 
+        if dry_run:
+            return
+
         if isinstance(records_table, OpaqueTableStorage):
             # Remove the records entries
-            records_table.delete(["dataset_id"], *[{"dataset_id": id} for id in self._trashedIds])
+            records_table.delete(["dataset_id"], *[{"dataset_id": id} for id in trashed_ids])
 
         # Empty the trash table
-        self._datasetIds.difference_update(self._trashedIds)
-        self._trashedIds = set()
+        self._datasetIds.difference_update(trashed_ids)
+        self._trashedIds = self._trashedIds - trashed_ids

lsst/daf/butler/registry/bridge/monolithic.py

@@ -32,12 +32,13 @@ __all__ = ("MonolithicDatastoreRegistryBridge", "MonolithicDatastoreRegistryBrid
 
 import copy
 from collections import namedtuple
-from collections.abc import Iterable, Iterator
+from collections.abc import Collection, Iterable, Iterator
 from contextlib import contextmanager
 from typing import TYPE_CHECKING, cast
 
 import sqlalchemy
 
+from ..._dataset_ref import DatasetId
 from ..._named import NamedValueSet
 from ...datastore.stored_file_info import StoredDatastoreItemInfo
 from ..interfaces import (
@@ -209,6 +210,8 @@ class MonolithicDatastoreRegistryBridge(DatastoreRegistryBridge):
         records_table: OpaqueTableStorage | None = None,
         record_class: type[StoredDatastoreItemInfo] | None = None,
         record_column: str | None = None,
+        selected_ids: Collection[DatasetId] | None = None,
+        dry_run: bool = False,
     ) -> Iterator[tuple[Iterable[tuple[DatasetIdRef, StoredDatastoreItemInfo | None]], set[str] | None]]:
         # Docstring inherited from DatastoreRegistryBridge
 
@@ -243,6 +246,11 @@ class MonolithicDatastoreRegistryBridge(DatastoreRegistryBridge):
         # table that is not listed in the records table. Such an
         # inconsistency would be missed by this query.
         info_in_trash = join_records(records_table._table.select(), self._tables.dataset_location_trash)
+        if selected_ids:
+            info_in_trash = info_in_trash.where(
+                self._tables.dataset_location_trash.columns["dataset_id"].in_(selected_ids)
+            )
+        info_in_trash = info_in_trash.with_for_update(skip_locked=True)
 
         # Run query, transform results into a list of dicts that we can later
         # use to delete.
@@ -265,14 +273,21 @@ class MonolithicDatastoreRegistryBridge(DatastoreRegistryBridge):
             items_in_trash = join_records(
                 sqlalchemy.sql.select(records_table._table.columns[record_column]),
                 self._tables.dataset_location_trash,
-            ).alias("items_in_trash")
+            )
+            if selected_ids:
+                items_in_trash = items_in_trash.where(
+                    self._tables.dataset_location_trash.columns["dataset_id"].in_(selected_ids)
+                )
+            items_in_trash_alias = items_in_trash.alias("items_in_trash")
 
             # A query for paths that are referenced by datasets in the trash
             # and datasets not in the trash.
-            items_to_preserve = sqlalchemy.sql.select(items_in_trash.columns[record_column]).select_from(
+            items_to_preserve = sqlalchemy.sql.select(
+                items_in_trash_alias.columns[record_column]
+            ).select_from(
                 items_not_in_trash.join(
-                    items_in_trash,
-                    onclause=items_in_trash.columns[record_column]
+                    items_in_trash_alias,
+                    onclause=items_in_trash_alias.columns[record_column]
                     == items_not_in_trash.columns[record_column],
                 )
             )
@@ -288,7 +303,7 @@ class MonolithicDatastoreRegistryBridge(DatastoreRegistryBridge):
         yield ((id_info, preserved))
 
         # No exception raised in context manager block.
-        if not rows:
+        if not rows or dry_run:
             return
 
         # Delete the rows from the records table

lsst/daf/butler/registry/collections/_base.py

@@ -570,7 +570,16 @@ class DefaultCollectionManager(CollectionManager[K]):
             child_collection_names,
             # Removing members from a chain can't create collection cycles
             skip_cycle_check=True,
+            # It is OK for multiple instances of `remove_from_collection_chain`
+            # to run concurrently on the same collection, because it doesn't
+            # read/modify the position numbers of the children -- it only
+            # deletes existing rows.
+            #
+            # However, other chain modification operations must still be
+            # blocked to avoid consistency issues.
+            exclusive_lock=False,
         ) as c:
+            self._block_for_concurrency_test()
             self._remove_collection_chain_rows(c.parent_key, c.child_keys)
 
     @contextmanager
@@ -581,6 +590,7 @@ class DefaultCollectionManager(CollectionManager[K]):
         *,
         skip_caching_check: bool = False,
         skip_cycle_check: bool = False,
+        exclusive_lock: bool = True,
     ) -> Iterator[_CollectionChainModificationContext[K]]:
         if (not skip_caching_check) and self._caching_context.collection_records is not None:
             # Avoid having cache-maintenance code around that is unlikely to
@@ -604,7 +614,9 @@ class DefaultCollectionManager(CollectionManager[K]):
         with self._db.transaction():
             # Lock the parent collection to prevent concurrent updates to the
             # same collection chain.
-            parent_key = self._find_and_lock_collection_chain(parent_collection_name)
+            parent_key = self._find_and_lock_collection_chain(
+                parent_collection_name, exclusive_lock=exclusive_lock
+            )
             yield _CollectionChainModificationContext[K](
                 parent_key=parent_key, child_keys=child_keys, child_records=child_records
             )
@@ -704,7 +716,7 @@ class DefaultCollectionManager(CollectionManager[K]):
 
         return position
 
-    def _find_and_lock_collection_chain(self, collection_name: str) -> K:
+    def _find_and_lock_collection_chain(self, collection_name: str, *, exclusive_lock: bool) -> K:
         """
         Take a row lock on the specified collection's row in the collections
         table, and return the collection's primary key.
@@ -715,14 +727,19 @@ class DefaultCollectionManager(CollectionManager[K]):
         collection chain table -- all operations that modify collection chains
         must obtain this lock first.  The database will NOT automatically
         prevent modification of tables based on this lock.  The only guarantee
-        is that only one caller will be allowed to hold this lock for a given
-        collection at a time.  Concurrent calls will block until the caller
-        holding the lock has completed its transaction.
+        is that only one caller will be allowed to hold the exclusive lock for
+        a given collection at a time.  Concurrent calls will block until the
+        caller holding the lock has completed its transaction.
 
         Parameters
         ----------
         collection_name : `str`
             Name of the collection whose chain is being modified.
+        exclusive_lock : `bool`
+            If `True`, an exclusive lock will be taken to block all concurrent
+            modifications to the same collection.  If `False`, a shared lock
+            will be taken which will only block operations that request an
+            exclusive lock.
 
         Returns
         -------
@@ -742,7 +759,7 @@ class DefaultCollectionManager(CollectionManager[K]):
         )
         assert self._db.isWriteable(), "Collection row locks are only useful for write operations."
 
-        query = self._select_pkey_by_name(collection_name).with_for_update()
+        query = self._select_pkey_by_name(collection_name).with_for_update(read=not exclusive_lock)
         with self._db.query(query) as cursor:
             rows = cursor.all()
 

lsst/daf/butler/registry/interfaces/_bridge.py

@@ -29,7 +29,7 @@ from __future__ import annotations
 __all__ = ("DatasetIdRef", "DatastoreRegistryBridge", "DatastoreRegistryBridgeManager", "FakeDatasetRef")
 
 from abc import ABC, abstractmethod
-from collections.abc import Iterable
+from collections.abc import Collection, Iterable
 from contextlib import AbstractContextManager
 from typing import TYPE_CHECKING, Any
 
@@ -191,6 +191,8 @@ class DatastoreRegistryBridge(ABC):
         records_table: OpaqueTableStorage | None = None,
         record_class: type[StoredDatastoreItemInfo] | None = None,
         record_column: str | None = None,
+        selected_ids: Collection[DatasetId] | None = None,
+        dry_run: bool = False,
     ) -> AbstractContextManager[
         tuple[Iterable[tuple[DatasetIdRef, StoredDatastoreItemInfo | None]], set[str] | None]
     ]:
@@ -206,6 +208,16 @@ class DatastoreRegistryBridge(ABC):
             Class to use when reading records from ``records_table``.
         record_column : `str`, optional
             Name of the column in records_table that refers to the artifact.
+        selected_ids : `collections.abc.Collection` [ `DatasetId` ] \
+                or `None`, optional
+            If provided, collection of IDs that should be trashed. Only records
+            within this selection will be yielded and then removed. This
+            can be used to allow a subset of the trash table to be emptied.
+            If an empty set is given no artifacts will be trashed. If `None`
+            the full list from the trash table will be used.
+        dry_run : `bool`, optional
+            If `True`, the trash table will be queried and results reported
+            but no artifacts will be removed.
 
         Yields
         ------

lsst/daf/butler/registry/tests/_registry.py

@@ -973,14 +973,14 @@ class RegistryTests(ABC):
         expected.
         """
 
-        def blocked_thread_func(registry: SqlRegistry):
+        def blocked_thread_func(butler: Butler):
             # This call will become blocked after it has decided on positions
             # for the new children in the collection chain, but before
             # inserting them.
-            registry._managers.collections.prepend_collection_chain("chain", ["a"])
+            butler.collections.prepend_chain("chain", ["a"])
 
-        def unblocked_thread_func(registry: SqlRegistry):
-            registry._managers.collections.prepend_collection_chain("chain", ["b"])
+        def unblocked_thread_func(butler: Butler):
+            butler.collections.prepend_chain("chain", ["b"])
 
         registry = self._do_collection_concurrency_test(blocked_thread_func, unblocked_thread_func)
 
@@ -993,13 +993,13 @@ class RegistryTests(ABC):
         expected.
         """
 
-        def blocked_thread_func(registry: SqlRegistry):
+        def blocked_thread_func(butler: Butler):
             # This call will become blocked after deleting children, but before
             # inserting new ones.
-            registry.setCollectionChain("chain", ["a"])
+            butler.collections.redefine_chain("chain", ["a"])
 
-        def unblocked_thread_func(registry: SqlRegistry):
-            registry.setCollectionChain("chain", ["b"])
+        def unblocked_thread_func(butler: Butler):
+            butler.collections.redefine_chain("chain", ["b"])
 
         registry = self._do_collection_concurrency_test(blocked_thread_func, unblocked_thread_func)
 
@@ -1008,8 +1008,23 @@ class RegistryTests(ABC):
         # chain with "b".
         self.assertEqual(("b",), registry.getCollectionChain("chain"))
 
+    def testCollectionChainRemoveConcurrency(self):
+        def blocked_thread_func(butler: Butler):
+            # This call will become blocked after taking the lock, but before
+            # deleting the children.
+            butler.collections.remove_from_chain("chain", ["b"])
+
+        def unblocked_thread_func(butler: Butler):
+            butler.collections.redefine_chain("chain", ["b", "a"])
+
+        registry = self._do_collection_concurrency_test(blocked_thread_func, unblocked_thread_func)
+
+        # blocked_thread_func should have finished first, removing "b".
+        # unblocked_thread_func should have finished second, putting "b" back.
+        self.assertEqual(("b", "a"), registry.getCollectionChain("chain"))
+
     def _do_collection_concurrency_test(
-        self, blocked_thread_func: Callable[[SqlRegistry]], unblocked_thread_func: Callable[[SqlRegistry]]
+        self, blocked_thread_func: Callable[[Butler]], unblocked_thread_func: Callable[[Butler]]
     ) -> SqlRegistry:
         # This function:
         # 1. Sets up two registries pointing at the same database.
@@ -1048,12 +1063,12 @@ class RegistryTests(ABC):
 
         with ThreadPoolExecutor(max_workers=1) as exec1:
             with ThreadPoolExecutor(max_workers=1) as exec2:
-                future1 = exec1.submit(blocked_thread_func, registry1)
+                future1 = exec1.submit(blocked_thread_func, butler1)
                 enter_barrier.wait()
 
                 # At this point registry 1 has entered the critical section and
                 # is waiting for us to release it.  Start the other thread.
-                future2 = exec2.submit(unblocked_thread_func, registry2)
+                future2 = exec2.submit(unblocked_thread_func, butler2)
                 # thread2 should block inside a database call, but we have no
                 # way to detect when it is in this state.
                 time.sleep(0.200)

lsst/daf/butler/remote_butler/server/_server.py

@@ -40,12 +40,14 @@ from ..._exceptions import ButlerUserError
 from .._errors import serialize_butler_user_error
 from ..server_models import CLIENT_REQUEST_ID_HEADER_NAME, ERROR_STATUS_CODE, ErrorResponseModel
 from ._config import load_config
+from ._telemetry import enable_telemetry
 from .handlers._external import external_router
 from .handlers._external_query import query_router
 from .handlers._internal import internal_router
 
 configure_logging(name="lsst.daf.butler.remote_butler.server")
 configure_uvicorn_logging()
+enable_telemetry()
 
 
 def create_app() -> FastAPI:

lsst/daf/butler/remote_butler/server/_telemetry.py

@@ -0,0 +1,105 @@
+# This file is part of daf_butler.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (http://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This software is dual licensed under the GNU General Public License and also
+# under a 3-clause BSD license. Recipients may choose which of these licenses
+# to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
+# respectively.  If you choose the GPL option then the following text applies
+# (but note that there is still no warranty even if you opt for BSD instead):
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+from collections.abc import Iterator
+from contextlib import AbstractContextManager, contextmanager
+from typing import Any, Protocol
+
+try:
+    import sentry_sdk
+
+    _SENTRY_AVAILABLE = True
+except ImportError:
+    _SENTRY_AVAILABLE = False
+
+
+class TelemetryContext(Protocol):
+    """Interface for adding information to trace telemetry."""
+
+    def span(self, name: str) -> AbstractContextManager[None]: ...
+
+
+class NullTelemetryContext(TelemetryContext):
+    """No-op implementation of telemetry used when no telemetry provider is
+    configured.
+    """
+
+    @contextmanager
+    def span(self, name: str) -> Iterator[None]:
+        yield
+
+
+class SentryTelemetryContext(TelemetryContext):
+    """Implementation of telemetry using Sentry."""
+
+    @contextmanager
+    def span(self, name: str) -> Iterator[None]:
+        with sentry_sdk.start_span(name=name):
+            yield
+
+
+_telemetry_context: TelemetryContext = NullTelemetryContext()
+
+
+def enable_telemetry() -> None:
+    """Turn on upload of trace telemetry to Sentry, to allow performance
+    debugging of deployed server.
+    """
+    if not _SENTRY_AVAILABLE:
+        return
+
+    # Configuration will be pulled from SENTRY_* environment variables
+    # (see https://docs.sentry.io/platforms/python/configuration/options/).
+    # If SENTRY_DSN is not present, telemetry is disabled.
+    sentry_sdk.init(enable_tracing=True, traces_sampler=_decide_whether_to_sample_trace)
+
+    global _telemetry_context
+    _telemetry_context = SentryTelemetryContext()
+
+
+def get_telemetry_context() -> TelemetryContext:
+    """Return an object that can be used to add information to the trace
+    telemetry.
+
+    Returns
+    -------
+    telemetry_context : `TelemetryContext`
+        Object that can be used to add information to the trace telemetry.
+    """
+    return _telemetry_context
+
+
+def _decide_whether_to_sample_trace(context: dict[str, Any]) -> float:
+    asgi_scope = context.get("asgi_scope")
+    if asgi_scope is not None:
+        # Do not log health check endpoint.
+        if asgi_scope.get("path") == "/":
+            return 0
+
+    sampling_rate = float(os.getenv("BUTLER_TRACE_SAMPLING_RATE", "0.02"))
+    return sampling_rate

lsst/daf/butler/remote_butler/server/handlers/_query_streaming.py

@@ -44,6 +44,7 @@ from lsst.daf.butler.remote_butler.server_models import (
 
 from ...._exceptions import ButlerUserError
 from ..._errors import serialize_butler_user_error
+from .._telemetry import get_telemetry_context
 
 # Restrict the maximum number of streaming queries that can be running
 # simultaneously, to prevent the database connection pool and the thread pool
@@ -175,9 +176,12 @@ async def _enqueue_query_pages(
     queue.  Send `None` to the queue when there is no more data to read.
     """
     try:
-        async with contextmanager_in_threadpool(query.setup()) as ctx:
-            async for page in iterate_in_threadpool(query.execute(ctx)):
-                await queue.put(page)
+        telemetry = get_telemetry_context()
+        with telemetry.span("Execute query"):
+            async with contextmanager_in_threadpool(query.setup()) as ctx:
+                with telemetry.span("Read from DB and send results"):
+                    async for page in iterate_in_threadpool(query.execute(ctx)):
+                        await queue.put(page)
     except ButlerUserError as e:
         # If a user-facing error occurs, serialize it and send it to the
         # client.

lsst/daf/butler/script/removeRuns.py

@@ -139,10 +139,16 @@ def removeRuns(
     def _doRemove(runs: Sequence[RemoveRun]) -> None:
         """Perform the remove step."""
         butler = Butler.from_config(repo, writeable=True)
+        # Collections must be removed from chains in a deterministic
+        # order to protect against parallelized purging on the same chain.
+        parents_to_children: dict[str, set[str]] = defaultdict(set)
+        for run in runs:
+            for parent in run.parents:
+                parents_to_children[parent].add(run.name)
+
         with butler.transaction():
-            for run in runs:
-                for parent in run.parents:
-                    butler.collections.remove_from_chain(parent, run.name)
+            for parent in sorted(parents_to_children):
+                butler.collections.remove_from_chain(parent, sorted(parents_to_children[parent]))
             butler.removeRuns([r.name for r in runs], unstore=True)
 
     result = RemoveRunsResult(

lsst/daf/butler/tests/cliCmdTestBase.py

@@ -174,7 +174,7 @@ class CliCmdTestBase(abc.ABC):
         """
         result = self.run_command(inputs)
         self.assertNotEqual(result.exit_code, 0, clickResultMsg(result))
-        self.assertRegex(result.stdout, expectedMsg)
+        self.assertRegex(result.output, expectedMsg)
 
     def test_help(self) -> None:
         self.assertFalse(

lsst/daf/butler/version.py

@@ -1,2 +1,2 @@
 __all__ = ["__version__"]
-__version__ = "29.2025.1900"
+__version__ = "29.2025.2000"

{lsst_daf_butler-29.2025.1900.dist-info → lsst_daf_butler-29.2025.2000.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-daf-butler
-Version: 29.2025.1900
+Version: 29.2025.2000
 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