lsst-daf-butler 29.2025.1500__tar.gz → 29.2025.1700__tar.gz

{lsst_daf_butler-29.2025.1500/python/lsst_daf_butler.egg-info → lsst_daf_butler-29.2025.1700}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-daf-butler
-Version: 29.2025.1500
+Version: 29.2025.1700
 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.1500 → lsst_daf_butler-29.2025.1700}/python/lsst/daf/butler/_config.py

@@ -1254,7 +1254,7 @@ class ConfigSubset(Config):
 
         Global defaults, at lowest priority, are found in the ``config``
         directory of the butler source tree. Additional defaults can be
-        defined using the environment variable ``$DAF_BUTLER_CONFIG_PATHS``
+        defined using the environment variable ``$DAF_BUTLER_CONFIG_PATH``
         which is a PATH-like variable where paths at the front of the list
         have priority over those later.
 

{lsst_daf_butler-29.2025.1500 → lsst_daf_butler-29.2025.1700}/python/lsst/daf/butler/configs/datastores/formatters.yaml

@@ -86,7 +86,7 @@ TaskMetadata: lsst.daf.butler.formatters.json.JsonFormatter
 SpectractorSpectrum: lsst.atmospec.formatters.SpectractorSpectrumFormatter
 SpectractorImage: lsst.atmospec.formatters.SpectractorImageFormatter
 SpectractorFitParameters: lsst.atmospec.formatters.SpectractorFitParametersFormatter
-ScarletModelData: lsst.daf.butler.formatters.json.JsonFormatter
+ScarletModelData: lsst.meas.extensions.scarlet.io.ScarletModelFormatter
 MetricMeasurementBundle: lsst.daf.butler.formatters.json.JsonFormatter
 MultipleCellCoadd: lsst.cell_coadds.CellCoaddFitsFormatter
 NNModelPackagePayload: lsst.meas.transiNet.modelPackages.NNModelPackageFormatter

{lsst_daf_butler-29.2025.1500 → lsst_daf_butler-29.2025.1700}/python/lsst/daf/butler/configs/storageClasses.yaml

@@ -409,6 +409,9 @@ storageClasses:
     pytype: spectractor.fit.fitter.FitParameters
   ScarletModelData:
     pytype: lsst.scarlet.lite.io.ScarletModelData
+    parameters:
+      - blend_id
+    delegate: lsst.meas.extensions.scarlet.io.ScarletModelDelegate
   MetricMeasurementBundle:
     pytype: lsst.analysis.tools.interfaces.MetricMeasurementBundle
   MultipleCellCoadd:

{lsst_daf_butler-29.2025.1500 → lsst_daf_butler-29.2025.1700}/python/lsst/daf/butler/dimensions/_universe.py

@@ -31,6 +31,7 @@ __all__ = ["DimensionUniverse"]
 
 import logging
 import pickle
+import warnings
 from collections import defaultdict
 from collections.abc import Iterable, Mapping, Sequence
 from typing import TYPE_CHECKING, Any, ClassVar, TypeVar, overload
@@ -117,6 +118,13 @@ class DimensionUniverse:  # numpydoc ignore=PR02
             else:
                 version = builder.version
 
+        if use_cache is not True:
+            warnings.warn(
+                "use_cache parameter is no longer supported and is ignored. Will be removed after v30.",
+                category=FutureWarning,
+                stacklevel=2,
+            )
+
         # Then a namespace.
         if namespace is None:
             if builder is None:
@@ -129,10 +137,9 @@ class DimensionUniverse:  # numpydoc ignore=PR02
             namespace = _DEFAULT_NAMESPACE
 
         # See if an equivalent instance already exists.
-        if use_cache:
-            existing_instance = cls._instances.get((version, namespace))
-            if existing_instance is not None:
-                return existing_instance
+        existing_instance = cls._instances.get((version, namespace))
+        if existing_instance is not None:
+            return existing_instance
 
         # Ensure we have a builder, building one from config if necessary.
         if builder is None:
@@ -183,10 +190,7 @@ class DimensionUniverse:  # numpydoc ignore=PR02
             if element.populated_by is not None:
                 self._populates[element.populated_by.name].add(element)
 
-        if use_cache:
-            return cls._instances.set_or_get((self._version, self._namespace), self)
-        else:
-            return self
+        return cls._instances.set_or_get((self._version, self._namespace), self)
 
     @property
     def version(self) -> int:

