lsst-pipe-base 29.2025.4700__tar.gz → 29.2025.4900__tar.gz

{lsst_pipe_base-29.2025.4700/python/lsst_pipe_base.egg-info → lsst_pipe_base-29.2025.4900}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-pipe-base
-Version: 29.2025.4700
+Version: 29.2025.4900
 Summary: Pipeline infrastructure for the Rubin Science Pipelines.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License-Expression: BSD-3-Clause OR GPL-3.0-or-later

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/caching_limited_butler.py

@@ -90,6 +90,9 @@ class CachingLimitedButler(LimitedButler):
         self._cache: dict[str, tuple[DatasetId, InMemoryDatasetHandle]] = {}
         self._no_copy_on_cache = no_copy_on_cache
 
+    def close(self) -> None:
+        self._wrapped.close()
+
     @property
     def _metrics(self) -> ButlerMetrics:
         # Need to always forward from the wrapped metrics object.

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/connections.py

@@ -506,8 +506,19 @@ class DeferredDatasetRef:
     datasetRef: DatasetRef
 
     def __getattr__(self, name: str) -> Any:
+        # make sure reduce is called on DeferredDatasetRef and not on
+        # the DatasetRef
+        if name in ("__reduce__", "datasetRef", "__deepcopy__"):
+            object.__getattribute__(self, name)
         return getattr(self.datasetRef, name)
 
+    def __deepcopy__(self, memo: dict) -> DeferredDatasetRef:
+        # dataset refs should be immutable deferred version should be too
+        return self
+
+    def __reduce__(self) -> tuple:
+        return (self.__class__, (self.datasetRef,))
+
 
 class PipelineTaskConnections(metaclass=PipelineTaskConnectionsMetaclass):
     """PipelineTaskConnections is a class used to declare desired IO when a

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/quantum_graph/aggregator/_ingester.py

@@ -34,6 +34,8 @@ import logging
 import time
 import uuid
 from collections import defaultdict
+from contextlib import AbstractContextManager
+from typing import Any, Literal, Self
 
 from lsst.daf.butler import Butler, CollectionType, DatasetRef, DimensionGroup
 from lsst.daf.butler.datastore.record_data import DatastoreRecordData
@@ -46,7 +48,7 @@ from ._communicators import IngesterCommunicator
 
 
 @dataclasses.dataclass
-class Ingester:
+class Ingester(AbstractContextManager):
     """A helper class for the provenance aggregator that handles ingestion into
     the central butler repository.
     """
@@ -107,6 +109,16 @@ class Ingester:
         self.comms.log.verbose("Initializing butler.")
         self.butler = Butler.from_config(self.butler_path, writeable=not self.comms.config.dry_run)
 
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> Literal[False]:
+        try:
+            self.butler.close()
+        except Exception:
+            self.comms.log.exception("An exception occurred during Ingester exit")
+        return False
+
     @property
     def n_datasets_pending(self) -> int:
         """The number of butler datasets currently pending."""
@@ -130,8 +142,7 @@ class Ingester:
         This method is designed to run as the ``target`` in
         `WorkerContext.make_worker`.
         """
-        with comms:
-            ingester = Ingester(predicted_path, butler_path, comms)
+        with comms, Ingester(predicted_path, butler_path, comms) as ingester:
             ingester.loop()
 
     def loop(self) -> None:

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/quantum_graph/aggregator/_scanner.py

@@ -32,6 +32,8 @@ __all__ = ("Scanner",)
 import dataclasses
 import itertools
 import uuid
+from contextlib import AbstractContextManager
+from typing import Any, Literal, Self
 
 import zstandard
 
@@ -56,7 +58,7 @@ from ._structs import IngestRequest, InProgressScan, ScanReport, ScanStatus, Wri
 
 
 @dataclasses.dataclass
-class Scanner:
+class Scanner(AbstractContextManager):
     """A helper class for the provenance aggregator that reads metadata and log
     files and scans for which outputs exist.
     """
