lsst-daf-butler 29.2025.4500__py3-none-any.whl → 29.2025.4800__py3-none-any.whl

lsst/daf/butler/__init__.py

@@ -41,9 +41,6 @@ from ._butler_config import *
 from ._butler_metrics import *
 from ._butler_repo_index import *
 from ._collection_type import CollectionType
-from ._column_categorization import *
-from ._column_tags import *
-from ._column_type_info import *
 from ._config import *
 from ._config_support import LookupKey
 from ._dataset_association import *

lsst/daf/butler/_butler.py

@@ -36,7 +36,7 @@ from abc import abstractmethod
 from collections.abc import Collection, Iterable, Iterator, Mapping, Sequence
 from contextlib import AbstractContextManager
 from types import EllipsisType
-from typing import TYPE_CHECKING, Any, TextIO
+from typing import TYPE_CHECKING, Any, Literal, Self, TextIO
 
 from lsst.resources import ResourcePath, ResourcePathExpression
 from lsst.utils import doImportType
@@ -94,7 +94,7 @@ class _DeprecatedDefault:
     """Default value for a deprecated parameter."""
 
 
-class Butler(LimitedButler):  # numpydoc ignore=PR02
+class Butler(LimitedButler, AbstractContextManager):  # numpydoc ignore=PR02
     """Interface for data butler and factory for Butler instances.
 
     Parameters
@@ -358,6 +358,16 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
             case _:
                 raise TypeError(f"Unknown Butler type '{butler_type}'")
 
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> Literal[False]:
+        try:
+            self.close()
+        except Exception:
+            _LOG.exception("An exception occured during Butler.close()")
+        return False
+
     @staticmethod
     def makeRepo(
         root: ResourcePathExpression,
@@ -506,9 +516,10 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
         # Create Registry and populate tables
         registryConfig = RegistryConfig(config.get("registry"))
         dimensionConfig = DimensionConfig(dimensionConfig)
-        _RegistryFactory(registryConfig).create_from_config(
+        registry = _RegistryFactory(registryConfig).create_from_config(
             dimensionConfig=dimensionConfig, butlerRoot=root_uri
         )
+        registry.close()
 
         _LOG.verbose("Wrote new Butler configuration file to %s", configURI)
 
@@ -1012,7 +1023,7 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
     @abstractmethod
     def get_dataset(
         self,
-        id: DatasetId,
+        id: DatasetId | str,
         *,
         storage_class: str | StorageClass | None = None,
         dimension_records: bool = False,
@@ -1023,7 +1034,8 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
         Parameters
         ----------
         id : `DatasetId`
-            The unique identifier for the dataset.
+            The unique identifier for the dataset, as an instance of
+            `uuid.UUID` or a string containing a hexadecimal number.
         storage_class : `str` or `StorageClass` or `None`
             A storage class to use when creating the returned entry. If given
             it must be compatible with the default storage class.
@@ -1040,6 +1052,26 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
         """
         raise NotImplementedError()
 