{lsst_daf_butler-29.2025.1500 → lsst_daf_butler-29.2025.1700}/python/lsst/daf/butler/direct_butler/_direct_butler.py

@@ -1587,30 +1587,24 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
     def _ingest_file_datasets(
         self,
         datasets: Sequence[FileDataset],
+        *,
+        dry_run: bool = False,
     ) -> None:
-        # Docstring inherited.
         if not datasets:
             return
 
         progress = Progress("lsst.daf.butler.Butler.ingest", level=logging.DEBUG)
 
-        # We need to reorganize all the inputs so that they are grouped
-        # by dataset type and run. Multiple refs in a single FileDataset
-        # are required to share the run and dataset type.
-        groupedData: MutableMapping[tuple[DatasetType, str], list[FileDataset]] = defaultdict(list)
-
         # Track DataIDs that are being ingested so we can spot issues early
         # with duplication. Retain previous FileDataset so we can report it.
         groupedDataIds: MutableMapping[tuple[DatasetType, str], dict[DataCoordinate, FileDataset]] = (
             defaultdict(dict)
         )
 
-        # And the nested loop that populates it:
-        for dataset in progress.wrap(datasets, desc="Grouping by dataset type"):
-            # Somewhere to store pre-existing refs if we have an
-            # execution butler.
-            existingRefs: list[DatasetRef] = []
+        # All the refs we need to import.
+        refs: list[DatasetRef] = []
 
+        for dataset in progress.wrap(datasets, desc="Validating dataIDs"):
             for ref in dataset.refs:
                 group_key = (ref.datasetType, ref.run)
 
@@ -1623,54 +1617,29 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
                     )
 
                 groupedDataIds[group_key][ref.dataId] = dataset
+            refs.extend(dataset.refs)
 
-            if existingRefs:
-                if len(dataset.refs) != len(existingRefs):
-                    # Keeping track of partially pre-existing datasets is hard
-                    # and should generally never happen. For now don't allow
-                    # it.
-                    raise ConflictingDefinitionError(
-                        f"For dataset {dataset.path} some dataIds already exist"
-                        " in registry but others do not. This is not supported."
-                    )
-
-                # Store expanded form in the original FileDataset.
-                dataset.refs = existingRefs
-            else:
-                groupedData[group_key].append(dataset)
-
-        # Now we can bulk-insert into Registry for each DatasetType.
-        for (datasetType, this_run), grouped_datasets in progress.iter_item_chunks(
-            groupedData.items(), desc="Bulk-inserting datasets by type"
-        ):
-            refs_to_import = []
-            for dataset in grouped_datasets:
-                refs_to_import.extend(dataset.refs)
-
-            n_refs = len(refs_to_import)
-            _LOG.verbose(
-                "Importing %d ref%s of dataset type %r into run %r",
-                n_refs,
-                "" if n_refs == 1 else "s",
-                datasetType.name,
-                this_run,
-            )
+        # Bulk insert.
+        import_info = self._prepare_for_import_refs(
+            self,
+            refs,
+            skip_missing=False,
+            register_dataset_types=True,
+            dry_run=dry_run,
+            transfer_dimensions=False,
+        )
 
-            # Import the refs and expand the DataCoordinates since we can't
-            # guarantee that they are expanded and Datastore will need
-            # the records.
-            imported_refs = self._registry._importDatasets(refs_to_import, expand=True)
+        self._import_dimension_records(import_info.dimension_records, dry_run=dry_run)
+        imported_refs = self._import_grouped_refs(
+            import_info.grouped_refs, self, progress, dry_run=dry_run, expand_refs=True
+        )
 
-            # Since refs can come from an external butler, there is no
-            # guarantee that the DatasetType values match. Compare IDs.
-            assert {ref.id for ref in imported_refs} == {ref.id for ref in refs_to_import}
+        # The expanded refs need to be attached back to the original
+        # FileDatasets for datastore to use.
+        id_to_ref = {ref.id: ref for ref in imported_refs}
 
