lsst-daf-butler 30.0.0rc2__py3-none-any.whl → 30.0.1__py3-none-any.whl

lsst/daf/butler/direct_query_driver/_driver.py

@@ -610,15 +610,15 @@ class DirectQueryDriver(QueryDriver):
         ----------
         tree : `.queries.tree.QueryTree`
             Description of the joins and row filters in the query.
+        allow_duplicate_overlaps : `bool`, optional
+            If set to `True` then query will be allowed to generate
+            non-distinct rows for spatial overlaps.
 
         Returns
         -------
         tree_analysis : `QueryTreeAnalysis`
             Struct containing additional information need to build the joins
             stage of a query.
-        allow_duplicate_overlaps : `bool`, optional
-            If set to `True` then query will be allowed to generate
-            non-distinct rows for spatial overlaps.
 
         Notes
         -----
@@ -1313,7 +1313,8 @@ class DirectQueryDriver(QueryDriver):
             Mapping of collection names to collection records, must contain
             records for all collections in ``collection_names`` and all their
             children collections.
-        summaries : `~collections.abc.Mapping` [`Any`, `CollectionSummary`]
+        summaries : `~collections.abc.Mapping` [`typing.Any`, \
+              `CollectionSummary`]
             Mapping of collection IDs to collection summaries, must contain
             summaries for all non-chained collections in the collection tree.
 

lsst/daf/butler/direct_query_driver/_result_page_converter.py

@@ -386,7 +386,7 @@ class _GeneralColumnConverter:
 
         Returns
         -------
-        value : `Any`
+        value : `typing.Any`
             Result of the conversion.
         """
         raise NotImplementedError()

lsst/daf/butler/formatters/parquet.py

@@ -270,18 +270,18 @@ def arrow_to_pandas(arrow_table: pa.Table) -> pd.DataFrame:
 
 
 def arrow_to_astropy(arrow_table: pa.Table) -> atable.Table:
-    """Convert a pyarrow table to an `astropy.Table`.
+    """Convert a pyarrow table to an `astropy.table.Table`.
 
     Parameters
     ----------
     arrow_table : `pyarrow.Table`
         Input arrow table to convert. If the table has astropy unit
         metadata in the schema it will be used in the construction
-        of the ``astropy.Table``.
+        of the ``astropy.table.Table``.
 
     Returns
     -------
-    table : `astropy.Table`
+    table : `astropy.table.Table`
         Converted astropy table.
     """
     from astropy.table import Table
@@ -520,7 +520,7 @@ def astropy_to_arrow(astropy_table: atable.Table) -> pa.Table:
 
     Parameters
     ----------
-    astropy_table : `astropy.Table`
+    astropy_table : `astropy.table.Table`
         Input astropy table.
 
     Returns
@@ -584,7 +584,7 @@ def astropy_to_pandas(astropy_table: atable.Table, index: str | None = None) ->
 
     Parameters
     ----------
-    astropy_table : `astropy.Table`
+    astropy_table : `astropy.table.Table`
         Input astropy table.
     index : `str`, optional
         Name of column to set as index.
@@ -640,7 +640,7 @@ def _astropy_to_numpy_dict(astropy_table: atable.Table) -> dict[str, np.ndarray]
 
     Parameters
     ----------
-    astropy_table : `astropy.Table`
+    astropy_table : `astropy.table.Table`
         Input astropy table.
 
     Returns

lsst/daf/butler/logging.py

@@ -764,11 +764,17 @@ class ButlerLogRecords(MutableSequence[ButlerLogRecord]):
 
 
 class ButlerLogRecordHandler(StreamHandler):
-    """Python log handler that accumulates records."""
+    """Python log handler that accumulates records.
 
-    def __init__(self) -> None:
+    Parameters
+    ----------
+    records : `ButlerLogRecords`, optional
+        Container to store logs in.
+    """
+
+    def __init__(self, records: ButlerLogRecords | None = None) -> None:
         super().__init__()
-        self.records = ButlerLogRecords([])
+        self.records = ButlerLogRecords([]) if records is None else records
 
     def emit(self, record: LogRecord) -> None:
         self.records.append(record)

