def testDelItem(self):
nkd = NamedKeyDict(self.dictionary)
del nkd[self.a]
self.assertNotIn("a", nkd)
del nkd["b"]
self.assertNotIn(self.b, nkd)
self.assertEqual(len(nkd), 0)
def testSchemaGeneration(self):
tableSpecs = NamedKeyDict({})
for element in self.universe.getStaticElements():
if element.hasTable and element.viewOf is None:
tableSpecs[element] = element.RecordClass.fields.makeTableSpec(
RegionReprClass=SpatialRegionDatabaseRepresentation,
TimespanReprClass=TimespanDatabaseRepresentation.Compound
)
for element, tableSpec in tableSpecs.items():
for dep in element.required:
with self.subTest(element=element.name, dep=dep.name):
if dep != element:
self.assertIn(dep.name, tableSpec.fields)
self.assertEqual(tableSpec.fields[dep.name].dtype, dep.primaryKey.dtype)
self.assertEqual(tableSpec.fields[dep.name].length, dep.primaryKey.length)
self.assertEqual(tableSpec.fields[dep.name].nbytes, dep.primaryKey.nbytes)
self.assertFalse(tableSpec.fields[dep.name].nullable)
self.assertTrue(tableSpec.fields[dep.name].primaryKey)
else:
self.assertIn(element.primaryKey.name, tableSpec.fields)
self.assertEqual(tableSpec.fields[element.primaryKey.name].dtype,
dep.primaryKey.dtype)
self.assertEqual(tableSpec.fields[element.primaryKey.name].length,
dep.primaryKey.length)
self.assertEqual(tableSpec.fields[element.primaryKey.name].nbytes,
dep.primaryKey.nbytes)
self.assertFalse(tableSpec.fields[element.primaryKey.name].nullable)
self.assertTrue(tableSpec.fields[element.primaryKey.name].primaryKey)
for dep in element.implied:
with self.subTest(element=element.name, dep=dep.name):
self.assertIn(dep.name, tableSpec.fields)
self.assertEqual(tableSpec.fields[dep.name].dtype, dep.primaryKey.dtype)
self.assertFalse(tableSpec.fields[dep.name].primaryKey)
for foreignKey in tableSpec.foreignKeys:
self.assertIn(foreignKey.table, tableSpecs)
self.assertIn(foreignKey.table, element.graph.dimensions.names)
self.assertEqual(len(foreignKey.source), len(foreignKey.target))
for source, target in zip(foreignKey.source, foreignKey.target):
self.assertIn(source, tableSpec.fields.names)
self.assertIn(target, tableSpecs[foreignKey.table].fields.names)
self.assertEqual(tableSpec.fields[source].dtype,
tableSpecs[foreignKey.table].fields[target].dtype)
self.assertEqual(tableSpec.fields[source].length,
tableSpecs[foreignKey.table].fields[target].length)
self.assertEqual(tableSpec.fields[source].nbytes,
tableSpecs[foreignKey.table].fields[target].nbytes)
def testGetItem(self):
nkd = NamedKeyDict(self.dictionary)
self.assertEqual(nkd["a"], 10)
self.assertEqual(nkd[self.a], 10)
self.assertEqual(nkd["b"], 20)
self.assertEqual(nkd[self.b], 20)
self.assertIn("a", nkd)
self.assertIn(self.b, nkd)
def testSetItem(self):
nkd = NamedKeyDict(self.dictionary)
nkd[self.a] = 30
self.assertEqual(nkd["a"], 30)
nkd["b"] = 40
self.assertEqual(nkd[self.b], 40)
with self.assertRaises(KeyError):
nkd["c"] = 50
with self.assertRaises(AssertionError):
nkd[self.TestTuple("a", 3)] = 60
def unpackMultiRefs(self) -> NamedKeyDict[DatasetType, DatasetRef]:
"""Unpack nested multi-element `DatasetRef` dicts into a new
mapping with `DatasetType` keys and `set` of `DatasetRef` values.
Returns
-------
dictionary : `NamedKeyDict`
Dictionary mapping `DatasetType` to `DatasetRef`, with both
`DatasetType` instances and string names usable as keys.
"""
return NamedKeyDict({
datasetType: list(refs.values())
for datasetType, refs in self.items()
})
def testConstructor(self):
"""Test of constructor.
"""
# Quantum specific arguments
run = None # TODO add Run
taskName = "some.task.object" # can't use a real PipelineTask due to inverted package dependency
# Base class arguments
startTime = astropy.time.Time("2018-01-01", format="iso", scale="utc")
endTime = astropy.time.Time("2018-01-02", format="iso", scale="utc")
host = "localhost"
quantum = Quantum(taskName=taskName,
run=run,
startTime=startTime,
endTime=endTime,
host=host)
self.assertEqual(quantum.taskName, taskName)
self.assertEqual(quantum.run, run)
self.assertEqual(quantum.predictedInputs, NamedKeyDict())
self.assertEqual(quantum.actualInputs, NamedKeyDict())
self.assertIsNone(quantum.dataId)
self.assertIsNone(quantum.id)
self.assertEqual(quantum.startTime, startTime)
self.assertEqual(quantum.endTime, endTime)
self.assertEqual(quantum.host, host)
def initialize(
cls,
db: Database,
context: StaticTablesContext,
*,
collections: CollectionManager,
dimensions: DimensionRecordStorageManager,
) -> CollectionSummaryManager:
"""Create all summary tables (or check that they have been created),
returning an object to manage them.
Parameters
----------
db : `Database`
Interface to the underlying database engine and namespace.
context : `StaticTablesContext`
Context object obtained from `Database.declareStaticTables`; used
to declare any tables that should always be present.
collections: `CollectionManager`
Manager object for the collections in this `Registry`.
dimensions : `DimensionRecordStorageManager`
Manager object for the dimensions in this `Registry`.
Returns
-------
manager : `CollectionSummaryManager`
New manager object for collection summaries.
"""
specs = CollectionSummaryTables.makeTableSpecs(collections, dimensions)
tables = CollectionSummaryTables(
datasetType=context.addTable("collection_summary_dataset_type",
specs.datasetType),
dimensions=NamedKeyDict({
dimension:
context.addTable(f"collection_summary_{dimension.name}", spec)
for dimension, spec in specs.dimensions.items()
}).freeze(),
)
return cls(
db=db,
collections=collections,
dimensions=dimensions,
tables=tables,
)
def unpackSingleRefs(self) -> NamedKeyDict[DatasetType, DatasetRef]:
"""Unpack nested single-element `DatasetRef` dicts into a new
mapping with `DatasetType` keys and `DatasetRef` values.
This method assumes that each nest contains exactly one item, as is the
case for all "init" datasets.
Returns
-------
dictionary : `NamedKeyDict`
Dictionary mapping `DatasetType` to `DatasetRef`, with both
`DatasetType` instances and string names usable as keys.
"""
def getOne(refs: Dict[DataCoordinate, DatasetRef]) -> DatasetRef:
ref, = refs.values()
return ref
return NamedKeyDict(
{datasetType: getOne(refs)
for datasetType, refs in self.items()})
def testConstructor(self):
"""Test of constructor.
"""
# Quantum specific arguments
taskName = "some.task.object" # can't use a real PipelineTask due to inverted package dependency
quantum = Quantum(taskName=taskName)
self.assertEqual(quantum.taskName, taskName)
self.assertEqual(quantum.initInputs, {})
self.assertEqual(quantum.inputs, NamedKeyDict())
self.assertEqual(quantum.outputs, {})
self.assertIsNone(quantum.dataId)
universe = DimensionUniverse()
instrument = "DummyCam"
datasetTypeName = "test_ds"
storageClass = StorageClass("testref_StructuredData")
datasetType = DatasetType(datasetTypeName,
universe.extract(("instrument", "visit")),
storageClass)
predictedInputs = {
datasetType: [
DatasetRef(datasetType, dict(instrument=instrument, visit=42)),
DatasetRef(datasetType, dict(instrument=instrument, visit=43))
]
}
outputs = {
datasetType: [
DatasetRef(datasetType, dict(instrument=instrument, visit=42)),
DatasetRef(datasetType, dict(instrument=instrument, visit=43))
]
}
quantum = Quantum(taskName=taskName,
inputs=predictedInputs,
outputs=outputs)
self.assertEqual(len(quantum.inputs[datasetType]), 2)
self.assertEqual(len(quantum.outputs[datasetType]), 2)
def testEquality(self):
nkd = NamedKeyDict(self.dictionary)
self.assertEqual(nkd, self.dictionary)
self.assertEqual(self.dictionary, nkd)
def testIter(self):
self.assertEqual(set(iter(NamedKeyDict(self.dictionary))),
set(self.dictionary))
def testNoNameConstruction(self):
self.dictionary["a"] = 30
with self.assertRaises(AttributeError):
NamedKeyDict(self.dictionary)
with self.assertRaises(AttributeError):
NamedKeyDict(iter(self.dictionary.items()))
def testDuplicateNameConstruction(self):
self.dictionary[self.TestTuple(name="a", id=3)] = 30
with self.assertRaises(AssertionError):
NamedKeyDict(self.dictionary)
with self.assertRaises(AssertionError):
NamedKeyDict(iter(self.dictionary.items()))
def testConstruction(self):
self.check(NamedKeyDict(self.dictionary))
self.check(NamedKeyDict(iter(self.dictionary.items())))
def testSchemaGeneration(self):
tableSpecs = NamedKeyDict({})
for element in self.universe.elements:
if element.hasTable and element.viewOf is None:
tableSpecs[element] = makeDimensionElementTableSpec(element)
for element, tableSpec in tableSpecs.items():
for dep in element.required:
with self.subTest(element=element.name, dep=dep.name):
if dep != element:
self.assertIn(dep.name, tableSpec.fields)
self.assertEqual(tableSpec.fields[dep.name].dtype,
dep.primaryKey.dtype)
self.assertEqual(tableSpec.fields[dep.name].length,
dep.primaryKey.length)
self.assertEqual(tableSpec.fields[dep.name].nbytes,
dep.primaryKey.nbytes)
self.assertFalse(tableSpec.fields[dep.name].nullable)
self.assertTrue(tableSpec.fields[dep.name].primaryKey)
else:
self.assertIn(element.primaryKey.name,
tableSpec.fields)
self.assertEqual(
tableSpec.fields[element.primaryKey.name].dtype,
dep.primaryKey.dtype)
self.assertEqual(
tableSpec.fields[element.primaryKey.name].length,
dep.primaryKey.length)
self.assertEqual(
tableSpec.fields[element.primaryKey.name].nbytes,
dep.primaryKey.nbytes)
self.assertFalse(
tableSpec.fields[element.primaryKey.name].nullable)
self.assertTrue(tableSpec.fields[
element.primaryKey.name].primaryKey)
for dep in element.implied:
with self.subTest(element=element.name, dep=dep.name):
self.assertIn(dep.name, tableSpec.fields)
self.assertEqual(tableSpec.fields[dep.name].dtype,
dep.primaryKey.dtype)
self.assertFalse(tableSpec.fields[dep.name].primaryKey)
for foreignKey in tableSpec.foreignKeys:
self.assertIn(foreignKey.table, tableSpecs)
self.assertIn(foreignKey.table, element.graph.dimensions.names)
self.assertEqual(len(foreignKey.source),
len(foreignKey.target))
for source, target in zip(foreignKey.source,
foreignKey.target):
self.assertIn(source, tableSpec.fields.names)
self.assertIn(target,
tableSpecs[foreignKey.table].fields.names)
self.assertEqual(
tableSpec.fields[source].dtype,
tableSpecs[foreignKey.table].fields[target].dtype)
self.assertEqual(
tableSpec.fields[source].length,
tableSpecs[foreignKey.table].fields[target].length)
self.assertEqual(
tableSpec.fields[source].nbytes,
tableSpecs[foreignKey.table].fields[target].nbytes)
self.assertEqual(tuple(tableSpec.fields.names),
element.RecordClass.__slots__)
