lsst-daf-butler 29.2025.2400__tar.gz → 29.2025.2500__tar.gz

{lsst_daf_butler-29.2025.2400/python/lsst_daf_butler.egg-info → lsst_daf_butler-29.2025.2500}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-daf-butler
-Version: 29.2025.2400
+Version: 29.2025.2500
 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.2400 → lsst_daf_butler-29.2025.2500}/doc/lsst.daf.butler/CHANGES.rst

@@ -1,3 +1,74 @@
+Butler v29.1.0 (2025-06-13)
+===========================
+
+New Features
+------------
+
+- Added support in user expressions for explicit specification of bind identifiers with a preceding colon symbol.
+  Legacy format of bind identifiers without colon is still supported, but will be deprecated in the future. (`DM-38497 <https://rubinobs.atlassian.net/browse/DM-38497>`_)
+- Added a new ``--show-dataset-types`` argument (``-t``) to ``butler query-collections`` to list the dataset types in each collection.
+  Also added a new ``--exclude-dataset-types`` which allows a comma-separated list of string globs to be passed in for exclusion when dataset types are shown. (`DM-48975 <https://rubinobs.atlassian.net/browse/DM-48975>`_)
+- Added Pydantic serialization for ``DimensionRecordSet``. (`DM-49622 <https://rubinobs.atlassian.net/browse/DM-49622>`_)
+- Added ``FileDataset.to_simple`` and ``FileDataset.from_simple`` for serializing ``FileDataset`` instances. (`DM-49670 <https://rubinobs.atlassian.net/browse/DM-49670>`_)
+- Added a ``join_data_coordinate_table`` method to the ``Query`` class for uploading data IDs from Astropy tables.
+  This includes support for filling in required-dimension columns using constraints from a ``where`` string (for example now a table with just ``visit`` IDs along with ``instrument='LSSTCam'`` in the ``where`` string will work). (`DM-49949 <https://rubinobs.atlassian.net/browse/DM-49949>`_)
+- Added support to the user expression language for a ``GLOB(expression, pattern)`` function.
+  The function performs case-sensitive match of the string expression against the pattern.
+  The pattern can include ``*`` and ``?`` meta-characters that match any number or a single character. (`DM-50191 <https://rubinobs.atlassian.net/browse/DM-50191>`_)
+- Added the ability for Zip ingest to register any missing dimension records.
+  Note that if any datasets use ``visit`` that require registration then the records being registered will not fully define the visit and so can not be usable for graph building.
+  It is recommended that visits be defined first before ingest at this time. (`DM-50313 <https://rubinobs.atlassian.net/browse/DM-50313>`_)
+- Added support to the user expression language for UUID literals that can be used to query dataset IDs.
+  UUID literals are specified using function call syntax: ``UUID('hex-string')``. (`DM-50451 <https://rubinobs.atlassian.net/browse/DM-50451>`_)
+- Added ability for Butler to record timing metrics such as the amount of time spent in ``get()`` or ``put()`` and the number of times those are called.
+  A metrics object can be given to the ``Butler`` constructor to record everything, or alternatively a new context manager ``Butler.record_metrics`` can be used to record metrics for a specific usage. (`DM-50491 <https://rubinobs.atlassian.net/browse/DM-50491>`_)
+- ``RemoteButler`` can now be used as a source Butler in ``transfer_from``. (`DM-51075 <https://rubinobs.atlassian.net/browse/DM-51075>`_)
+
+
+API Changes
+-----------
+
+- * The ``unstore`` parameter for ``Butler.removeRuns()`` has been deprecated.
+    We now always remove the file artifacts when removing the collection.
+  * Added a ``unlink_from_chains`` parameter to ``Butler.removeRuns()`` to allow the RUN collections to be unlinked from their parent chains automatically. (`DM-50996 <https://rubinobs.atlassian.net/browse/DM-50996>`_)
+
+
+Bug Fixes
+---------
+
+- Fixed an issue where ``find_first=False`` dataset queries would sometimes return duplicate results if more than one collection was being searched. (`DM-47201 <https://rubinobs.atlassian.net/browse/DM-47201>`_)
+- Query expressions now allow float columns to be compared with ``int`` literals.
+  Query expressions now allow ``OVERLAPS`` to be used to compare timespans with ``ingest_date.`` (`DM-47644 <https://rubinobs.atlassian.net/browse/DM-47644>`_)
+- ``Butler.ingest()`` will now register missing run collections instead of raising a ``MissingCollectionError``. (`DM-49670 <https://rubinobs.atlassian.net/browse/DM-49670>`_)
+- Fixed handling of expressions like ``"id=2"`` in contexts where ``"id"`` resolves unambigously to a dimension primary key column. (`DM-50465 <https://rubinobs.atlassian.net/browse/DM-50465>`_)
+- ``butler remove-runs`` will no longer block if a parallel process calls ``butler remove-runs`` on a run contained in the same collection chain. (`DM-50855 <https://rubinobs.atlassian.net/browse/DM-50855>`_)
+
+
+Performance Enhancement
+-----------------------
+
+- ``Butler.transfer_from()`` now uses fewer database queries when inserting datasets of multiple dataset types, when some of the dataset types have the same dimensions. (`DM-49513 <https://rubinobs.atlassian.net/browse/DM-49513>`_)
+- Improve the performance of certain queries by moving ``WHERE`` clause terms down into subqueries. (`DM-50969 <https://rubinobs.atlassian.net/browse/DM-50969>`_)
+- ``Butler.transfer_from`` now uses fewer database queries. (`DM-51302 <https://rubinobs.atlassian.net/browse/DM-51302>`_)
+
+
+Other Changes and Additions
+---------------------------
+
+- ``retrieveArtifacts`` and ``transfer_from`` now transfer their artifacts using multiple threads. (`DM-31824 <https://rubinobs.atlassian.net/browse/DM-31824>`_)
+- * Reorganized the code for ``Butler.ingest`` and ``Butler.ingest_zip`` to share the code from ``Butler.transfer_from`` in order to provide consistent error messages for incompatible dataset types and to allow a future possibility of registering dataset types and dimension records as part of ``ingest_zip``.
+  * Removed the ``use_cache`` parameter from the ``DimensionUniverse`` constructor.
+    The universe is always cached and the remote butler now uses that cache and does not need to disable the cache. (`DM-50044 <https://rubinobs.atlassian.net/browse/DM-50044>`_)
+- Significantly sped up ``Butler.pruneDatasets`` by using parallelized artifact deletions. (`DM-50724 <https://rubinobs.atlassian.net/browse/DM-50724>`_)
+- Modified trash emptying in datastore such that only the datasets to be removed as part of the original butler request are the ones that are trashed immediately. (`DM-50727 <https://rubinobs.atlassian.net/browse/DM-50727>`_)
+- Modified CLI tooling to work with both click 8.1 and click 8.2. (`DM-50823 <https://rubinobs.atlassian.net/browse/DM-50823>`_)
+- Fixed handling of ``FileDatastore.transfer_from()`` such that it now works with chained datastores. (`DM-50935 <https://rubinobs.atlassian.net/browse/DM-50935>`_)
+- Reorganized ``Butler.removeRuns()`` to remove datasets in chunks to provide more feedback to the user and allow for restarting if the command fails for some reason. (`DM-50996 <https://rubinobs.atlassian.net/browse/DM-50996>`_)
+- Added a ``fallback_instrument`` to ObsCore configurations.
+  This instrument is used when an ObsCore record is constructed from a dataset type that has no instrument defined. (`DM-51269 <https://rubinobs.atlassian.net/browse/DM-51269>`_)
+- ``Butler.transfer_from()`` will now raise a `FileNotFoundError` while transferring files if a file listed in the database is not actually available on the filesystem.  Previously, it would silently skip the file. (`DM-51302 <https://rubinobs.atlassian.net/browse/DM-51302>`_)
+
+
 Butler v29.0.0 (2025-03-25)
 ===========================
 

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/pyproject.toml

