def setUp(self):
super().setUp()
self.dimension = Dimension(translations='translations')
self.dimension.correct_virtual = 1
self.dimension.correct_reporting = 1
self.dimension.correct_ceiling_virtual = 2
self.dimension.correct_ceiling_reporting = 2
self.dimension.incorrect_virtual = 1
self.dimension.incorrect_reporting = 1
self.dimension_none = Dimension(
deserialized_files='deserialized files')
self.dimension_none.correct_virtual = 0
self.dimension_none.correct_reporting = 0
self.dimension_none.correct_ceiling_virtual = 0
self.dimension_none.correct_ceiling_reporting = 0
self.dimension_none.incorrect_virtual = 0
self.dimension_none.incorrect_reporting = 0
self.dimension_override = copy.copy(self.dimension)
self.entities = {
'canonical_type_appended':
canonical_entity(),
'noncanonical_type_appended':
noncanonical_entity(),
'reporting':
list(
validator.Deserialize(['tests/samples/reporting_entity.yaml'
])[0].values())[0],
'virtual':
list(
validator.Deserialize(['tests/samples/virtual_entity.yaml'
])[0].values())[0],
}
def testEntityIsCanonical(self):
self.assertTrue(
Dimension.is_entity_canonical(
self.entities['canonical_type_appended']))
self.assertFalse(
Dimension.is_entity_canonical(
self.entities['noncanonical_type_appended']))
# This entity has had a type of `None` appended, thus it returns false.
reporting_type_none = copy.copy(self.entities['reporting'])
reporting_type_none.type = None
self.assertFalse(Dimension.is_entity_canonical(reporting_type_none))
def testArgumentExclusivity(self):
with self.assertRaises(Exception) as not_enough:
Dimension()
self.assertEqual(
not_enough.exception.args[0],
'`translations` xor `deserialized_files` argument is required')
with self.assertRaises(Exception) as too_many:
Dimension(translations='translations',
deserialized_files='deserialized files')
self.assertEqual(
too_many.exception.args[0],
'`translations` or `deserialized_files` argument must be exclusive'
)
class DimensionTest(absltest.TestCase):
def setUp(self):
super().setUp()
self.dimension = Dimension(translations='translations')
self.dimension.correct_virtual = 1
self.dimension.correct_reporting = 1
self.dimension.correct_ceiling_virtual = 2
self.dimension.correct_ceiling_reporting = 2
self.dimension.incorrect_virtual = 1
self.dimension.incorrect_reporting = 1
self.dimension_none = Dimension(
deserialized_files='deserialized files')
self.dimension_none.correct_virtual = 0
self.dimension_none.correct_reporting = 0
self.dimension_none.correct_ceiling_virtual = 0
self.dimension_none.correct_ceiling_reporting = 0
self.dimension_none.incorrect_virtual = 0
self.dimension_none.incorrect_reporting = 0
self.dimension_override = copy.copy(self.dimension)
self.entities = {
'canonical_type_appended':
canonical_entity(),
'noncanonical_type_appended':
noncanonical_entity(),
'reporting':
list(
validator.Deserialize(['tests/samples/reporting_entity.yaml'
])[0].values())[0],
'virtual':
list(
validator.Deserialize(['tests/samples/virtual_entity.yaml'
])[0].values())[0],
}
def testArgumentAttributes(self):
self.assertEqual(self.dimension.translations, 'translations')
self.assertEqual(self.dimension.deserialized_files, None)
self.assertEqual(self.dimension_none.translations, None)
self.assertEqual(self.dimension_none.deserialized_files,
'deserialized files')
def testCategoryAttribute_None(self):
self.assertEqual(Dimension.category, None)
self.assertEqual(self.dimension.category, None)
def testArgumentExclusivity(self):
with self.assertRaises(Exception) as not_enough:
Dimension()
self.assertEqual(
not_enough.exception.args[0],
'`translations` xor `deserialized_files` argument is required')
with self.assertRaises(Exception) as too_many:
Dimension(translations='translations',
deserialized_files='deserialized files')
self.assertEqual(
too_many.exception.args[0],
'`translations` or `deserialized_files` argument must be exclusive'
)
def testCorrectTotal(self):
self.assertEqual(self.dimension.correct_total(), 2)
self.assertEqual(self.dimension_none.correct_total(), 0)
self.assertEqual(self.dimension.correct_total_override, None)
self.dimension.correct_total_override = 4
self.assertEqual(self.dimension.correct_total_override, 4)
def testCorrectCeiling(self):
self.assertEqual(self.dimension.correct_ceiling(), 4)
self.assertEqual(self.dimension_none.correct_total(), 0)
self.assertEqual(self.dimension_override.correct_ceiling_override,
None)
self.dimension_override.correct_ceiling_override = 8
self.assertEqual(self.dimension_override.correct_ceiling_override, 8)
def testIncorrectTotal(self):
self.assertEqual(self.dimension.incorrect_total(), 2)
self.assertEqual(self.dimension_none.correct_total(), 0)
self.assertEqual(self.dimension_override.incorrect_total_override,
None)
self.dimension_override.incorrect_total_override = 4
self.assertEqual(self.dimension_override.incorrect_total_override, 4)
def testResultComposite(self):
self.assertEqual(self.dimension.result_all, 0.0)
self.assertEqual(self.dimension_none.result_all, None)
self.assertEqual(self.dimension_override.result_all, 0.0)
def testResultVirtual(self):
self.assertEqual(self.dimension.result_virtual, 0.0)
self.assertEqual(self.dimension_none.result_virtual, None)
def testResultReporting(self):
self.assertEqual(self.dimension.result_reporting, 0.0)
self.assertEqual(self.dimension_none.result_reporting, None)
def testEntityIsCanonical(self):
self.assertTrue(
Dimension.is_entity_canonical(
self.entities['canonical_type_appended']))
self.assertFalse(
Dimension.is_entity_canonical(
self.entities['noncanonical_type_appended']))
# This entity has had a type of `None` appended, thus it returns false.
reporting_type_none = copy.copy(self.entities['reporting'])
reporting_type_none.type = None
self.assertFalse(Dimension.is_entity_canonical(reporting_type_none))
def testEntityIsReporting(self):
self.assertTrue(
Dimension.is_entity_reporting(self.entities['reporting']))
self.assertFalse(
Dimension.is_entity_reporting(self.entities['virtual']))
def testEntityIsVirtual(self):
self.assertTrue(Dimension.is_entity_virtual(self.entities['virtual']))
self.assertFalse(
Dimension.is_entity_virtual(self.entities['reporting']))
def testStr(self):
self.assertEqual(
str(self.dimension),
'{result_all: 0.00, result_virtual: 0.00, result_reporting: 0.00}')
def testEntityIsVirtual(self):
self.assertTrue(Dimension.is_entity_virtual(self.entities['virtual']))
self.assertFalse(
Dimension.is_entity_virtual(self.entities['reporting']))
def retrieve_reporting_translations(
*, proposed_entities: DeserializedFile,
solution_entities: DeserializedFile) -> TranslationsDict:
"""
Retrieves proposed and solution translations
for all matched reporting entities.
Args:
matches: List of `cloud_device_id`s which have corresponding
proposed and solution entities
proposed_entities: Dictionary of proposed entity names
and `EntityInstance`s
solution_entities: Dictionary of solution entity names
and `EntityInstance`s
Returns:
Dictionary with `cloud_device_id`s as keys
and values which are dictionaries containing lists
of translations for the device, keyed under the file type
"""
translations = {}
for solution_entity in solution_entities.values():
if solution_entity.cloud_device_id is None:
continue # as this is not a reporting device
if not Dimension.is_entity_canonical(solution_entity):
continue # as noncanonical entities are skipped
cloud_device_id = solution_entity.cloud_device_id
def find_matches(cdid: str) -> List[Any]:
"""Find the matching proposal via cloud_device_id comparison.
Args:
cdid: cloud device id string.
Returns:
List of matching entities.
"""
matches = [
proposed_entity
for proposed_entity in proposed_entities.values()
if proposed_entity.cloud_device_id == cdid
]
return matches
proposed_entity = find_matches(cloud_device_id)[0] if find_matches(
cloud_device_id) else {}
def aggregate_translations(entity) -> List[Any]:
"""Isolate translation of an entity pairing."""
if getattr(entity, 'translation', None):
return list(entity.translation.items())
return []
translations[cloud_device_id] = {
f'{PROPOSED}': aggregate_translations(proposed_entity),
f'{SOLUTION}': aggregate_translations(solution_entity)
}
return translations