lsst/daf/butler/nonempty_mapping.py

@@ -43,7 +43,7 @@ _V = TypeVar("_V", bound=Copyable, covariant=True)
 
 
 class NonemptyMapping(Mapping[_K, _V]):
-    """A `Mapping` that implicitly adds values (like
+    """A `~collections.abc.Mapping` that implicitly adds values (like
     `~collections.defaultdict`) but treats any that evaluate to `False` as not
     present.
 

lsst/daf/butler/persistence_context.py

@@ -180,17 +180,20 @@ class PersistenceContextVars:
 
         Parameters
         ----------
-        function : `Callable`
+        function : `collections.abc.Callable`
             A callable which is to be executed inside a specific context.
         *args : tuple
-            Positional arguments which are to be passed to the `Callable`.
+            Positional arguments which are to be passed to the
+            `~collections.abc.Callable`.
         **kwargs : dict, optional
-            Extra key word arguments which are to be passed to the `Callable`.
+            Extra key word arguments which are to be passed to the
+            `~collections.abc.Callable`.
 
         Returns
         -------
-        result : `Any`
-            The result returned by executing the supplied `Callable`.
+        result : `typing.Any`
+            The result returned by executing the supplied
+            `~collections.abc.Callable`.
         """
         self._ctx = copy_context()
         # Type checkers seem to have trouble with a second layer nesting of

lsst/daf/butler/queries/_general_query_results.py

@@ -93,7 +93,7 @@ class GeneralQueryResults(QueryResultsBase):
 
         Yields
         ------
-        row_dict : `dict` [`str`, `Any`]
+        row_dict : `dict` [`str`, `typing.Any`]
             Result row as dictionary, the keys are the names of the dimensions,
             dimension fields (separated from dimension by dot) or dataset type
             fields (separated from dataset type name by dot).

lsst/daf/butler/queries/driver.py

@@ -245,7 +245,7 @@ class QueryDriver(AbstractContextManager[None]):
         ----------
         dimensions : `DimensionGroup`
             Dimensions of the data coordinates.
-        rows : `Iterable` [ `tuple` ]
+        rows : `~collections.abc.Iterable` [ `tuple` ]
             Tuples of data coordinate values, covering just the "required"
             subset of ``dimensions``.
 

lsst/daf/butler/queries/expression_factory.py

@@ -557,7 +557,7 @@ class ExpressionFactory:
         -------
         logical_and : `tree.Predicate`
             A boolean expression that evaluates to `True` only if all operands
-            evaluate to `True.
+            evaluate to `True`.
         """
         return first.logical_and(*args)
 
@@ -575,7 +575,7 @@ class ExpressionFactory:
         -------
         logical_or : `tree.Predicate`
             A boolean expression that evaluates to `True` if any operand
