def makeSQLiteRegistry(create=True):
"""Context manager to create new empty registry database.
Yields
------
config : `RegistryConfig`
Registry configuration for initialized registry database.
"""
with temporaryDirectory() as tmpdir:
uri = f"sqlite:///{tmpdir}/gen3.sqlite"
config = RegistryConfig()
config["db"] = uri
if create:
Registry.createFromConfig(config)
yield config
def test_register(self):
"""Test that register() sets appropriate Dimensions."""
registryConfig = RegistryConfig()
registryConfig["db"] = "sqlite://"
registry = Registry.createFromConfig(registryConfig)
# Check that the registry starts out empty.
self.instrument.importAll(registry)
self.assertFalse(list(registry.queryDimensionRecords("instrument")))
# Register and check again.
self.instrument.register(registry)
instruments = list(registry.queryDimensionRecords("instrument"))
self.assertEqual(len(instruments), 1)
self.assertEqual(instruments[0].name, self.name)
self.assertEqual(instruments[0].detector_max, 2)
self.assertIn("DummyInstrument", instruments[0].class_name)
self.instrument.importAll(registry)
from_registry = DummyInstrument.fromName("DummyInstrument", registry)
self.assertIsInstance(from_registry, Instrument)
with self.assertRaises(LookupError):
Instrument.fromName("NotThrere", registry)
# Register a bad instrument.
BadInstrument().register(registry)
with self.assertRaises(TypeError):
Instrument.fromName("BadInstrument", registry)
UnimportableInstrument().register(registry)
with self.assertRaises(ImportError):
Instrument.fromName("NoImportInstr", registry)
# This should work even with the bad class name.
self.instrument.importAll(registry)
def makeButler(self, **kwargs: Any) -> Butler:
"""Return new Butler instance on each call.
"""
config = ButlerConfig()
# make separate temporary directory for registry of this instance
tmpdir = tempfile.mkdtemp(dir=self.root)
config["registry", "db"] = f"sqlite:///{tmpdir}/gen3.sqlite3"
config["root"] = self.root
# have to make a registry first
registryConfig = RegistryConfig(config.get("registry"))
Registry.createFromConfig(registryConfig)
butler = Butler(config, **kwargs)
DatastoreMock.apply(butler)
return butler
def test_register(self):
"""Test that register() sets appropriate Dimensions.
"""
registryConfig = RegistryConfig()
registryConfig["db"] = "sqlite://"
registry = Registry.createFromConfig(registryConfig)
# check that the registry starts out empty
self.assertFalse(registry.queryDataIds(["instrument"]).toSequence())
self.assertFalse(registry.queryDataIds(["detector"]).toSequence())
self.assertFalse(
registry.queryDataIds(["physical_filter"]).toSequence())
# register the instrument and check that certain dimensions appear
self.instrument.register(registry)
instrumentDataIds = registry.queryDataIds(["instrument"]).toSequence()
self.assertEqual(len(instrumentDataIds), 1)
instrumentNames = {
dataId["instrument"]
for dataId in instrumentDataIds
}
self.assertEqual(instrumentNames, {self.data.name})
detectorDataIds = registry.queryDataIds(["detector"
]).expanded().toSequence()
self.assertEqual(len(detectorDataIds), self.data.nDetectors)
detectorNames = {
dataId.records["detector"].full_name
for dataId in detectorDataIds
}
self.assertIn(self.data.firstDetectorName, detectorNames)
physicalFilterDataIds = registry.queryDataIds(["physical_filter"
]).toSequence()
filterNames = {
dataId['physical_filter']
for dataId in physicalFilterDataIds
}
self.assertGreaterEqual(filterNames, self.data.physical_filters)
# Check that the instrument class can be retrieved
registeredInstrument = Instrument.fromName(self.instrument.getName(),
registry)
self.assertEqual(type(registeredInstrument), type(self.instrument))
# Check that re-registration is not an error.
self.instrument.register(registry)
def loadDimensionData() -> DataCoordinateSequence:
"""Load dimension data from an export file included in the code repository.
Returns
-------
dataIds : `DataCoordinateSet`
A set containing all data IDs in the export file.
"""
# Create an in-memory SQLite database and Registry just to import the YAML
# data and retreive it as a set of DataCoordinate objects.
config = RegistryConfig()
config["db"] = "sqlite://"
registry = Registry.createFromConfig(config)
with open(DIMENSION_DATA_FILE, 'r') as stream:
backend = YamlRepoImportBackend(stream, registry)
backend.register()
backend.load(datastore=None)
dimensions = DimensionGraph(registry.dimensions, names=["visit", "detector", "tract", "patch"])
return registry.queryDataIds(dimensions).expanded().toSequence()