-            # Replace all the refs in the FileDataset with expanded versions.
-            # Pull them off in the order we put them on the list.
-            for dataset in grouped_datasets:
-                n_dataset_refs = len(dataset.refs)
-                dataset.refs = imported_refs[:n_dataset_refs]
-                del imported_refs[:n_dataset_refs]
+        for dataset in progress.wrap(datasets, desc="Re-attaching expanded refs"):
+            dataset.refs = [id_to_ref[ref.id] for ref in dataset.refs]
 
     @transactional
     def ingest(
@@ -1933,20 +1902,19 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
 
         return dimension_records
 
-    def transfer_from(
+    def _prepare_for_import_refs(
         self,
         source_butler: LimitedButler,
         source_refs: Iterable[DatasetRef],
-        transfer: str = "auto",
+        *,
         skip_missing: bool = True,
         register_dataset_types: bool = False,
         transfer_dimensions: bool = False,
         dry_run: bool = False,
-    ) -> collections.abc.Collection[DatasetRef]:
+    ) -> _ImportDatasetsInfo:
         # Docstring inherited.
         if not self.isWriteable():
             raise TypeError("Butler is read-only.")
-        progress = Progress("lsst.daf.butler.Butler.transfer_from", level=VERBOSE)
 
         # Will iterate through the refs multiple times so need to convert
         # to a list if this isn't a collection.
@@ -1954,7 +1922,7 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
             source_refs = list(source_refs)
 
         original_count = len(source_refs)
-        _LOG.info("Transferring %d datasets into %s", original_count, str(self))
+        _LOG.info("Importing %d datasets into %s", original_count, str(self))
 
         # In some situations the datastore artifact may be missing
         # and we do not want that registry entry to be imported.
@@ -1996,7 +1964,7 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
                 # might result in additional unwanted dataset types being
                 # registered.
                 try:
-                    if self._registry.registerDatasetType(datasetType):
+                    if not dry_run and self._registry.registerDatasetType(datasetType):
                         newly_registered_dataset_types.add(datasetType)
                 except ConflictingDefinitionError as e:
                     # Be safe and require that conversions be bidirectional
@@ -2076,86 +2044,132 @@ class DirectButler(Butler):  # numpydoc ignore=PR02
             dimension_records = self._extract_all_dimension_records_from_data_ids(
                 source_butler, dataIds, elements
             )
+        return _ImportDatasetsInfo(grouped_refs, dimension_records, artifact_existence)
 
+    def _import_dimension_records(
+        self,
+        dimension_records: dict[DimensionElement, dict[DataCoordinate, DimensionRecord]],
+        *,
+        dry_run: bool,
+    ) -> None:
+        """Import dimension records collected during import pre-process."""
+        if dimension_records and not dry_run:
+            _LOG.verbose("Ensuring that dimension records exist for transferred datasets.")
+            # Order matters.
+            for element in self.dimensions.sorted(dimension_records.keys()):
+                records = list(dimension_records[element].values())
+                # Assume that if the record is already present that we can
+                # use it without having to check that the record metadata
+                # is consistent.
+                self._registry.insertDimensionData(element, *records, skip_existing=True)
+
+    def _import_grouped_refs(
+        self,
+        grouped_refs: defaultdict[_RefGroup, list[DatasetRef]],
+        source_butler: LimitedButler,
+        progress: Progress,
+        *,
+        dry_run: bool = False,
+        expand_refs: bool = False,
+    ) -> list[DatasetRef]:
         handled_collections: set[str] = set()
-
-        # Do all the importing in a single transaction.
-        with self.transaction():
-            if dimension_records and not dry_run:
-                _LOG.verbose("Ensuring that dimension records exist for transferred datasets.")
-                # Order matters.
-                for element in self.dimensions.sorted(dimension_records.keys()):
-                    records = [r for r in dimension_records[element].values()]
-                    # Assume that if the record is already present that we can
-                    # use it without having to check that the record metadata
-                    # is consistent.
-                    self._registry.insertDimensionData(element, *records, skip_existing=True)
-
-            n_imported = 0
-
-            # Sort by run collection name to ensure Postgres takes locks in the
-            # same order between different processes, to mitigate an issue
-            # where Postgres can deadlock due to the unique index on collection
-            # name. (See DM-47543).
-            groups = sorted(grouped_refs.items(), key=lambda item: item[0].run)
-            for (dimension_group, run), refs_to_import in progress.iter_item_chunks(
-                groups, desc="Importing to registry by run and dataset type"
-            ):
-                if run not in handled_collections:
-                    # May need to create output collection. If source butler
-                    # has a registry, ask for documentation string.
-                    run_doc = None
-                    if registry := getattr(source_butler, "registry", None):
-                        run_doc = registry.getCollectionDocumentation(run)
-                    if not dry_run:
-                        registered = self.collections.register(run, doc=run_doc)
-                    else:
-                        registered = True
-                    handled_collections.add(run)
-                    if registered:
-                        _LOG.verbose("Creating output run %s", run)
-
-                n_refs = len(refs_to_import)
-                _LOG.verbose(
-                    "Importing %d ref%s with dimensions %s into run %s",
-                    n_refs,
-                    "" if n_refs == 1 else "s",
-                    dimension_group.names,
-                    run,
-                )
-
-                # Assume we are using UUIDs and the source refs will match
-                # those imported.
+        n_to_import = 0
+        all_imported_refs: list[DatasetRef] = []
+        # Sort by run collection name to ensure Postgres takes locks in the
+        # same order between different processes, to mitigate an issue
+        # where Postgres can deadlock due to the unique index on collection
+        # name. (See DM-47543).
+        groups = sorted(grouped_refs.items(), key=lambda item: item[0].run)
+        for (dimension_group, run), refs_to_import in progress.iter_item_chunks(
+            groups, desc="Importing to registry by run and dataset type"
+        ):
+            if run not in handled_collections:
+                # May need to create output collection. If source butler
+                # has a registry, ask for documentation string.
+                run_doc = None
+                if registry := getattr(source_butler, "registry", None):
+                    run_doc = registry.getCollectionDocumentation(run)
                 if not dry_run:
-                    imported_refs = self._registry._importDatasets(refs_to_import)
+                    registered = self.collections.register(run, doc=run_doc)
                 else:
-                    imported_refs = refs_to_import
+                    registered = True
+                handled_collections.add(run)
+                if registered:
+                    _LOG.verbose("Creating output run %s", run)
+
+            n_refs = len(refs_to_import)
+            n_to_import += n_refs
+            _LOG.verbose(
+                "Importing %d ref%s with dimensions %s into run %s",
+                n_refs,
+                "" if n_refs == 1 else "s",
+                dimension_group.names,
+                run,
+            )
+
+            # Assume we are using UUIDs and the source refs will match
+            # those imported.
+            if not dry_run:
+                imported_refs = self._registry._importDatasets(refs_to_import, expand=expand_refs)
+            else:
+                imported_refs = refs_to_import
+
+            all_imported_refs.extend(imported_refs)
+
+        assert n_to_import == len(all_imported_refs)
+        _LOG.verbose("Imported %d datasets into destination butler", n_to_import)
+        return all_imported_refs
+
+    def transfer_from(
+        self,
+        source_butler: LimitedButler,
+        source_refs: Iterable[DatasetRef],
+        transfer: str = "auto",
+        skip_missing: bool = True,
+        register_dataset_types: bool = False,
+        transfer_dimensions: bool = False,
+        dry_run: bool = False,
+    ) -> collections.abc.Collection[DatasetRef]:
+        # Docstring inherited.
+        if not self.isWriteable():
+            raise TypeError("Butler is read-only.")
 
-                n_imported += len(imported_refs)
+        progress = Progress("lsst.daf.butler.Butler.transfer_from", level=VERBOSE)
 
-            assert len(source_refs) == n_imported
-            _LOG.verbose("Imported %d datasets into destination butler", n_imported)
+        import_info = self._prepare_for_import_refs(
+            source_butler,
+            source_refs,
+            skip_missing=skip_missing,
+            register_dataset_types=register_dataset_types,
+            dry_run=dry_run,
+            transfer_dimensions=transfer_dimensions,
+        )
+
+        # Do all the importing in a single transaction.
+        with self.transaction():
+            self._import_dimension_records(import_info.dimension_records, dry_run=dry_run)
+            imported_refs = self._import_grouped_refs(
+                import_info.grouped_refs, source_butler, progress, dry_run=dry_run
+            )
 
             # Ask the datastore to transfer. The datastore has to check that
             # the source datastore is compatible with the target datastore.
             accepted, rejected = self._datastore.transfer_from(
                 source_butler._datastore,
-                source_refs,
+                imported_refs,
                 transfer=transfer,
-                artifact_existence=artifact_existence,
+                artifact_existence=import_info.artifact_existence,
                 dry_run=dry_run,
             )
             if rejected:
                 # For now, accept the registry entries but not the files.
                 _LOG.warning(
-                    "%d datasets were rejected and %d accepted for dataset type %s in run %r.",
+                    "%d datasets were rejected and %d accepted for transfer.",
                     len(rejected),
                     len(accepted),
-                    datasetType,
-                    run,
                 )
 
-        return source_refs
+        return imported_refs
 
     def validateConfiguration(
         self,
@@ -2382,3 +2396,11 @@ class _RefGroup(NamedTuple):
 
     dimensions: DimensionGroup
     run: str
+
+
+class _ImportDatasetsInfo(NamedTuple):
+    """Information extracted from datasets to be imported."""
+
+    grouped_refs: defaultdict[_RefGroup, list[DatasetRef]]
+    dimension_records: dict[DimensionElement, dict[DataCoordinate, DimensionRecord]]
+    artifact_existence: dict[ResourcePath, bool]

{lsst_daf_butler-29.2025.1500 → lsst_daf_butler-29.2025.1700}/python/lsst/daf/butler/direct_query_driver/_driver.py

@@ -56,6 +56,7 @@ from ..queries.driver import (
     QueryDriver,
     ResultPage,
 )
+from ..queries.predicate_constraints_summary import PredicateConstraintsSummary
 from ..queries.result_specs import (
     DataCoordinateResultSpec,
     DatasetRefResultSpec,
@@ -68,7 +69,6 @@ from ..registry.interfaces import ChainedCollectionRecord, CollectionRecord
 from ..registry.managers import RegistryManagerInstances
 from ..registry.wildcards import CollectionWildcard
 from ._postprocessing import Postprocessing
-from ._predicate_constraints_summary import PredicateConstraintsSummary
 from ._query_analysis import (
     QueryCollectionAnalysis,
     QueryFindFirstAnalysis,

{lsst_daf_butler-29.2025.1500 → lsst_daf_butler-29.2025.1700}/python/lsst/daf/butler/queries/_query.py

@@ -33,6 +33,8 @@ from collections.abc import Iterable, Mapping, Set
 from types import EllipsisType
 from typing import Any, final
 
+import astropy.table
+
 from lsst.utils.iteration import ensure_iterable
 
 from .._dataset_type import DatasetType
@@ -49,6 +51,7 @@ from ._identifiers import IdentifierContext, interpret_identifier
 from .convert_args import convert_where_args
 from .driver import QueryDriver
 from .expression_factory import ExpressionFactory
+from .predicate_constraints_summary import PredicateConstraintsSummary
 from .result_specs import (
     DataCoordinateResultSpec,
     DatasetRefResultSpec,
@@ -586,7 +589,7 @@ class Query(QueryBase):
         return query
 
     def join_data_coordinates(self, iterable: Iterable[DataCoordinate]) -> Query:
-        """Return a new query that joins in an explicit table of data IDs.
+        """Return a new query that joins in an explicit iterable of data IDs.
 
         Parameters
         ----------
@@ -618,6 +621,50 @@ class Query(QueryBase):
             driver=self._driver,
         )
 
+    def join_data_coordinate_table(self, table: astropy.table.Table) -> Query:
+        """Return a new query that joins in an explicit table of data IDs.
+
+        Parameters
+        ----------
+        table : `astropy.table.Table`
+            A table of data IDs to join.  Columns must be dimension names, and
+            columns for dimensions whose values that are implied by others are
+            ignored.  If there is no column for a required dimension is missing
+            but is fully constrained to a literal by a previous `where` call, a
+            constant-valued column will be added.
+
+        Returns
+        -------
+        query : `Query`
+            A new query object with the data IDs joined in.
+        """
+        if not len(table):
+            raise InvalidQueryError("Cannot upload an empty data coordinate set.")
+        column_names = set(table.colnames)
+        dimensions = self._driver.universe.conform(column_names)
+        # To avoid numpy scalar types that will upset SQLAlchemy, we turn the
+        # columns we care about into lists of regular Python scalars.  We do
+        # this in dimensions.required order so we can zip the values of this
+        # dict later to make data ID 'required_values' tuples.
+        column_lists = {d: table[d].data.tolist() if d in column_names else None for d in dimensions.required}
+        if not column_names.issuperset(dimensions.required):
+            # If columns are missing, see if they're fixed by a previous
+            # `where` call or equivalent.
+            predicate_summary = PredicateConstraintsSummary(self._tree.predicate)
+            missing = dimensions.required - column_names
+            provided_by_predicate = predicate_summary.constraint_data_id.keys() & missing
+            missing -= provided_by_predicate
+            if missing:
+                raise InvalidQueryError(f"Data coordinate table is missing required dimension(s) {missing}.")
+            if provided_by_predicate:
+                for k in provided_by_predicate:
+                    column_lists[k] = [predicate_summary.constraint_data_id[k]] * len(table)
+        key = self._driver.upload_data_coordinates(dimensions, zip(*column_lists.values(), strict=True))
+        return Query(
+            tree=self._tree.join_data_coordinate_upload(dimensions=dimensions, key=key),
+            driver=self._driver,
+        )
+
     def join_dimensions(self, dimensions: Iterable[str] | DimensionGroup) -> Query:
         """Return a new query that joins the logical tables for additional
         dimensions.

lsst_daf_butler-29.2025.1500/python/lsst/daf/butler/direct_query_driver/_predicate_constraints_summary.py → lsst_daf_butler-29.2025.1700/python/lsst/daf/butler/queries/predicate_constraints_summary.py

@@ -31,8 +31,8 @@ from typing import Any
 
 from .._exceptions import InvalidQueryError
 from ..dimensions import DataCoordinate, DataIdValue, DimensionGroup, DimensionUniverse
-from ..queries import tree as qt
-from ..queries.visitors import ColumnExpressionVisitor, PredicateVisitFlags, SimplePredicateVisitor
+from . import tree as qt
+from .visitors import ColumnExpressionVisitor, PredicateVisitFlags, SimplePredicateVisitor
 
 
 class PredicateConstraintsSummary:

{lsst_daf_butler-29.2025.1500 → lsst_daf_butler-29.2025.1700}/python/lsst/daf/butler/remote_butler/_remote_butler.py

@@ -187,14 +187,7 @@ class RemoteButler(Butler):  # numpydoc ignore=PR02
         model = parse_model(response, GetUniverseResponseModel)
 
         config = DimensionConfig.from_simple(model.universe)
-        universe = DimensionUniverse(
-            config,
-            # The process-global cache internal to DimensionUniverse can mask
-            # problems in unit tests, since client and server live in the same
-            # process for these tests.  We are doing our own caching, so we
-            # don't benefit from it.  So just disable it.
-            use_cache=False,
-        )
+        universe = DimensionUniverse(config)
         with self._cache.access() as cache:
             if cache.dimensions is None:
                 cache.dimensions = universe

lsst_daf_butler-29.2025.1700/python/lsst/daf/butler/version.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "29.2025.1700"

{lsst_daf_butler-29.2025.1500 → lsst_daf_butler-29.2025.1700/python/lsst_daf_butler.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-daf-butler
-Version: 29.2025.1500
+Version: 29.2025.1700
 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.1500 → lsst_daf_butler-29.2025.1700}/python/lsst_daf_butler.egg-info/SOURCES.txt

@@ -147,7 +147,6 @@ python/lsst/daf/butler/direct_butler/_direct_butler_collections.py
 python/lsst/daf/butler/direct_query_driver/__init__.py
 python/lsst/daf/butler/direct_query_driver/_driver.py
 python/lsst/daf/butler/direct_query_driver/_postprocessing.py
-python/lsst/daf/butler/direct_query_driver/_predicate_constraints_summary.py
 python/lsst/daf/butler/direct_query_driver/_query_analysis.py
 python/lsst/daf/butler/direct_query_driver/_query_builder.py
 python/lsst/daf/butler/direct_query_driver/_result_page_converter.py
@@ -177,6 +176,7 @@ python/lsst/daf/butler/queries/convert_args.py
 python/lsst/daf/butler/queries/driver.py
 python/lsst/daf/butler/queries/expression_factory.py
 python/lsst/daf/butler/queries/overlaps.py
+python/lsst/daf/butler/queries/predicate_constraints_summary.py
 python/lsst/daf/butler/queries/result_specs.py
 python/lsst/daf/butler/queries/visitors.py
 python/lsst/daf/butler/queries/tree/__init__.py

{lsst_daf_butler-29.2025.1500 → lsst_daf_butler-29.2025.1700}/tests/test_config.py

@@ -42,11 +42,11 @@ TESTDIR = os.path.abspath(os.path.dirname(__file__))
 def modified_environment(**environ):
     """Temporarily set environment variables.
 
-    >>> with modified_environment(DAF_BUTLER_CONFIG_PATHS="/somewhere"):
-    ...     os.environ["DAF_BUTLER_CONFIG_PATHS"] == "/somewhere"
+    >>> with modified_environment(DAF_BUTLER_CONFIG_PATH="/somewhere"):
+    ...     os.environ["DAF_BUTLER_CONFIG_PATH"] == "/somewhere"
     True
 
-    >>> "DAF_BUTLER_CONFIG_PATHS" != "/somewhere"
+    >>> "DAF_BUTLER_CONFIG_PATH" != "/somewhere"
     True
 
     Parameters