@@ -77,7 +77,7 @@ zip-safe = true
 license-files = ["COPYRIGHT", "LICENSE", "bsd_license.txt", "gpl-v3.0.txt"]
 
 [tool.setuptools.package-data]
-"lsst.daf.butler" = ["py.typed", "configs/*.yaml", "configs/*/*.yaml"]
+"lsst.daf.butler" = ["py.typed", "configs/*.yaml", "configs/*/*.yaml", "tests/registry_data/*.yaml"]
 
 [tool.setuptools.dynamic]
 version = { attr = "lsst_versions.get_lsst_version" }

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/python/lsst/daf/butler/datastore/_datastore.py

@@ -67,6 +67,7 @@ if TYPE_CHECKING:
     from .._dataset_type import DatasetType
     from .._storage_class import StorageClass
     from ..datastores.file_datastore.retrieve_artifacts import ArtifactIndexInfo
+    from ..datastores.fileDatastoreClient import FileDatastoreGetPayload
     from ..registry.interfaces import DatasetIdRef, DatastoreRegistryBridgeManager
     from .record_data import DatastoreRecordData
     from .stored_file_info import StoredDatastoreItemInfo
@@ -613,7 +614,7 @@ class Datastore(FileTransferSource, metaclass=ABCMeta):
         """
         raise NotImplementedError("Must be implemented by subclass")
 
-    def prepare_get_for_external_client(self, ref: DatasetRef) -> object | None:
+    def prepare_get_for_external_client(self, ref: DatasetRef) -> FileDatastoreGetPayload | None:
         """Retrieve serializable data that can be used to execute a ``get()``.
 
         Parameters

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/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
+from typing import TYPE_CHECKING, Any, ClassVar
 
 import pydantic
 