+    @abstractmethod
+    def get_many_datasets(self, ids: Iterable[DatasetId | str]) -> list[DatasetRef]:
+        """Retrieve a list of dataset entries.
+
+        Parameters
+        ----------
+        ids : `~collections.abc.Iterable` [ `DatasetId` or `str` ]
+            The unique identifiers for the datasets, as instances of
+            `uuid.UUID` or strings containing a hexadecimal number.
+
+        Returns
+        -------
+        refs : `list` [ `DatasetRef` ]
+            A list containing a `DatasetRef` for each of the given dataset IDs.
+            If a dataset was not found, no error is thrown -- it is just not
+            included in the list.  The returned datasets are in no particular
+            order.
+        """
+        raise NotImplementedError()
+
     @abstractmethod
     def find_dataset(
         self,
@@ -2201,3 +2233,18 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
             Metrics object to record butler statistics.
         """
         raise NotImplementedError()
+
+    @abstractmethod
+    def close(self) -> None:
+        """Release all resources associated with this Butler instance.  The
+        instance may no longer be used after this is called.
+
+        Notes
+        -----
+        Instead of calling ``close()``directly, you can use the Butler object
+        as a context manager.  For example::
+          with Butler(...) as butler:
+              butler.get(...)
+          # butler is closed after exiting the block.
+        """
+        raise NotImplementedError()

lsst/daf/butler/_dataset_provenance.py

@@ -112,6 +112,8 @@ class DatasetProvenance(pydantic.BaseModel):
         sep: str = ".",
         simple_types: bool = False,
         use_upper: bool | None = None,
+        max_inputs: int | None = None,
+        store_minimalist_inputs: bool = False,
     ) -> dict[str, _PROV_TYPES]:
         """Return provenance as a flattened dictionary.
 
@@ -137,6 +139,13 @@ class DatasetProvenance(pydantic.BaseModel):
             character of the prefix (defined by whether `str.isupper()` returns
             true, else they will be lower case). If `False` the case will be
             lower case, and if `True` the case will be upper case.
+        max_inputs : `int` or `None`, optional
+            Maximum number of inputs to be recorded in provenance. `None`
+            results in all inputs being recorded. If the number of inputs
+            exceeds this value no input provenance will be recorded.
+        store_minimalist_inputs : `bool`, optional
+            If `True` only the ID of the input is stored along with explicit
+            extras. If `False` the run and dataset type are also recorded.
 
         Returns
         -------
@@ -155,7 +164,13 @@ class DatasetProvenance(pydantic.BaseModel):
 
         Each input dataset will have the ``id``, ``run``, and ``datasettype``
         keys as defined above (but no ``dataid`` key) with an ``input N``
-        prefix where ``N`` starts counting at 0.
+        prefix where ``N`` starts counting at 0. It is possible to drop
+        the ``datasettype`` and ``run`` to save space by using the
+        ``store_minimalist_inputs`` flag.
+
+        If there are too many inputs (see the ``max_inputs`` parameters)
+        no inputs will be recorded. The number of inputs is always recorded
+        to indicate that the inputs were dropped.
 
         The quantum ID, if present, will use key ``quantum``.
 
@@ -171,6 +186,7 @@ class DatasetProvenance(pydantic.BaseModel):
             "lsst.butler.dataid.detector": 10,
             "lsst.butler.dataid.instrument": "LSSTCam",
             "lsst.butler.quantum": "d93a735b-08f0-477d-bc95-2cc32d6d898b",
+            "lsst.butler.n_inputs": 2,
             "lsst.butler.input.0.id": "3dfd7ba5-5e35-4565-9d87-4b33880ed06c",
             "lsst.butler.input.0.run": "other_run",
             "lsst.butler.input.0.datasettype": "astropy_parquet",
@@ -206,12 +222,28 @@ class DatasetProvenance(pydantic.BaseModel):
         if self.quantum_id is not None:
             prov[_make_key("quantum")] = self.quantum_id if not simple_types else str(self.quantum_id)
 
-        for i, input in enumerate(self.inputs):
+        # Record the number of inputs so that people can determine how many
+        # there were even if they were dropped because they exceeded the
+        # allowed maximum. Do not record the count if we have a null provenance
+        # state with no ref and no inputs.
+        if ref is not None or len(self.inputs) > 0:
+            prov[_make_key("n_inputs")] = len(self.inputs)
+
+        # Remove all inputs if the maximum is found. Truncating to the
+        # maximum (or auto switching to minimalist mode and increasing the
+        # maximum by 3) is not preferred.
+        inputs = (
+            self.inputs
+            if max_inputs is None or (max_inputs is not None and len(self.inputs) <= max_inputs)
+            else []
+        )
+        for i, input in enumerate(inputs):
             prov[_make_key("input", i, "id")] = input.id if not simple_types else str(input.id)
-            if input.run is not None:  # for mypy
-                prov[_make_key("input", i, "run")] = input.run
-            if input.datasetType is not None:  # for mypy
-                prov[_make_key("input", i, "datasettype")] = input.datasetType.name
+            if not store_minimalist_inputs:
+                if input.run is not None:  # for mypy
+                    prov[_make_key("input", i, "run")] = input.run
+                if input.datasetType is not None:  # for mypy
+                    prov[_make_key("input", i, "datasettype")] = input.datasetType.name
 
             if input.id in self.extras:
                 for xk, xv in self.extras[input.id].items():
@@ -369,7 +401,9 @@ class DatasetProvenance(pydantic.BaseModel):
             # Prefix will always include the separator if it is defined.
             prefix += sep
 
-        core_provenance = tuple(f"{prefix}{k}".lower() for k in ("run", "id", "datasettype", "quantum"))
+        core_provenance = tuple(
+            f"{prefix}{k}".lower() for k in ("run", "id", "datasettype", "quantum", "n_inputs")
+        )
 
         # Need to escape the prefix and separator for regex usage.
         esc_sep = re.escape(sep)
@@ -445,7 +479,7 @@ class DatasetProvenance(pydantic.BaseModel):
 
         quantum_id = None
         ref_id = None
-        input_ids = {}
+        input_ids: dict[int, uuid.UUID] = {}
         extras: dict[int, dict[str, Any]] = {}
 
         for k, standard in prov_keys.items():
@@ -475,8 +509,9 @@ class DatasetProvenance(pydantic.BaseModel):
 
         provenance = cls(quantum_id=quantum_id)
 
+        input_refs = {ref.id: ref for ref in butler.get_many_datasets(input_ids.values())}
         for i in sorted(input_ids):
-            input_ref = butler.get_dataset(input_ids[i])
+            input_ref = input_refs.get(input_ids[i])
             if input_ref is None:
                 raise ValueError(f"Input dataset ({input_ids[i]}) is not known to this butler.")
             provenance.add_input(input_ref)

lsst/daf/butler/_labeled_butler_factory.py

@@ -25,9 +25,11 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+from __future__ import annotations
+
 __all__ = ("LabeledButlerFactory", "LabeledButlerFactoryProtocol")
 
-from collections.abc import Callable, Mapping
+from collections.abc import Mapping
 from typing import Protocol
 
 from lsst.resources import ResourcePathExpression
@@ -38,10 +40,6 @@ from ._butler_repo_index import ButlerRepoIndex
 from ._utilities.named_locks import NamedLocks
 from ._utilities.thread_safe_cache import ThreadSafeCache
 
-_FactoryFunction = Callable[[str | None], Butler]
-"""Function that takes an access token string or `None`, and returns a Butler
-instance."""
-
 
 class LabeledButlerFactoryProtocol(Protocol):
     """Callable to retrieve a butler from a label."""
@@ -84,7 +82,7 @@ class LabeledButlerFactory:
         else:
             self._repositories = dict(repositories)
 
-        self._factories = ThreadSafeCache[str, _FactoryFunction]()
+        self._factories = ThreadSafeCache[str, _ButlerFactory]()
         self._initialization_locks = NamedLocks()
 
         # This may be overridden by unit tests.
@@ -138,10 +136,18 @@ class LabeledButlerFactory:
         based on the end user instead of the service. See
         https://gafaelfawr.lsst.io/user-guide/gafaelfawringress.html#requesting-delegated-tokens
         """
-        factory = self._get_or_create_butler_factory_function(label)
-        return factory(access_token)
+        factory = self._get_or_create_butler_factory(label)
+        return factory.create_butler(access_token)
+
+    def close(self) -> None:
+        """Reset the factory cache, and release any resources associated with
+        the cached instances.
+        """
+        factories = self._factories.clear()
+        for factory in factories.values():
+            factory.close()
 
-    def _get_or_create_butler_factory_function(self, label: str) -> _FactoryFunction:
+    def _get_or_create_butler_factory(self, label: str) -> _ButlerFactory:
         # We maintain a separate lock per label.  We only want to instantiate
         # one factory function per label, because creating the factory sets up
         # shared state that should only exist once per repository.  However, we
@@ -154,16 +160,16 @@ class LabeledButlerFactory:
             factory = self._create_butler_factory_function(label)
             return self._factories.set_or_get(label, factory)
 
-    def _create_butler_factory_function(self, label: str) -> _FactoryFunction:
+    def _create_butler_factory_function(self, label: str) -> _ButlerFactory:
         config_uri = self._get_config_uri(label)
         config = ButlerConfig(config_uri)
         butler_type = config.get_butler_type()
 
         match butler_type:
             case ButlerType.DIRECT:
-                return _create_direct_butler_factory(config, self._preload_unsafe_direct_butler_caches)
+                return _DirectButlerFactory(config, self._preload_unsafe_direct_butler_caches)
             case ButlerType.REMOTE:
-                return _create_remote_butler_factory(config)
+                return _RemoteButlerFactory(config)
             case _:
                 raise TypeError(f"Unknown butler type '{butler_type}' for label '{label}'")
 
@@ -177,34 +183,45 @@ class LabeledButlerFactory:
             return config_uri
 
 
-def _create_direct_butler_factory(config: ButlerConfig, preload_unsafe_caches: bool) -> _FactoryFunction:
-    import lsst.daf.butler.direct_butler
+class _ButlerFactory(Protocol):
+    def create_butler(self, access_token: str | None) -> Butler: ...
+    def close(self) -> None: ...
+
+
+class _DirectButlerFactory(_ButlerFactory):
+    def __init__(self, config: ButlerConfig, preload_unsafe_caches: bool) -> None:
+        import lsst.daf.butler.direct_butler
 
-    # Create a 'template' Butler that will be cloned when callers request an
-    # instance.
-    butler = Butler.from_config(config)
-    assert isinstance(butler, lsst.daf.butler.direct_butler.DirectButler)
+        # Create a 'template' Butler that will be cloned when callers request
+        # an instance.
+        self._butler = Butler.from_config(config)
+        assert isinstance(self._butler, lsst.daf.butler.direct_butler.DirectButler)
 
-    # Load caches so that data is available in cloned instances without
-    # needing to refetch it from the database for every instance.
-    butler._preload_cache(load_dimension_record_cache=preload_unsafe_caches)
+        # Load caches so that data is available in cloned instances without
+        # needing to refetch it from the database for every instance.
+        self._butler._preload_cache(load_dimension_record_cache=preload_unsafe_caches)
 
-    def create_butler(access_token: str | None) -> Butler:
+    def create_butler(self, access_token: str | None) -> Butler:
         # Access token is ignored because DirectButler does not use Gafaelfawr
         # authentication.
-        return butler.clone()
+        return self._butler.clone()
 
-    return create_butler
+    def close(self) -> None:
+        self._butler.close()
 
 
-def _create_remote_butler_factory(config: ButlerConfig) -> _FactoryFunction:
-    import lsst.daf.butler.remote_butler._factory
+class _RemoteButlerFactory(_ButlerFactory):
+    def __init__(self, config: ButlerConfig) -> None:
+        import lsst.daf.butler.remote_butler._factory
 
-    factory = lsst.daf.butler.remote_butler._factory.RemoteButlerFactory.create_factory_from_config(config)
+        self._factory = lsst.daf.butler.remote_butler._factory.RemoteButlerFactory.create_factory_from_config(
+            config
+        )
 
-    def create_butler(access_token: str | None) -> Butler:
+    def create_butler(self, access_token: str | None) -> Butler:
         if access_token is None:
             raise ValueError("Access token is required to connect to a Butler server")
-        return factory.create_butler_for_access_token(access_token)
+        return self._factory.create_butler_for_access_token(access_token)
 
-    return create_butler
+    def close(self) -> None:
+        pass

lsst/daf/butler/_quantum_backed.py

@@ -55,7 +55,7 @@ from .datastore import Datastore
 from .datastore.record_data import DatastoreRecordData, SerializedDatastoreRecordData
 from .datastores.file_datastore.retrieve_artifacts import retrieve_and_zip
 from .dimensions import DimensionUniverse
-from .registry.interfaces import DatastoreRegistryBridgeManager, OpaqueTableStorageManager
+from .registry.interfaces import Database, DatastoreRegistryBridgeManager, OpaqueTableStorageManager
 
 if TYPE_CHECKING:
     from ._butler import Butler
@@ -83,6 +83,9 @@ class QuantumBackedButler(LimitedButler):
         The registry dataset type definitions, indexed by name.
     metrics : `lsst.daf.butler.ButlerMetrics` or `None`, optional
         Metrics object for tracking butler statistics.
+    database : `Database`, optional
+        Database instance used by datastore.  Not required -- only provided
+        to allow database connections to be closed during cleanup.
 
     Notes
     -----
@@ -130,6 +133,7 @@ class QuantumBackedButler(LimitedButler):
         storageClasses: StorageClassFactory,
         dataset_types: Mapping[str, DatasetType] | None = None,
         metrics: ButlerMetrics | None = None,
+        database: Database | None = None,
     ):
         self._dimensions = dimensions
         self._predicted_inputs = set(predicted_inputs)
@@ -142,6 +146,7 @@ class QuantumBackedButler(LimitedButler):
         self.storageClasses = storageClasses
         self._dataset_types: Mapping[str, DatasetType] = {}
         self._metrics = metrics if metrics is not None else ButlerMetrics()
+        self._database = database
         if dataset_types is not None:
             self._dataset_types = dataset_types
         self._datastore.set_retrieve_dataset_type_method(self._retrieve_dataset_type)
@@ -321,7 +326,7 @@ class QuantumBackedButler(LimitedButler):
             Metrics object for gathering butler statistics.
         """
         butler_config = ButlerConfig(config, searchPaths=search_paths)
-        datastore, _ = instantiate_standalone_datastore(
+        datastore, database = instantiate_standalone_datastore(
             butler_config, dimensions, filename, OpaqueManagerClass, BridgeManagerClass
         )
 
@@ -342,8 +347,13 @@ class QuantumBackedButler(LimitedButler):
             storageClasses=storageClasses,
             dataset_types=dataset_types,
             metrics=metrics,
+            database=database,
         )
 
+    def close(self) -> None:
+        if self._database is not None:
+            self._database.dispose()
+
     def _retrieve_dataset_type(self, name: str) -> DatasetType | None:
         """Return DatasetType defined in registry given dataset type name."""
         return self._dataset_types.get(name)

lsst/daf/butler/_utilities/thread_safe_cache.py

@@ -76,3 +76,16 @@ class ThreadSafeCache(Generic[TKey, TValue]):
         """
         with self._mutex:
             return self._cache.setdefault(key, value)
+
+    def clear(self) -> dict[TKey, TValue]:
+        """Clear the cache.
+
+        Returns
+        -------
+        old_cache : `dict`
+            The values that were contained in the cache prior to clearing it.
+        """
+        with self._mutex:
+            old = self._cache
+            self._cache = {}
+            return old

lsst/daf/butler/cli/cmd/commands.py

@@ -33,6 +33,7 @@ from typing import Any
 import click
 
 from ... import script
+from ..._butler import Butler
 from ..opt import (
     collection_argument,
     collection_type_option,
@@ -487,9 +488,11 @@ def remove_dataset_type(*args: Any, **kwargs: Any) -> None:
 @options_file_option()
 def query_datasets(**kwargs: Any) -> None:
     """List the datasets in a repository."""
-    for table in script.QueryDatasets(**kwargs).getTables():
-        print("")
-        table.pprint_all()
+    repo = kwargs.pop("repo")
+    with Butler.from_config(repo, writeable=False) as butler:
+        for table in script.QueryDatasets(butler=butler, **kwargs).getTables():
+            print("")
+            table.pprint_all()
     print("")
 
 

lsst/daf/butler/configs/datastores/formatters.yaml

@@ -93,8 +93,9 @@ MultipleCellCoadd: lsst.cell_coadds.CellCoaddFitsFormatter
 NNModelPackagePayload: lsst.meas.transiNet.modelPackages.NNModelPackageFormatter
 Timespan: lsst.daf.butler.formatters.json.JsonFormatter
 RegionTimeInfo: lsst.daf.butler.formatters.json.JsonFormatter
-QPEnsemble: lsst.meas.pz.qp_formatter.QPFormatter
-PZModel: lsst.meas.pz.model_formatter.ModelFormatter
+QPEnsemble: lsst.meas.photoz.base.qp_formatter.QPFormatter
+PZModel: lsst.meas.photoz.base.model_formatter.ModelFormatter
+PhotozModel: lsst.meas.photoz.base.model_formatter.ModelFormatter
 VisitBackgroundModel: lsst.daf.butler.formatters.json.JsonFormatter
 VignettingCorrection: lsst.ts.observatory.control.utils.extras.vignetting_storage.VignettingCorrectionFormatter
 SSPAuxiliaryFile: lsst.pipe.tasks.sspAuxiliaryFile.SSPAuxiliaryFileFormatter

lsst/daf/butler/configs/datastores/writeRecipes.yaml

@@ -12,19 +12,19 @@ lsst.obs.base.formatters.fitsExposure.StandardFitsImageFormatterBase: &StandardF
     variance:
       <<: *losslessOptions
 
-  # Basic lossy (quantizing) compression
-  lossyBasic: &lossyBasic
-    image: &lossyBasicOptions
+  # Lossy (quantizing) compression with noise sigma subdivided into 16.
+  lossy16:
+    image: &lossy16Options
       algorithm: RICE_1
       quantization:
         dither: SUBTRACTIVE_DITHER_2
         scaling: STDEV_MASKED
-        mask_planes: ["NO_DATA"]
-        level: 10.0
+        mask_planes: ["NO_DATA", "INTRP"]
+        level: 16.0
     mask:
       <<: *losslessOptions
     variance:
-      <<: *lossyBasicOptions
+      <<: *lossy16Options
 
   # Set the default
   default:

lsst/daf/butler/configs/storageClasses.yaml

@@ -433,6 +433,8 @@ storageClasses:
     pytype: qp.Ensemble
   PZModel:
     pytype: rail.core.model.Model
+  PhotozModel:
+    pytype: rail.core.model.Model
   VisitBackgroundModel:
     pytype: lsst.drp.tasks.fit_visit_background.VisitBackgroundModel
   VignettingCorrection:

lsst/daf/butler/delegates/arrowtable.py

@@ -229,7 +229,9 @@ def _add_arrow_provenance(
     type_string = _checkArrowCompatibleType(in_memory_dataset)
     if type_string == "astropy":
         provenance = provenance if provenance is not None else DatasetProvenance()
-        prov_dict = provenance.to_flat_dict(ref, prefix="LSST.BUTLER", sep=".", simple_types=True)
+        prov_dict = provenance.to_flat_dict(
+            ref, prefix="LSST.BUTLER", sep=".", simple_types=True, max_inputs=2000
+        )
 
         # Strip any previous provenance.
         DatasetProvenance.strip_provenance_from_flat_dict(in_memory_dataset.meta)

lsst/daf/butler/dimensions/_schema.py

@@ -29,20 +29,17 @@ from __future__ import annotations
 __all__ = ("DimensionRecordSchema", "addDimensionForeignKey")
 
 import copy
-from collections.abc import Mapping, Set
+from collections.abc import Set
 from typing import TYPE_CHECKING
 
-from lsst.utils.classes import cached_getter, immutable
+from lsst.utils.classes import immutable
 
 from .. import arrow_utils, ddl
-from .._column_tags import DimensionKeyColumnTag, DimensionRecordColumnTag
 from .._named import NamedValueAbstractSet, NamedValueSet
 from ..column_spec import RegionColumnSpec, TimespanColumnSpec
 from ..timespan_database_representation import TimespanDatabaseRepresentation
 
 if TYPE_CHECKING:  # Imports needed only for type annotations; may be circular.
-    from lsst.daf.relation import ColumnTag
-
     from ._elements import Dimension, DimensionElement, KeyColumnSpec, MetadataColumnSpec
     from ._group import DimensionGroup
 
@@ -387,25 +384,6 @@ class DimensionElementFields:
             lines.append("  timespan: lsst.daf.butler.Timespan")
         return "\n".join(lines)
 
-    @property
-    @cached_getter
-    def columns(self) -> Mapping[ColumnTag, str]:
-        """A mapping from `ColumnTag` to field name for all fields in this
-        element's records (`~collections.abc.Mapping`).
-        """
-        result: dict[ColumnTag, str] = {}
-        for dimension_name, field_name in zip(
-            self.element.dimensions.names, self.dimensions.names, strict=True
-        ):
-            result[DimensionKeyColumnTag(dimension_name)] = field_name
-        for field_name in self.facts.names:
-            result[DimensionRecordColumnTag(self.element.name, field_name)] = field_name
-        if self.element.spatial:
-            result[DimensionRecordColumnTag(self.element.name, "region")] = "region"
-        if self.element.temporal:
-            result[DimensionRecordColumnTag(self.element.name, "timespan")] = "timespan"
-        return result
-
     element: DimensionElement
     """The dimension element these fields correspond to.