@@ -101,6 +103,16 @@ class Scanner:
         self.qbb = self.make_qbb(self.butler_path, self.reader.pipeline_graph)
         self.init_quanta = {q.quantum_id: q for q in self.reader.components.init_quanta.root}
 
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> Literal[False]:
+        try:
+            self.qbb.close()
+        except Exception:
+            self.comms.log.exception("An exception occurred during Ingester exit")
+        return False
+
     @staticmethod
     def make_qbb(butler_config: str, pipeline_graph: PipelineGraph) -> QuantumBackedButler:
         """Make quantum-backed butler that can operate on the outputs of the
@@ -155,8 +167,7 @@ class Scanner:
         This method is designed to run as the ``target`` in
         `WorkerContext.make_worker`.
         """
-        with comms:
-            scanner = Scanner(predicted_path, butler_path, comms)
+        with comms, Scanner(predicted_path, butler_path, comms) as scanner:
             scanner.loop()
 
     def loop(self) -> None:

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/script/register_instrument.py

@@ -53,7 +53,7 @@ def register_instrument(repo: str, instrument: list[str], update: bool = False)
         Raised iff the instrument is not a subclass of
         `lsst.pipe.base.Instrument`.
     """
-    butler = Butler.from_config(repo, writeable=True)
-    for string in instrument:
-        instrument_instance = Instrument.from_string(string, butler.registry)
-        instrument_instance.register(butler.registry, update=update)
+    with Butler.from_config(repo, writeable=True) as butler:
+        for string in instrument:
+            instrument_instance = Instrument.from_string(string, butler.registry)
+            instrument_instance.register(butler.registry, update=update)

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/script/retrieve_artifacts_for_quanta.py

@@ -93,16 +93,15 @@ def retrieve_artifacts_for_quanta(
     dataset_types = {dstype.name: dstype for dstype in qgraph.registryDatasetTypes()}
 
     # Make QBB, its config is the same as output Butler.
-    qbb = QuantumBackedButler.from_predicted(
+    with QuantumBackedButler.from_predicted(
         config=repo,
         predicted_inputs=[ref.id for ref in refs],
         predicted_outputs=[],
         dimensions=qgraph.universe,
         datastore_records=datastore_records,
         dataset_types=dataset_types,
-    )
-
-    paths = qbb.retrieve_artifacts(
-        refs, dest, transfer=transfer, overwrite=clobber, preserve_path=preserve_path
-    )
+    ) as qbb:
+        paths = qbb.retrieve_artifacts(
+            refs, dest, transfer=transfer, overwrite=clobber, preserve_path=preserve_path
+        )
     return paths

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/script/transfer_from_graph.py

@@ -85,52 +85,52 @@ def transfer_from_graph(
     # Get data repository dataset type definitions from the QuantumGraph.
     dataset_types = {dstype.name: dstype for dstype in qgraph.registryDatasetTypes()}
 
-    # Make QBB, its config is the same as output Butler.
-    qbb = QuantumBackedButler.from_predicted(
-        config=dest,
-        predicted_inputs=[ref.id for ref in output_refs],
-        predicted_outputs=[],
-        dimensions=qgraph.universe,
-        datastore_records={},
-        dataset_types=dataset_types,
-    )
-
     # Filter the refs based on requested dataset types.
     filtered_refs = filter_by_dataset_type_glob(output_refs, dataset_type)
     _LOG.verbose("After filtering by dataset_type, number of datasets to transfer: %d", len(filtered_refs))
 
-    dest_butler = Butler.from_config(dest, writeable=True)
-
-    # For faster restarts, filter out those the destination already knows.
-    filtered_refs = filter_by_existence(dest_butler, filtered_refs)
-
-    # Transfer in chunks
-    chunk_size = 50_000
-    n_chunks = math.ceil(len(filtered_refs) / chunk_size)
-    chunk_num = 0
-    count = 0
-    for chunk in chunk_iterable(filtered_refs, chunk_size=chunk_size):
-        chunk_num += 1
-        if n_chunks > 1:
-            _LOG.verbose("Transferring %d datasets in chunk %d/%d", len(chunk), chunk_num, n_chunks)
-        transferred = dest_butler.transfer_from(
-            qbb,
-            chunk,
-            transfer="auto",
-            register_dataset_types=register_dataset_types,
-            transfer_dimensions=transfer_dimensions,
-            dry_run=dry_run,
-        )
-        count += len(transferred)
-
-    # If asked to do so, update output chain definition.
-    if update_output_chain and (metadata := qgraph.metadata) is not None:
-        # These are defined in CmdLineFwk.
-        output_run = metadata.get("output_run")
-        output = metadata.get("output")
-        input = metadata.get("input")
-        if output_run is not None and output is not None:
-            _update_chain(dest_butler, output, output_run, input)
+    # Make QBB, its config is the same as output Butler.
+    with (
+        QuantumBackedButler.from_predicted(
+            config=dest,
+            predicted_inputs=[ref.id for ref in output_refs],
+            predicted_outputs=[],
+            dimensions=qgraph.universe,
+            datastore_records={},
+            dataset_types=dataset_types,
+        ) as qbb,
+        Butler.from_config(dest, writeable=True) as dest_butler,
+    ):
+        # For faster restarts, filter out those the destination already knows.
+        filtered_refs = filter_by_existence(dest_butler, filtered_refs)
+
+        # Transfer in chunks
+        chunk_size = 50_000
+        n_chunks = math.ceil(len(filtered_refs) / chunk_size)
+        chunk_num = 0
+        count = 0
+        for chunk in chunk_iterable(filtered_refs, chunk_size=chunk_size):
+            chunk_num += 1
+            if n_chunks > 1:
+                _LOG.verbose("Transferring %d datasets in chunk %d/%d", len(chunk), chunk_num, n_chunks)
+            transferred = dest_butler.transfer_from(
+                qbb,
+                chunk,
+                transfer="auto",
+                register_dataset_types=register_dataset_types,
+                transfer_dimensions=transfer_dimensions,
+                dry_run=dry_run,
+            )
+            count += len(transferred)
+
+        # If asked to do so, update output chain definition.
+        if update_output_chain and (metadata := qgraph.metadata) is not None:
+            # These are defined in CmdLineFwk.
+            output_run = metadata.get("output_run")
+            output = metadata.get("output")
+            input = metadata.get("input")
+            if output_run is not None and output is not None:
+                _update_chain(dest_butler, output, output_run, input)
 
     return count
 

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/script/zip_from_graph.py

@@ -72,19 +72,18 @@ def zip_from_graph(
     # Get data repository dataset type definitions from the QuantumGraph.
     dataset_types = {dstype.name: dstype for dstype in qgraph.registryDatasetTypes()}
 
+    # Filter the refs based on requested dataset types.
+    filtered_refs = filter_by_dataset_type_glob(output_refs, dataset_type)
+
     # Make QBB, its config is the same as output Butler.
-    qbb = QuantumBackedButler.from_predicted(
+    with QuantumBackedButler.from_predicted(
         config=repo,
         predicted_inputs=[ref.id for ref in output_refs],
         predicted_outputs=[],
         dimensions=qgraph.universe,
         datastore_records={},
         dataset_types=dataset_types,
-    )
-
-    # Filter the refs based on requested dataset types.
-    filtered_refs = filter_by_dataset_type_glob(output_refs, dataset_type)
-
-    _LOG.info("Retrieving artifacts for %d datasets and storing in Zip file.", len(filtered_refs))
-    zip = qbb.retrieve_artifacts_zip(filtered_refs, dest)
+    ) as qbb:
+        _LOG.info("Retrieving artifacts for %d datasets and storing in Zip file.", len(filtered_refs))
+        zip = qbb.retrieve_artifacts_zip(filtered_refs, dest)
     return zip

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/simple_pipeline_executor.py

@@ -40,6 +40,7 @@ from lsst.daf.butler import (
     DatasetRef,
     Quantum,
 )
+from lsst.daf.butler.registry import RegistryDefaults
 from lsst.pex.config import Config
 
 from ._instrument import Instrument
@@ -152,9 +153,9 @@ class SimplePipelineExecutor:
         collections = [output_run]
         collections.extend(inputs)
         butler.registry.setCollectionChain(output, collections)
-        # Remake butler to let it infer default data IDs from collections, now
-        # that those collections exist.
-        return Butler.from_config(butler=butler, collections=[output], run=output_run)
+        # Override the registry defaults. No need to clone.
+        butler.registry.defaults = RegistryDefaults(collections=[output], run=output_run)
+        return butler
 
     @classmethod
     def from_pipeline_filename(

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/single_quantum_executor.py

@@ -176,16 +176,34 @@ class SingleQuantumExecutor(QuantumExecutor):
 
         Internal implementation of `execute()`.
         """