@@ -192,30 +192,44 @@ class StoredFileInfo(StoredDatastoreItemInfo):
         The formatter to use for this dataset.
     path : `str`
         Path to the artifact associated with this dataset.
-    storageClass : `StorageClass`
-        The storage class associated with this dataset.
+    storageClass : `StorageClass` or `None`
+        The storage class associated with this dataset.  If `None`,
+        ``storage_class_name`` must be provided as a keyword argument.
     component : `str` or `None`, optional
         The component if disassembled.
     checksum : `str` or `None`, optional
         The checksum of the artifact.
     file_size : `int`
         The size of the file in bytes. -1 indicates the size is not known.
+    storage_class_name : `str`, optional
+        Name of the storage class.  This may be passed instead of
+        ``storageClass`` to defer loading storage class definitions (e.g. if a
+        butler configuration may not have been loaded yet).  Note that
+        ``storageClass=None`` must be passed explicitly (for backward
+        compatibility, it remains a positional argument with no default).
     """
 
-    storageClassFactory = StorageClassFactory()
+    storageClassFactory: ClassVar[StorageClassFactory] = StorageClassFactory()
 
     def __init__(
         self,
         formatter: FormatterParameter,
         path: str,
-        storageClass: StorageClass,
+        storageClass: StorageClass | None,
         component: str | None,
         checksum: str | None,
         file_size: int,
+        *,
+        storage_class_name: str | None = None,
     ):
         # Use these shenanigans to allow us to use a frozen dataclass
         object.__setattr__(self, "path", path)
-        object.__setattr__(self, "storageClass", storageClass)
+        if storageClass is not None:
+            object.__setattr__(self, "storage_class_name", storageClass.name)
+        else:
+            if storage_class_name is None:
+                raise TypeError("At least one of 'storageClass' and 'storage_class_name' must be provided.")
+            object.__setattr__(self, "storage_class_name", storage_class_name)
         object.__setattr__(self, "component", component)
         object.__setattr__(self, "checksum", checksum)
         object.__setattr__(self, "file_size", file_size)
@@ -238,8 +252,8 @@ class StoredFileInfo(StoredDatastoreItemInfo):
     path: str
     """Path to dataset within Datastore."""
 
-    storageClass: StorageClass
-    """StorageClass associated with Dataset."""
+    storage_class_name: str
+    """Name of the storage class associated with this dataset."""
 
     component: str | None
     """Component associated with this file. Can be `None` if the file does