-            evaluates to `True.
+            evaluates to `True`.
         """
         return first.logical_or(*args)
 

lsst/daf/butler/queries/expressions/parser/exprTree.py

@@ -561,7 +561,7 @@ class PolygonNode(Node):
 
     Parameters
     ----------
-    vertices : `list`[`tuple`[`Node`, `Node`]]
+    vertices : `list` [`tuple` [`Node`, `Node`]]
         Node representing vertices of polygon.
     """
 

lsst/daf/butler/queries/expressions/parser/parserYacc.py

@@ -109,7 +109,7 @@ def _parseTimeString(time_str: str) -> astropy.time.Time:
     Returns
     -------
     time : `astropy.time.Time`
-       The parsed time.
+        The parsed time.
 
     Raises
     ------

lsst/daf/butler/queries/overlaps.py

@@ -69,9 +69,9 @@ class _NaiveDisjointSet(Generic[_T]):
 
         Parameters
         ----------
-        a :
+        a
             Element whose subset should be merged.
-        b :
+        b
             Element whose subset should be merged.
 
         Returns

lsst/daf/butler/queries/tree/_column_set.py

@@ -429,7 +429,7 @@ class ColumnOrder:
 
         Parameters
         ----------
-        row : `Sequence` [ `DataIdValue` ]
+        row : `~collections.abc.Sequence` [ `DataIdValue` ]
             A row output by the SQL query associated with these columns.
         """
         return row[: len(self._dimension_keys)]

lsst/daf/butler/registry/_collection_record_cache.py

@@ -135,7 +135,7 @@ class CollectionRecordCache:
 
         Parameters
         ----------
-        key : `Any`
+        key : `typing.Any`
             Collection key.
 
         Returns

lsst/daf/butler/registry/_collection_summary_cache.py

@@ -54,7 +54,8 @@ class CollectionSummaryCache:
 
         Parameters
         ----------
-        summaries : `~collections.abc.Mapping` [`Any`, `CollectionSummary`]
+        summaries : `~collections.abc.Mapping` [`typing.Any`, \
+              `CollectionSummary`]
             Summary records indexed by collection key, records must include all
             dataset types.
         """
@@ -65,15 +66,15 @@ class CollectionSummaryCache:
 
         Parameters
         ----------
-        keys : `~collections.abc.Iterable` [`Any`]
+        keys : `~collections.abc.Iterable` [`typing.Any`]
             Sequence of collection keys.
 
         Returns
         -------
-        summaries : `dict` [`Any`, `CollectionSummary`]
+        summaries : `dict` [`typing.Any`, `CollectionSummary`]
             Dictionary of summaries indexed by collection keys, includes
             records found in the cache.
-        missing_keys : `set` [`Any`]
+        missing_keys : `set` [`typing.Any`]
             Collection keys that are not present in the cache.
         """
         found = {}

lsst/daf/butler/registry/_registry.py

@@ -437,6 +437,10 @@ class Registry(ABC):
             Name of the type to be removed or tuple containing a list of type
             names to be removed. Wildcards are allowed.
 
+        Returns
+        -------
+        None
+
         Raises
         ------
         lsst.daf.butler.registry.OrphanedRecordError

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

@@ -215,20 +215,24 @@ class MonolithicDatastoreRegistryBridge(DatastoreRegistryBridge):
     def check(self, refs: Iterable[DatasetIdRef]) -> Iterable[DatasetIdRef]:
         # Docstring inherited from DatastoreRegistryBridge
         byId = {ref.id: ref for ref in refs}
-        sql = (
-            sqlalchemy.sql.select(self._tables.dataset_location.columns.dataset_id)
-            .select_from(self._tables.dataset_location)
-            .where(
-                sqlalchemy.sql.and_(
-                    self._tables.dataset_location.columns.datastore_name == self.datastoreName,
-                    self._tables.dataset_location.columns.dataset_id.in_(byId.keys()),
+        found: list[DatasetIdRef] = []
+        with self._db.session():
+            for batch in chunk_iterable(byId.keys(), 50000):
+                sql = (
+                    sqlalchemy.sql.select(self._tables.dataset_location.columns.dataset_id)
+                    .select_from(self._tables.dataset_location)
+                    .where(
+                        sqlalchemy.sql.and_(
+                            self._tables.dataset_location.columns.datastore_name == self.datastoreName,
+                            self._tables.dataset_location.columns.dataset_id.in_(batch),
+                        )
+                    )
                 )
-            )
-        )
-        with self._db.query(sql) as sql_result:
-            sql_rows = sql_result.fetchall()
-        for row in sql_rows:
-            yield byId[row.dataset_id]
+                with self._db.query(sql) as sql_result:
+                    sql_ids = sql_result.scalars().all()
+                found.extend(byId[id] for id in sql_ids)
+
+        return found
 
     @contextmanager
     def emptyTrash(

lsst/daf/butler/registry/databases/postgresql.py

@@ -92,7 +92,8 @@ class PostgresqlDatabase(Database):
         allow_temporary_tables: bool = True,
     ):
         with engine.connect() as connection:
-            # `Any` to make mypy ignore the line below, can't use type: ignore
+            # `typing.Any` to make mypy ignore the line below, can't
+            # use type: ignore
             dbapi: Any = connection.connection
             try:
                 dsn = dbapi.get_dsn_parameters()

lsst/daf/butler/registry/datasets/byDimensions/_dataset_type_cache.py

@@ -155,7 +155,7 @@ class DatasetTypeCache:
         dataset_type : `DatasetType` or `None`
             Cached dataset type, `None` is returned if the name is not in the
             cache.
-        extra : `Any` or `None`
+        extra : `typing.Any` or `None`
             Cached opaque data, `None` is returned if the name is not in the
             cache.
         """

lsst/daf/butler/registry/datasets/byDimensions/_manager.py

@@ -12,6 +12,8 @@ from typing import TYPE_CHECKING, Any, ClassVar
 import astropy.time
 import sqlalchemy
 
+from lsst.utils.iteration import chunk_iterable
+
 from .... import ddl
 from ...._collection_type import CollectionType
 from ...._dataset_ref import DatasetId, DatasetIdFactory, DatasetIdGenEnum, DatasetRef
@@ -424,17 +426,18 @@ class ByDimensionsDatasetRecordStorageManagerUUID(DatasetRecordStorageManager):
         return result
 
     def get_dataset_refs(self, ids: list[DatasetId]) -> list[DatasetRef]:
-        # Look up the dataset types corresponding to the given Dataset IDs.
-        id_col = self._static.dataset.columns["id"]
-        sql = sqlalchemy.sql.select(
-            id_col,
-            self._static.dataset.columns["dataset_type_id"],
-        ).where(id_col.in_(ids))
-        with self._db.query(sql) as sql_result:
-            dataset_rows = sql_result.mappings().all()
-        dataset_type_map: dict[DatasetId, DatasetType] = {
-            row["id"]: self._get_dataset_type_by_id(row["dataset_type_id"]) for row in dataset_rows
-        }
+        dataset_type_map: dict[DatasetId, DatasetType] = {}
+        for batch in chunk_iterable(set(ids), 50000):
+            # Look up the dataset types corresponding to the given Dataset IDs.
+            id_col = self._static.dataset.columns["id"]
+            sql = sqlalchemy.sql.select(
+                id_col,
+                self._static.dataset.columns["dataset_type_id"],
+            ).where(id_col.in_(batch))
+            with self._db.query(sql) as sql_result:
+                dataset_rows = sql_result.mappings().all()
+            for row in dataset_rows:
+                dataset_type_map[row["id"]] = self._get_dataset_type_by_id(row["dataset_type_id"])
 
         # Group the given dataset IDs by the DimensionGroup of their dataset
         # types -- there is a separate tags table for each DimensionGroup.
@@ -448,40 +451,41 @@ class ByDimensionsDatasetRecordStorageManagerUUID(DatasetRecordStorageManager):
             # data IDs corresponding to the UUIDs found from the dataset table.
             dynamic_tables = self._get_dynamic_tables(dimension_group)
             tags_table = self._get_tags_table(dynamic_tables)
-            tags_sql = tags_table.select().where(tags_table.columns["dataset_id"].in_(datasets))
-            # Join in the collection table to fetch the run name.
-            collection_column = tags_table.columns[self._collections.getCollectionForeignKeyName()]
-            joined_collections = self._collections.join_collections_sql(collection_column, tags_sql)
-            tags_sql = joined_collections.joined_sql
-            run_name_column = joined_collections.name_column
-            tags_sql = tags_sql.add_columns(run_name_column)
-            # Tags table includes run collections and tagged
-            # collections.
-            # In theory the data ID for a given dataset should be the
-            # same in both, but nothing actually guarantees this.
-            # So skip any tagged collections, using the run collection
-            # as the definitive definition.
-            tags_sql = tags_sql.where(joined_collections.type_column == int(CollectionType.RUN))
-
-            with self._db.query(tags_sql) as sql_result:
-                data_id_rows = sql_result.mappings().all()
-
-            assert run_name_column.key is not None
-            for data_id_row in data_id_rows:
-                id = data_id_row["dataset_id"]
-                dataset_type = dataset_type_map[id]
-                run_name = data_id_row[run_name_column.key]
-                data_id = DataCoordinate.from_required_values(
-                    dimension_group,
-                    tuple(data_id_row[dimension] for dimension in dimension_group.required),
-                )
-                ref = DatasetRef(
-                    datasetType=dataset_type,
-                    dataId=data_id,
-                    id=id,
-                    run=run_name,
-                )
-                output_refs.append(ref)
+            for batch in chunk_iterable(datasets, 50000):
+                tags_sql = tags_table.select().where(tags_table.columns["dataset_id"].in_(batch))
+                # Join in the collection table to fetch the run name.
+                collection_column = tags_table.columns[self._collections.getCollectionForeignKeyName()]
+                joined_collections = self._collections.join_collections_sql(collection_column, tags_sql)
+                tags_sql = joined_collections.joined_sql
+                run_name_column = joined_collections.name_column
+                tags_sql = tags_sql.add_columns(run_name_column)
+                # Tags table includes run collections and tagged
+                # collections.
+                # In theory the data ID for a given dataset should be the
+                # same in both, but nothing actually guarantees this.
+                # So skip any tagged collections, using the run collection
+                # as the definitive definition.
+                tags_sql = tags_sql.where(joined_collections.type_column == int(CollectionType.RUN))
+
+                with self._db.query(tags_sql) as sql_result:
+                    data_id_rows = sql_result.mappings().all()
+
+                assert run_name_column.key is not None
+                for data_id_row in data_id_rows:
+                    id = data_id_row["dataset_id"]
+                    dataset_type = dataset_type_map[id]
+                    run_name = data_id_row[run_name_column.key]
+                    data_id = DataCoordinate.from_required_values(
+                        dimension_group,
+                        tuple(data_id_row[dimension] for dimension in dimension_group.required),
+                    )
+                    ref = DatasetRef(
+                        datasetType=dataset_type,
+                        dataId=data_id,
+                        id=id,
+                        run=run_name,
+                    )
+                    output_refs.append(ref)
 
         return output_refs
 
@@ -818,8 +822,10 @@ class ByDimensionsDatasetRecordStorageManagerUUID(DatasetRecordStorageManager):
 
         Parameters
         ----------
-        storage : `_DatasetREcordStorage`
-            Struct that holds the tables and ID for a dataset type.
+        dimensions : `DimensionGroup`
+            Dimensions to validate.
+        tags : `sqlalchemy.schema.Table`
+            ???
         tmp_tags : `sqlalchemy.schema.Table`
             Temporary table with new datasets and the same schema as tags
             table.

lsst/daf/butler/registry/datasets/byDimensions/summaries.py

@@ -304,13 +304,14 @@ class CollectionSummaryManager:
         dataset_type_names : `~collections.abc.Iterable` [`str`]
             Names of dataset types to include into returned summaries. If
             `None` then all dataset types will be included.
-        dataset_type_factory : `Callable`
+        dataset_type_factory : `~collections.abc.Callable`
             Method that takes a table row and make `DatasetType` instance out
             of it.
 
         Returns
         -------
-        summaries : `~collections.abc.Mapping` [`Any`, `CollectionSummary`]
+        summaries : `~collections.abc.Mapping` [`typing.Any`, \
+              `CollectionSummary`]
             Collection summaries indexed by collection record key. This mapping
             will also contain all nested non-chained collections of the chained
             collections.

lsst/daf/butler/registry/expand_data_ids.py

@@ -0,0 +1,93 @@
+# 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/>.
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Iterable
+
+from ..dimensions import (
+    DataCoordinate,
+    DimensionDataAttacher,
+    DimensionGroup,
+    DimensionUniverse,
+)
+from ..dimensions.record_cache import DimensionRecordCache
+from ..queries import QueryFactoryFunction
+
+
+def expand_data_ids(
+    data_ids: Iterable[DataCoordinate],
+    universe: DimensionUniverse,
+    query_func: QueryFactoryFunction,
+    cache: DimensionRecordCache | None,
+) -> list[DataCoordinate]:
+    """Expand the given data IDs to look up implied dimension values and attach
+    dimension records.
+
+    Parameters
+    ----------
+    data_ids : `~collections.abc.Iterable` [ `DataCoordinate` ]
+        Data coordinates to be expanded.
+    universe : `DimensionUniverse`
+        Dimension universe associated with the given ``data_ids`` values.
+    query_func : QueryFactoryFunction
+        Function used to set up a Butler query context for looking up required
+        information from the database.
+    cache : `DimensionRecordCache` | None
+        Cache containing already-known dimension records.  May be `None` if a
+        cache is not available.
+
+    Returns
+    -------
+    expanded : `list` [ `DataCoordinate` ]
+        List of `DataCoordinate` instances in the same order as the input
+        values.  It is guaranteed that each `DataCoordinate` has
+        ``hasRecords()=True`` and ``hasFull()=True``.
+    """
+    output = list(data_ids)
+
+    grouped_by_dimensions: defaultdict[DimensionGroup, list[int]] = defaultdict(list)
+    for i, data_id in enumerate(data_ids):
+        if not data_id.hasRecords():
+            grouped_by_dimensions[data_id.dimensions].append(i)
+
+    if not grouped_by_dimensions:
+        # All given DataCoordinate values are already expanded.
+        return output
+
+    attacher = DimensionDataAttacher(
+        cache=cache,
+        dimensions=DimensionGroup.union(*grouped_by_dimensions.keys(), universe=universe),
+    )
+    for dimensions, indexes in grouped_by_dimensions.items():
+        with query_func() as query:
+            expanded = attacher.attach(dimensions, (output[index] for index in indexes), query)
+            for index, data_id in zip(indexes, expanded):
+                output[index] = data_id
+
+    return output

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

@@ -1562,7 +1562,12 @@ class Database(ABC):
                 return None
             else:
                 sql = table.insert()
-                return [connection.execute(sql, row).inserted_primary_key[0] for row in rows]
+                ids = []
+                for row in rows:
+                    key = connection.execute(sql, row).inserted_primary_key
+                    assert key is not None
+                    ids.append(key[0])
+                return ids
 
     @abstractmethod
     def replace(self, table: sqlalchemy.schema.Table, *rows: dict) -> None:

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

@@ -378,7 +378,8 @@ class DatasetRecordStorageManager(VersionedExtension):
 
         Returns
         -------
-        summaries : `~collections.abc.Mapping` [`Any`, `CollectionSummary`]
+        summaries : `~collections.abc.Mapping` [`typing.Any`, \
+              `CollectionSummary`]
             Collection summaries indexed by collection record key. This mapping
             will also contain all nested non-chained collections of the chained
             collections.

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

@@ -115,7 +115,7 @@ class ObsCoreTableManager(VersionedExtension):
             implemented with this manager.
         universe : `DimensionUniverse`
             All dimensions known to the registry.
-        config : `dict` [ `str`, `Any` ]
+        config : `dict` [ `str`, `typing.Any` ]
             Configuration of the obscore manager.
         datasets : `type`
             Type of dataset manager.

lsst/daf/butler/registry/obscore/_records.py

@@ -256,7 +256,7 @@ class RecordFactory:
 
         Returns
         -------
-        record : `dict` [ `str`, `Any` ] or `None`
+        record : `dict` [ `str`, `typing.Any` ] or `None`
             ObsCore record represented as a dictionary. `None` is returned if
             dataset does not need to be stored in the obscore table, e.g. when
             dataset type is not in obscore configuration.

lsst/daf/butler/registry/obscore/_spatial.py

@@ -72,7 +72,7 @@ class SpatialObsCorePlugin(ABC):
         name : `str`
             Arbitrary name given to this plugin (usually key in
             configuration).
-        config : `dict` [ `str`, `Any` ]
+        config : `dict` [ `str`, `typing.Any` ]
             Plugin configuration dictionary.
         db : `Database`, optional
             Interface to the underlying database engine and namespace. In some
@@ -120,7 +120,7 @@ class SpatialObsCorePlugin(ABC):
 
         Returns
         -------
-        record : `dict` [ `str`, `Any` ] or `None`
+        record : `dict` [ `str`, `typing.Any` ] or `None`
             Data to store in the main obscore table with column values
             corresponding to a region or `None` if there is nothing to store.