-        startTime = time.time()
-
         # Make a limited butler instance if needed.
         limited_butler: LimitedButler
+        used_butler_factory = False
         if self._butler is not None:
             limited_butler = self._butler
         else:
             # We check this in constructor, but mypy needs this check here.
             assert self._limited_butler_factory is not None
             limited_butler = self._limited_butler_factory(quantum)
+            used_butler_factory = True
+
+        try:
+            return self._execute_with_limited_butler(
+                task_node, limited_butler, quantum=quantum, quantum_id=quantum_id
+            )
+        finally:
+            if used_butler_factory:
+                limited_butler.close()
+
+    def _execute_with_limited_butler(
+        self,
+        task_node: TaskNode,
+        limited_butler: LimitedButler,
+        /,
+        quantum: Quantum,
+        quantum_id: uuid.UUID | None = None,
+    ) -> Quantum:
+        startTime = time.time()
 
         if self._butler is not None:
             log_capture = LogCapture.from_full(self._butler)

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/tests/mocks/_repo.py

@@ -29,11 +29,12 @@ from __future__ import annotations
 
 __all__ = ("DirectButlerRepo", "InMemoryRepo", "MockRepo")
 
+import logging
 import tempfile
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 from collections.abc import Iterable, Iterator, Mapping
-from contextlib import contextmanager
-from typing import Any
+from contextlib import AbstractContextManager, contextmanager
+from typing import Any, Literal, Self
 
 from lsst.daf.butler import (
     Butler,
@@ -61,8 +62,10 @@ from ._pipeline_task import (
 )
 from ._storage_class import MockDataset, is_mock_name
 
+_LOG = logging.getLogger(__name__)
 
-class MockRepo(ABC):
+
+class MockRepo(AbstractContextManager):
     """A test helper that populates a butler repository for task execution.
 
     Parameters
@@ -100,6 +103,31 @@ class MockRepo(ABC):
         self.last_auto_dataset_type_index = 0
         self.last_auto_task_index = 0
 
+    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 occurred during MockRepo.close()")
+        return False
+
+    def close(self) -> None:
+        """Release all resources associated with this mock instance.  The
+        instance may no longer be used after this is called.
+
+        Notes
+        -----
+        Instead of calling ``close()`` directly, you can use the mock object
+        as a context manager.  For example::
+
+          with MockRepo(...) as butler:
+              butler.get(...)
+          # butler is closed after exiting the block.
+        """
+        self.butler.close()
+
     def add_task(
         self,
         label: str | None = None,
@@ -581,18 +609,18 @@ class DirectButlerRepo(MockRepo):
     ) -> Iterator[tuple[DirectButlerRepo, str]]:
         with tempfile.TemporaryDirectory(ignore_cleanup_errors=True) as root:
             config = Butler.makeRepo(root, **kwargs)
-            butler = Butler.from_config(config, writeable=True)
-            yield (
-                cls(
-                    butler,
-                    *args,
-                    input_run=input_run,
-                    input_chain=input_chain,
-                    use_import_collections_as_input=use_import_collections_as_input,
-                    data_root=data_root,
-                ),
-                root,
-            )
+            with Butler.from_config(config, writeable=True) as butler:
+                yield (
+                    cls(
+                        butler,
+                        *args,
+                        input_run=input_run,
+                        input_chain=input_chain,
+                        use_import_collections_as_input=use_import_collections_as_input,
+                        data_root=data_root,
+                    ),
+                    root,
+                )
 
     def _insert_datasets_impl(
         self, dataset_type: DatasetType, data_ids: list[DataCoordinate]

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst/pipe/base/tests/simpleQGraph.py

@@ -41,6 +41,7 @@ import lsst.daf.butler.tests as butlerTests
 import lsst.pex.config as pexConfig
 from lsst.daf.butler import Butler, Config, DataId, DatasetRef, DatasetType, Formatter, LimitedButler
 from lsst.daf.butler.logging import ButlerLogRecords
+from lsst.daf.butler.registry import RegistryDefaults
 from lsst.resources import ResourcePath
 from lsst.utils import doImportType
 from lsst.utils.introspection import get_full_type_name
@@ -295,8 +296,8 @@ def makeSimpleButler(
     if not inMemory:
         butler_config["registry", "db"] = f"sqlite:///{root_path.ospath}/gen3.sqlite"
         butler_config["datastore", "cls"] = "lsst.daf.butler.datastores.fileDatastore.FileDatastore"
-    repo = butlerTests.makeTestRepo(str(root_path), {}, config=butler_config)
-    butler = Butler.from_config(butler=repo, run=run)
+    butler = butlerTests.makeTestRepo(str(root_path), {}, config=butler_config)
+    butler.registry.defaults = RegistryDefaults(run=run)
     return butler
 
 
@@ -480,44 +481,51 @@ def makeSimpleQGraph(
         case _:
             raise TypeError(f"Unexpected pipeline object: {pipeline!r}.")
 
+    butler_created = False
     if butler is None:
         if root is None:
             raise ValueError("Must provide `root` when `butler` is None")
         if callPopulateButler is False:
             raise ValueError("populateButler can only be False when butler is supplied as an argument")
         butler = makeSimpleButler(root, run=run, inMemory=inMemory)
-
-    if callPopulateButler:
-        populateButler(pipeline_graph, butler, datasetTypes=datasetTypes, instrument=instrument)
-
-    # Make the graph
-    _LOG.debug(
-        "Instantiating QuantumGraphBuilder, "
-        "skip_existing_in=%s, input_collections=%r, output_run=%r, where=%r, bind=%s.",
-        skipExistingIn,
-        butler.collections.defaults,
-        run,
-        userQuery,
-        bind,
-    )
-    if not run:
-        assert butler.run is not None, "Butler must have run defined"
-        run = butler.run
-    builder = AllDimensionsQuantumGraphBuilder(
-        pipeline_graph,
-        butler,
-        skip_existing_in=skipExistingIn if skipExistingIn is not None else [],
-        input_collections=butler.collections.defaults,
-        output_run=run,
-        where=userQuery,
-        bind=bind,
-        dataset_query_constraint=datasetQueryConstraint,
-    )
-    _LOG.debug("Calling QuantumGraphBuilder.build.")
-    if not metadata:
-        metadata = {}
-    metadata["output_run"] = run
-
-    qgraph = builder.build(metadata=metadata, attach_datastore_records=makeDatastoreRecords)
+        butler_created = True
+
+    try:
+        if callPopulateButler:
+            populateButler(pipeline_graph, butler, datasetTypes=datasetTypes, instrument=instrument)
+
+        # Make the graph
+        _LOG.debug(
+            "Instantiating QuantumGraphBuilder, "
+            "skip_existing_in=%s, input_collections=%r, output_run=%r, where=%r, bind=%s.",
+            skipExistingIn,
+            butler.collections.defaults,
+            run,
+            userQuery,
+            bind,
+        )
+        if not run:
+            assert butler.run is not None, "Butler must have run defined"
+            run = butler.run
+        builder = AllDimensionsQuantumGraphBuilder(
+            pipeline_graph,
+            butler,
+            skip_existing_in=skipExistingIn if skipExistingIn is not None else [],
+            input_collections=butler.collections.defaults,
+            output_run=run,
+            where=userQuery,
+            bind=bind,
+            dataset_query_constraint=datasetQueryConstraint,
+        )
+        _LOG.debug("Calling QuantumGraphBuilder.build.")
+        if not metadata:
+            metadata = {}
+        metadata["output_run"] = run
+
+        qgraph = builder.build(metadata=metadata, attach_datastore_records=makeDatastoreRecords)
+    except Exception:
+        if butler_created:
+            butler.close()
+        raise
 
     return butler, qgraph

lsst_pipe_base-29.2025.4900/python/lsst/pipe/base/version.py

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

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900/python/lsst_pipe_base.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-pipe-base
-Version: 29.2025.4700
+Version: 29.2025.4900
 Summary: Pipeline infrastructure for the Rubin Science Pipelines.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License-Expression: BSD-3-Clause OR GPL-3.0-or-later

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/python/lsst_pipe_base.egg-info/SOURCES.txt

@@ -147,6 +147,7 @@ tests/test_config_formatter.py
 tests/test_connections.py
 tests/test_dataid_match.py
 tests/test_dataset_handle.py
+tests/test_deferredDatasetRef.py
 tests/test_dot_tools.py
 tests/test_dynamic_connections.py
 tests/test_execution_reports.py

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/tests/test_adjust_all_quanta.py

@@ -129,6 +129,7 @@ class AdjustAllQuantaTestCase(unittest.TestCase):
         adjust_all_quanta hook, and check that it works as expected.
         """
         butler = self.make_butler()
+        self.enterContext(butler)
         pipeline_graph = PipelineGraph(universe=butler.dimensions)
         pipeline_graph.add_task("grouper", GroupTestTask)
         collections = ["imported_g", "imported_r"]

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/tests/test_aggregator.py

@@ -263,7 +263,9 @@ class AggregatorTestCase(unittest.TestCase):
         quanta : `~collections.abc.Iterator` [`uuid.UUID`]
             An iterator over all executed quantum IDs (not blocked ones).
         """
-        qg.init_output_run(qg.make_init_qbb(repo))
+        qbb = qg.make_init_qbb(repo)
+        self.enterContext(qbb)
+        qg.init_output_run(qbb)
         sqe = SingleQuantumExecutor(
             limited_butler_factory=lambda quantum: QuantumBackedButler.initialize(
                 repo,

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/tests/test_caching_limited_butler.py

@@ -44,6 +44,7 @@ class CachingLimitedButlerTestCase(unittest.TestCase):
 
     def test_init(self):
         helper = InMemoryRepo("base.yaml")
+        self.enterContext(helper)
         helper.add_task()
         refs = helper.insert_datasets("dataset_auto0")
         in_memory_butler = helper.make_limited_butler()

{lsst_pipe_base-29.2025.4700 → lsst_pipe_base-29.2025.4900}/tests/test_config_formatter.py

@@ -51,7 +51,8 @@ class PexConfigFormatterTestCase(unittest.TestCase):
         """Create a new butler root for each test."""
         self.root = makeTestTempDir(TESTDIR)
         Butler.makeRepo(self.root)
-        self.butler = Butler(self.root, run="test_run")
+        self.butler = Butler.from_config(self.root, run="test_run")
+        self.enterContext(self.butler)
         # No dimensions in dataset type so we don't have to worry about
         # inserting dimension data or defining data IDs.
         self.datasetType = DatasetType(