@@ -251,6 +265,11 @@ class StoredFileInfo(StoredDatastoreItemInfo):
     file_size: int
     """Size of the serialized dataset in bytes."""
 
+    @property
+    def storageClass(self) -> StorageClass:
+        """Storage class associated with this dataset."""
+        return self.storageClassFactory.getStorageClass(self.storage_class_name)
+
     def rebase(self, ref: DatasetRef) -> StoredFileInfo:
         """Return a copy of the record suitable for a specified reference.
 
@@ -287,7 +306,7 @@ class StoredFileInfo(StoredDatastoreItemInfo):
         return dict(
             formatter=self.formatter,
             path=self.path,
-            storage_class=self.storageClass.name,
+            storage_class=self.storage_class_name,
             component=component,
             checksum=self.checksum,
             file_size=self.file_size,
@@ -336,12 +355,12 @@ class StoredFileInfo(StoredDatastoreItemInfo):
             The newly-constructed item corresponding to the record.
         """
         # Convert name of StorageClass to instance
-        storageClass = cls.storageClassFactory.getStorageClass(record["storage_class"])
         component = record["component"] if (record["component"] and record["component"] != NULLSTR) else None
         info = cls(
             formatter=record["formatter"],
             path=record["path"],
-            storageClass=storageClass,
+            storageClass=None,
+            storage_class_name=record["storage_class"],
             component=component,
             checksum=record["checksum"],
             file_size=record["file_size"],
@@ -353,7 +372,7 @@ class StoredFileInfo(StoredDatastoreItemInfo):
         return cls.from_record(dict(model))
 
     def update(self, **kwargs: Any) -> StoredFileInfo:
-        new_args = {}
+        new_args: dict[str, Any] = {"storageClass": None}  # so `storage_class_name` can be passed.
         for k in self.__slots__:
             if k in kwargs:
                 new_args[k] = kwargs.pop(k)

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/python/lsst/daf/butler/datastores/chainedDatastore.py

@@ -61,6 +61,8 @@ if TYPE_CHECKING:
     from lsst.daf.butler.registry.interfaces import DatasetIdRef, DatastoreRegistryBridgeManager
     from lsst.resources import ResourcePathExpression
 
+    from .fileDatastoreClient import FileDatastoreGetPayload
+
 log = getLogger(__name__)
 
 
@@ -409,7 +411,7 @@ class ChainedDatastore(Datastore):
 
         raise FileNotFoundError(f"Dataset {ref} could not be found in any of the datastores")
 
-    def prepare_get_for_external_client(self, ref: DatasetRef) -> object | None:
+    def prepare_get_for_external_client(self, ref: DatasetRef) -> FileDatastoreGetPayload | None:
         datastore = self._get_matching_datastore(ref)
         if datastore is None:
             return None

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/python/lsst/daf/butler/direct_butler/_direct_butler.py

@@ -1879,18 +1879,15 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
         # Docstring inherited.
         if not self.isWriteable():
             raise TypeError("Butler is read-only.")
-        if format is None:
-            if filename is None:
-                raise TypeError("At least one of 'filename' or 'format' must be provided.")
-            else:
-                _, format = os.path.splitext(filename)  # type: ignore
-        elif filename is None:
+        if filename is None and format is not None:
             filename = ResourcePath(f"export.{format}", forceAbsolute=False)
         if directory is not None:
             directory = ResourcePath(directory, forceDirectory=True)
         # mypy doesn't think this will work but it does in python >= 3.10.
         if isinstance(filename, ResourcePathExpression):  # type: ignore
             filename = ResourcePath(filename, forceAbsolute=False)  # type: ignore
+            if format is None:
+                format = filename.getExtension()
             if not filename.isabs() and directory is not None:
                 potential = directory.join(filename)
                 exists_in_cwd = filename.exists()
@@ -1914,6 +1911,8 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
                     raise FileNotFoundError(
                         f"Export file could not be found in {filename.abspath()} or {potential.abspath()}."
                     )
+        elif format is None:
+            format = ".yaml"
         BackendClass: type[RepoImportBackend] = get_class_of(
             self._config["repo_transfer_formats"][format]["import"]
         )

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/python/lsst/daf/butler/direct_query_driver/_driver.py

@@ -353,7 +353,7 @@ class DirectQueryDriver(QueryDriver):
         else:
             dict_rows = [dict(zip(dimensions.required, values)) for values in rows]
         from_clause: sqlalchemy.FromClause
-        if len(dict_rows) > self._constant_rows_limit:
+        if self.db.supports_temporary_tables and len(dict_rows) > self._constant_rows_limit:
             from_clause = self._exit_stack.enter_context(self.db.temporary_table(table_spec))
             self.db.insert(from_clause, *dict_rows)
         else:

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/python/lsst/daf/butler/registry/_config.py

@@ -119,3 +119,24 @@ class RegistryConfig(ConfigSubset):
         (`sqlalchemy.engine.url.URL`).
         """
         return ConnectionStringFactory.fromConfig(self)
+
+    @property
+    def areTemporaryTablesAllowed(self) -> bool:
+        """Return `True` if the database allows creating temporary tables for
+        read operations; `False` otherwise.
+
+        By default this is `True`, because there is a performance penalty
+        for some queries if temporary tables cannot be used.
+
+        This should be set to `False` when using a Postgres hot standby using
+        physical replication or an AlloyDB read pool, since these backends
+        do not support temporary tables.
+        """
+        key = "temporary_tables"
+        value = self.get(key)
+        if value is None:
+            return True
+        elif isinstance(value, bool):
+            return value
+
+        raise ValueError(f"Unexpected value '{value}' for '{key}' in registry configuration")

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/python/lsst/daf/butler/registry/databases/postgresql.py

@@ -65,6 +65,10 @@ class PostgresqlDatabase(Database):
     writeable : `bool`, optional
         If `True`, allow write operations on the database, including
         ``CREATE TABLE``.
+    allow_temporary_tables : `bool`, optional
+        If `True`, database operations will be allowed to use temporary tables.
+        If `False`, other SQL constructs will be used instead of temporary
+        tables when possible.
 
     Notes
     -----
@@ -85,6 +89,7 @@ class PostgresqlDatabase(Database):
         origin: int,
         namespace: str | None = None,
         writeable: bool = True,
+        allow_temporary_tables: bool = True,
     ):
         with engine.connect() as connection:
             # `Any` to make mypy ignore the line below, can't use type: ignore
@@ -114,6 +119,7 @@ class PostgresqlDatabase(Database):
             dbname=dsn.get("dbname"),
             metadata=None,
             pg_version=pg_version,
+            allow_temporary_tables=allow_temporary_tables,
         )
 
     def _init(
@@ -126,9 +132,16 @@ class PostgresqlDatabase(Database):
         dbname: str,
         metadata: DatabaseMetadata | None,
         pg_version: tuple[int, int],
+        allow_temporary_tables: bool = True,
     ) -> None:
         # Initialization logic shared between ``__init__`` and ``clone``.
-        super().__init__(origin=origin, engine=engine, namespace=namespace, metadata=metadata)
+        super().__init__(
+            origin=origin,
+            engine=engine,
+            namespace=namespace,
+            metadata=metadata,
+            allow_temporary_tables=allow_temporary_tables,
+        )
         self._writeable = writeable
         self.dbname = dbname
         self._pg_version = pg_version
@@ -143,6 +156,7 @@ class PostgresqlDatabase(Database):
             dbname=self.dbname,
             metadata=self._metadata,
             pg_version=self._pg_version,
+            allow_temporary_tables=self._allow_temporary_tables,
         )
         return clone
 

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/python/lsst/daf/butler/registry/databases/sqlite.py

@@ -74,6 +74,11 @@ class SqliteDatabase(Database):
     writeable : `bool`, optional
         If `True`, allow write operations on the database, including
         ``CREATE TABLE``.
+    allow_temporary_tables : `bool`, optional
+        If `True`, database operations will be allowed to use temporary
+        tables.
+        If `False`, other SQL constructs will be used instead of temporary
+        tables when possible.
 
     Notes
     -----
@@ -90,6 +95,7 @@ class SqliteDatabase(Database):
         origin: int,
         namespace: str | None = None,
         writeable: bool = True,
+        allow_temporary_tables: bool = True,
     ):
         filename = _find_database_filename(engine, namespace)
         self._init(
@@ -99,6 +105,7 @@ class SqliteDatabase(Database):
             writeable=writeable,
             filename=filename,
             metadata=None,
+            allow_temporary_tables=allow_temporary_tables,
         )
 
     def _init(
@@ -110,9 +117,16 @@ class SqliteDatabase(Database):
         writeable: bool = True,
         filename: str | None,
         metadata: DatabaseMetadata | None,
+        allow_temporary_tables: bool,
     ) -> None:
         # Initialization logic shared between ``__init__`` and ``clone``.
-        super().__init__(origin=origin, engine=engine, namespace=namespace, metadata=metadata)
+        super().__init__(
+            origin=origin,
+            engine=engine,
+            namespace=namespace,
+            metadata=metadata,
+            allow_temporary_tables=allow_temporary_tables,
+        )
         self._writeable = writeable
         self.filename = filename
 
@@ -125,6 +139,7 @@ class SqliteDatabase(Database):
             writeable=self._writeable,
             filename=self.filename,
             metadata=self._metadata,
+            allow_temporary_tables=self._allow_temporary_tables,
         )
         return clone
 

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/python/lsst/daf/butler/registry/interfaces/_database.py

@@ -238,6 +238,10 @@ class Database(ABC):
         Object representing the tables and other schema entities.  If not
         provided, will be generated during the next call to
         ``declareStaticTables``.
+    allow_temporary_tables : `bool`, optional
+        If `True`, database operations will be allowed to use temporary tables.
+        If `False`, other SQL constructs will be used instead of temporary
+        tables when possible.
 
     Notes
     -----
@@ -272,6 +276,7 @@ class Database(ABC):
         engine: sqlalchemy.engine.Engine,
         namespace: str | None = None,
         metadata: DatabaseMetadata | None = None,
+        allow_temporary_tables: bool = True,
     ):
         self.origin = origin
         self.name_shrinker = NameShrinker(engine.dialect.max_identifier_length)
@@ -280,6 +285,7 @@ class Database(ABC):
         self._session_connection: sqlalchemy.engine.Connection | None = None
         self._temp_tables: set[str] = set()
         self._metadata = metadata
+        self._allow_temporary_tables = allow_temporary_tables
 
     def __repr__(self) -> str:
         # Rather than try to reproduce all the parameters used to create
@@ -318,6 +324,7 @@ class Database(ABC):
         origin: int,
         namespace: str | None = None,
         writeable: bool = True,
+        allow_temporary_tables: bool = True,
     ) -> Database:
         """Construct a database from a SQLAlchemy URI.
 
@@ -336,15 +343,22 @@ class Database(ABC):
         writeable : `bool`, optional
             If `True`, allow write operations on the database, including
             ``CREATE TABLE``.
+        allow_temporary_tables : `bool`, optional
+            If `True`, database operations will be allowed to use temporary
+            tables.
+            If `False`, other SQL constructs will be used instead of temporary
+            tables when possible.
 
         Returns
         -------
         db : `Database`
             A new `Database` instance.
         """
-        return cls.fromEngine(
+        db = cls.fromEngine(
             cls.makeEngine(uri, writeable=writeable), origin=origin, namespace=namespace, writeable=writeable
         )
+        db._allow_temporary_tables = allow_temporary_tables
+        return db
 
     @abstractmethod
     def clone(self) -> Database:
@@ -539,6 +553,8 @@ class Database(ABC):
         support the full range of expected read-only butler behavior.
         """
         assert self._metadata is not None, "Static tables must be created before temporary tables"
+        if not self.supports_temporary_tables:
+            raise ReadOnlyDatabaseError("Creation of temporary tables is not supported by this database.")
         with self._session() as connection:
             table = self._make_temporary_table(connection, spec=spec, name=name)
             self._temp_tables.add(table.key)
@@ -1954,6 +1970,10 @@ class Database(ABC):
         """
         raise NotImplementedError()
 
+    @property
+    def supports_temporary_tables(self) -> bool:
+        return self._allow_temporary_tables
+
     @abstractmethod
     def apply_any_aggregate(self, column: sqlalchemy.ColumnElement[Any]) -> sqlalchemy.ColumnElement[Any]:
         """Wrap the given SQLAlchemy column in the ``ANY_VALUE`` aggregate

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/python/lsst/daf/butler/registry/obscore/_config.py

@@ -183,6 +183,11 @@ class ObsCoreConfig(pydantic.BaseModel):
     dimension. Will be left unset if `None`. Can be dangerous to set this
     in a repository containing data from multiple instruments."""
 
+    obs_publisher_did_fmt: str | None = None
+    """Format string to generate an obs_publisher_did for a record. Assumes
+    that a single string is suitable for all results.
+    """
+
 
 class ConfigCollectionType(str, enum.Enum):
     """Enum class defining possible values for configuration attributes."""

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/python/lsst/daf/butler/registry/obscore/_records.py

@@ -197,6 +197,9 @@ class RecordFactory:
         if dataset_config.datalink_url_fmt:
             record["access_url"] = dataset_config.datalink_url_fmt.format(**fmt_kws)
 
+        if self.config.obs_publisher_did_fmt:
+            record["obs_publisher_did"] = self.config.obs_publisher_did_fmt.format(**fmt_kws)
+
         extra_columns = {}
         if self.config.extra_columns:
             extra_columns.update(self.config.extra_columns)

{lsst_daf_butler-29.2025.2400 → lsst_daf_butler-29.2025.2500}/python/lsst/daf/butler/registry/sql_registry.py

@@ -187,7 +187,10 @@ class SqlRegistry:
 
         DatabaseClass = config.getDatabaseClass()
         database = DatabaseClass.fromUri(
-            config.connectionString, origin=config.get("origin", 0), namespace=config.get("namespace")
+            config.connectionString,
+            origin=config.get("origin", 0),
+            namespace=config.get("namespace"),
+            allow_temporary_tables=config.areTemporaryTablesAllowed,
         )
         managerTypes = RegistryManagerTypes.fromConfig(config)
         managers = managerTypes.makeRepo(database, dimensionConfig)
@@ -230,6 +233,7 @@ class SqlRegistry:
             origin=config.get("origin", 0),
             namespace=config.get("namespace"),
             writeable=writeable,
+            allow_temporary_tables=config.areTemporaryTablesAllowed,
         )
         managerTypes = RegistryManagerTypes.fromConfig(config)
         with database.session():