def testAddDuplicateTypes(self):
fields_universe = field_lib.FieldUniverse([])
fields_universe._namespace_map = {'': ('animal'), 'ANIMAL': ('meow')}
folderpath = 'ANIMAL/entity_types'
type_folder = entity_type_lib.EntityTypeFolder(folderpath,
fields_universe)
self.assertFalse(type_folder.GetFindings())
rel_typepath = os.path.join(folderpath, 'mammal')
# entity type
entity_type = entity_type_lib.EntityType(
filepath=rel_typepath,
typename='kitty',
description='feline animal',
local_field_tuples=_FS(['ANIMAL/meow', '/animal']))
# duplicate type
dup_type = entity_type_lib.EntityType(filepath=rel_typepath,
typename='kitty',
description='feline animal',
local_field_tuples=_FS(
['ANIMAL/meow', '/animal']))
type_folder._AddType(entity_type)
type_folder._AddType(dup_type)
self.assertTrue(
type_folder.local_namespace.HasFindingTypes(
[findings_lib.DuplicateTypesError]))
self.assertLen(type_folder.local_namespace.valid_types_map, 1)
self.assertIn(entity_type.typename,
type_folder.local_namespace.valid_types_map)
self.assertEqual(
type_folder.local_namespace.valid_types_map.get(
entity_type.typename), entity_type)
def testAnalyzeIgnoresAutogeneratedTypes(self):
yaml = {'literals': ['field1', 'field2', 'field3', 'field4']}
field_universe = field_lib.FieldUniverse(
[_GetFieldFolder(yaml)])
yaml = {
'parent': {
'description': 'parent',
'uses': ['field1', 'field2', 'field3']
},
'AUTOGENERATED_NETWORK_DEVICE': {
'description': 'AUTOGENERATED_NETWORK_DEVICE',
},
'child2': {
'implements': ['AUTOGENERATED_NETWORK_DEVICE'],
'description': 'child2',
'uses': ['field1', 'field2', 'field3', 'field4']
},
}
type_folder = _GetEntityTypeFolder(
field_universe, yaml)
universe = _GetEntityTypeUniverse([type_folder])
manager = entity_type_manager.EntityTypeManager(universe)
findings = manager.Analyze()
self.assertEmpty(findings)
def testConfigUniverseGetStatesByField(self):
meow_states = ['HUNGRY', 'SNUGGLY']
meow_cat = field_lib.Field('meow_cat')
meow_cat.states = meow_states
claw_states = ['HISSY', 'BITEY']
claws_cat = field_lib.Field('claws_cat')
claws_cat.states = claw_states
global_folder = field_lib.FieldFolder('fields/anyfolder')
folder = field_lib.FieldFolder('localnamespace/fields/anyfolder',
global_folder.local_namespace)
folder.local_namespace.PutIfAbsent(meow_cat)
global_folder.local_namespace.PutIfAbsent(claws_cat)
field_universe = field_lib.FieldUniverse([folder, global_folder])
config_universe = presubmit_validate_types_lib.ConfigUniverse(
subfield_universe=None,
field_universe=field_universe,
entity_type_universe=None,
state_universe=None,
connection_universe=None,
unit_universe=None)
self.assertSameElements(claw_states,
config_universe.GetStatesByField('/claws_cat'))
self.assertSameElements(
meow_states,
config_universe.GetStatesByField('localnamespace/meow_cat'))
def testGetTypenamesBySubsetOI(self):
#build test universe
yaml = {'literals': ['field1', 'field2', 'field3', 'field4']}
field_universe = field_lib.FieldUniverse(
[_GetFieldFolder(yaml)])
yaml = {
'VAV_child1': {
'description': 'child1',
'uses': ['field1', 'field4'],
'opt_uses': ['field2']
},
'VAV_child2': {
'description': 'child2',
'uses': ['field1', 'field3', 'field4']
},
}
type_folder = _GetEntityTypeFolder(field_universe, yaml)
universe = _GetEntityTypeUniverse([type_folder])
manager = entity_type_manager.EntityTypeManager(universe)
#expected output for GetTypenamesBySubsetOI() once Analyze() is called
expected_output = {
frozenset({
FieldParts(namespace='', field='field4', increment=''),
FieldParts(namespace='', field='field1', increment='')
}): {'/VAV_child2', '/VAV_child1'}
}
#test field sets have not been instantiated
self.assertRaises(Exception, manager.GetTypenamesBySubsetOI)
#instantiate and build field sets
manager.Analyze()
function_output = manager.GetTypenamesBySubsetOI()
self.assertEqual(expected_output, function_output)
def testConfigUniverse(self):
context = findings_lib.FileContext('')
type_universe = entity_type_lib.EntityTypeUniverse([])
type_universe.AddFinding(
findings_lib.IllegalCharacterError('stuff', context))
field_universe = field_lib.FieldUniverse([])
field_universe.AddFinding(
findings_lib.InconsistentFileLocationError('', context))
subfield_universe = subfield_lib.SubfieldUniverse([])
subfield_universe.AddFinding(
findings_lib.CapitalizationError('Hi', context))
state_universe = state_lib.StateUniverse([])
connection_universe = connection_lib.ConnectionUniverse([])
connection_universe.AddFinding(
findings_lib.InvalidConnectionNamespaceError('notglobal', context))
unit_universe = unit_lib.UnitUniverse([])
config_universe = presubmit_validate_types_lib.ConfigUniverse(
subfield_universe=subfield_universe,
field_universe=field_universe,
entity_type_universe=type_universe,
state_universe=state_universe,
connection_universe=connection_universe,
unit_universe=unit_universe)
findings = config_universe.GetFindings()
self.assertLen(findings, 4)
self.assertTrue(
config_universe.HasFindingTypes([
findings_lib.InconsistentFileLocationError,
findings_lib.IllegalCharacterError,
findings_lib.CapitalizationError,
findings_lib.InvalidConnectionNamespaceError
]))
self.assertFalse(config_universe.IsValid())
def testAddTypeWithNamespacedField(self):
fields_universe = field_lib.FieldUniverse([])
fields_universe._namespace_map = {
'': [field_lib.Field('animal')],
'ANIMAL': [field_lib.Field('meow')],
'ATTACK': [field_lib.Field('claws')]
}
folderpath = 'ANIMAL/entity_types'
type_folder = entity_type_lib.EntityTypeFolder(folderpath,
fields_universe)
self.assertFalse(type_folder.GetFindings())
rel_typepath = os.path.join(folderpath, 'mammal')
# field 'claws' is undefined.
entity_type = entity_type_lib.EntityType(
filepath=rel_typepath,
typename='cat',
description='feline animal',
local_field_tuples=_FS(['ANIMAL/meow', 'ATTACK/claws', '/animal']))
type_folder._AddType(entity_type)
self.assertFalse(type_folder.local_namespace.GetFindings())
self.assertLen(type_folder.local_namespace.valid_types_map, 1)
self.assertIn(entity_type.typename,
type_folder.local_namespace.valid_types_map)
self.assertEqual(
type_folder.local_namespace.valid_types_map.get(
entity_type.typename), entity_type)
def testFieldsUniverseGetFindings(self):
context = findings_lib.FileContext(_GOOD_PATH + '/file.yaml')
folder = field_lib.FieldFolder(_GOOD_PATH)
folder.AddFinding(
findings_lib.InconsistentFileLocationError('', context))
namespace = folder.local_namespace
namespace.AddFinding(
findings_lib.UnrecognizedSubfieldError(['any'],
field_lib.Field(
'two',
file_context=context)))
field = field_lib.Field('one', file_context=context)
# Currently there are no warnings for fields, so using a subfield warning
field.AddFinding(
findings_lib.MissingSubfieldDescriptionWarning('one', context))
namespace.InsertField(field)
fields_universe = field_lib.FieldUniverse([folder])
findings = fields_universe.GetFindings()
self.assertLen(findings, 3)
self.assertTrue(
fields_universe.HasFindingTypes([
findings_lib.InconsistentFileLocationError,
findings_lib.UnrecognizedSubfieldError,
findings_lib.MissingSubfieldDescriptionWarning
]))
self.assertFalse(fields_universe.IsValid())
def testConfigUniverseGetEntityType(self):
context = findings_lib.FileContext('')
type_universe = entity_type_lib.EntityTypeUniverse([])
type_universe.AddFinding(
findings_lib.IllegalCharacterError('stuff', context))
field_universe = field_lib.FieldUniverse([])
field_universe.AddFinding(
findings_lib.InconsistentFileLocationError('', context))
subfield_universe = subfield_lib.SubfieldUniverse([])
subfield_universe.AddFinding(
findings_lib.CapitalizationError('Hi', context))
state_universe = state_lib.StateUniverse([])
connection_universe = connection_lib.ConnectionUniverse([])
unit_universe = unit_lib.UnitUniverse([])
config_universe = presubmit_validate_types_lib.ConfigUniverse(
subfield_universe=subfield_universe,
field_universe=field_universe,
entity_type_universe=type_universe,
state_universe=state_universe,
connection_universe=connection_universe,
unit_universe=unit_universe)
entity_type = config_universe.GetEntityType('NONEXISTENT',
'NONEXISTENT')
self.assertIsNone(entity_type)
def testAddMultipleTypes(self):
fields_universe = field_lib.FieldUniverse([])
fields_universe._namespace_map = {
'': [field_lib.Field('animal')],
'ANIMAL': [field_lib.Field('meow')]
}
folderpath = 'ANIMAL/entity_types'
type_folder = entity_type_lib.EntityTypeFolder(folderpath, fields_universe)
self.assertFalse(type_folder.GetFindings())
rel_typepath = os.path.join(folderpath, 'mammal')
# bad entity type, field 'claws' is undefined.
bad_type = entity_type_lib.EntityType(
filepath=rel_typepath,
typename='cat',
description='feline animal',
local_field_tuples=_FS(['ANIMAL/meow', 'ANIMAL/claws', '/animal']))
# good entity type
good_type = entity_type_lib.EntityType(
filepath=rel_typepath,
typename='kitty',
description='feline animal',
local_field_tuples=_FS(['ANIMAL/meow', '/animal']))
type_folder._AddType(good_type)
type_folder._AddType(bad_type)
self.assertTrue(
type_folder.local_namespace.HasFindingTypes(
[findings_lib.UndefinedFieldError]))
self.assertLen(type_folder.local_namespace.valid_types_map, 1)
self.assertIn(good_type.typename,
type_folder.local_namespace.valid_types_map)
self.assertEqual(
type_folder.local_namespace.valid_types_map.get(good_type.typename),
good_type)
def testAnalyzeFindsDuplicates(self):
yaml = {'literals': ['field1', 'field2', 'field3', 'field4', 'field5']}
field_universe = field_lib.FieldUniverse(
[_GetFieldFolder(yaml)])
yaml = {
'parent': {
'description': 'parent',
'uses': ['field1', 'field2', 'field3']
},
'child1': {
'description': 'child1',
'implements': ['parent'],
'uses': ['field4']
},
'child2': {
'description': 'child2',
'uses': ['field1', 'field2', 'field3', 'field4']
},
}
type_folder = _GetEntityTypeFolder(field_universe, yaml)
universe = _GetEntityTypeUniverse([type_folder])
manager = entity_type_manager.EntityTypeManager(universe)
manager.Analyze()
child1 = universe.GetEntityType('', 'child1')
child2 = universe.GetEntityType('', 'child2')
parent = universe.GetEntityType('', 'parent')
self.assertTrue(child2.HasFindingTypes(
[findings_lib.DuplicateExpandedFieldSetsWarning]))
self.assertTrue(child1.HasFindingTypes(
[findings_lib.DuplicateExpandedFieldSetsWarning]))
self.assertFalse(parent.HasFindingTypes(
[findings_lib.DuplicateExpandedFieldSetsWarning]))
def testAnalyzeIgnoresNonCanonicalFlexibleParents(self):
yaml = {'literals': ['field1', 'field2', 'field3', 'field4']}
field_universe = field_lib.FieldUniverse(
[_GetFieldFolder(yaml)])
yaml = {
'VAV_parent': {
'description': 'parent',
'uses': ['field1', 'field4'],
'opt_uses': ['field2', 'field3']
},
'VAV_child1': {
'description': 'child1',
'uses': ['field1', 'field4'],
'opt_uses': ['field2']
},
}
type_folder = _GetEntityTypeFolder(field_universe, yaml)
universe = _GetEntityTypeUniverse([type_folder])
manager = entity_type_manager.EntityTypeManager(universe)
manager.Analyze()
parent = universe.GetEntityType('', 'VAV_parent')
self.assertFalse(parent.HasFindingTypes(
[findings_lib.OverlappingFlexTypeChildWarning,
findings_lib.OverlappingFlexTypeParentWarning]))
def testFieldUniverse(self):
# Create field folders
folder = field_lib.FieldFolder(_GOOD_PATH)
namespace = folder.local_namespace
namespace.InsertField(field_lib.Field('meow'))
namespace.InsertField(field_lib.Field('claws'))
fields_universe = field_lib.FieldUniverse([folder])
self.assertTrue(fields_universe.IsFieldDefined('meow', 'mynamespace'))
self.assertTrue(fields_universe.IsFieldDefined('claws', 'mynamespace'))
self.assertFalse(fields_universe.IsFieldDefined('clawsss', 'mynamespace'))
def BuildUniverse(config):
"""Verifies that the ontology config is consistent and valid.
Args:
config: a Config namedtuple containing lists of localpaths to config files.
Returns:
A ConfigUniverse that is fully populated with all content specified in the
config.
"""
# Parse state files
state_universe = None
if config.states:
state_folders = parse.ParseStateFoldersFromFiles(config.states)
state_universe = state_lib.StateUniverse(state_folders)
connections_universe = None
if config.connections:
connection_folders = parse.ParseConnectionFoldersFromFiles(
config.connections)
connections_universe = connection_lib.ConnectionUniverse(
connection_folders)
# Parse subfield files
subfields_universe = None
if config.subfields:
subfield_folders = parse.ParseSubfieldFoldersFromFiles(
config.subfields)
subfields_universe = subfield_lib.SubfieldUniverse(subfield_folders)
# Parse unit files
unit_universe = None
if config.units:
unit_folders = parse.ParseUnitFoldersFromFiles(config.units,
subfields_universe)
unit_universe = unit_lib.UnitUniverse(unit_folders)
if subfields_universe:
subfields_universe.ValidateUnits(unit_universe)
# Parse fields files
fields_universe = None
if config.fields:
field_folders = parse.ParseFieldFoldersFromFiles(
config.fields, subfields_universe, state_universe)
fields_universe = field_lib.FieldUniverse(field_folders)
# Parse typedef files
type_folders = parse.ParseTypeFoldersFromFiles(config.type_defs,
fields_universe)
types_universe = entity_type_lib.EntityTypeUniverse(type_folders)
# return findings_list, result_namespaces
return ConfigUniverse(types_universe, fields_universe, subfields_universe,
state_universe, connections_universe, unit_universe)
def testParseTypeFoldersFromFilesWithFieldsUniverse(self):
fields_universe = field_lib.FieldUniverse([])
fields_universe._namespace_map = {
'': ('current_sensor', 'fan_run_status', 'dryer_run_status',
'fan_run_command'),
'GOOD': ('zone_air_temperature_sensor')
}
type_folders = parse.ParseTypeFoldersFromFiles(
[self.good_types_file, self.good_types_file_2], fields_universe)
# should have 1 folder for GOOD namespace
self.assertLen(type_folders, 1)
# folder should have 4 types
valid_types = list(
type_folders[0].local_namespace.valid_types_map.values())
self.assertLen(valid_types, 4)
def testParseTypeFoldersFromFileUndefinedFields(self):
bad_type_file = base_lib.PathParts(
root=self.base_dir, relative_path='BAD/entity_types/bad3.yaml')
fields_universe = field_lib.FieldUniverse([])
fields_universe._namespace_map = {
'': ('current_sensor', 'fan_run_command')
}
type_folders = parse.ParseTypeFoldersFromFiles([bad_type_file],
fields_universe)
# should have 1 folder
self.assertLen(type_folders, 1)
self.assertTrue(type_folders[0].local_namespace.HasFindingTypes(
[findings_lib.UndefinedFieldError]))
valid_types = list(
type_folders[0].local_namespace.valid_types_map.values())
self.assertFalse(valid_types)
def testAnalyzeHandlesNamespaces(self):
yaml1 = {'literals': ['field1']}
yaml2 = {
'literals': ['field1', 'field2', 'field3', 'field4', 'field5']
}
field_folder1 = _GetFieldFolder(yaml1, 'HVAC')
field_folder2 = _GetFieldFolder(yaml2)
field_universe = field_lib.FieldUniverse(
[field_folder1, field_folder2])
yaml1 = {
'parent': {
'description': 'parent',
'uses': ['HVAC/field1', 'field2', 'field3']
},
}
yaml2 = {
'child1': {
'description': 'child1',
'uses': ['field1', 'field2', 'field3']
},
}
type_folder1 = _GetEntityTypeFolder(field_universe, yaml1,
'other_namespace')
type_folder2 = _GetEntityTypeFolder(field_universe, yaml2, 'HVAC')
universe = _GetEntityTypeUniverse([type_folder1, type_folder2])
manager = entity_type_manager.EntityTypeManager(universe)
findings = manager.Analyze()
child1 = universe.GetEntityType('HVAC', 'child1')
parent = universe.GetEntityType('other_namespace', 'parent')
self.assertLen(findings, 2)
self.assertLen(child1.GetFindings(), 1)
self.assertTrue(
child1.HasFindingTypes(
[findings_lib.DuplicateExpandedFieldSetsWarning]))
self.assertLen(parent.GetFindings(), 1)
self.assertTrue(
parent.HasFindingTypes(
[findings_lib.DuplicateExpandedFieldSetsWarning]))
def testInstanceLinkSourceFieldValidation(self, mock_fn):
field_u = field_lib.FieldUniverse([])
config_u = presubmit_validate_types_lib.ConfigUniverse(
None, field_u, None, None, None, None)
mock_fn.side_effect = lambda f, ns: f == 'run_status'
validator = entity_instance.InstanceValidator(config_u, _UPDATE_CFG)
src_ok = entity_instance.EntityInstance(
_UPDATE,
'AHU-1',
links=[link.Link('CTRL-1', {'run_status': 'run_status'})],
etag='123')
bad_src_field = entity_instance.EntityInstance(
_UPDATE,
'AHU-1',
links=[link.Link('CTRL-1', {'nonexistent_status': 'run_status'})],
etag='123')
self.assertFalse(validator.Validate(bad_src_field))
self.assertTrue(validator.Validate(src_ok))
def testParseTypeFoldersFromFileBadFormat(self):
bad_types_file = base_lib.PathParts(
root=self.base_dir, relative_path='BAD/entity_types/bad1.yaml')
fields_universe = field_lib.FieldUniverse([])
fields_universe._namespace_map = {
'': ('dryer_run_status', 'fan_run_command')
}
type_folders = parse.ParseTypeFoldersFromFiles([bad_types_file],
fields_universe)
# should have 1 folder
self.assertLen(type_folders, 1)
type_folder = type_folders[0]
# Should find 4 errors
self.assertLen(type_folder.GetFindings(), 3)
self.assertTrue(
type_folder.HasFindingTypes([findings_lib.DuplicateFieldError]))
self.assertTrue(
type_folder.HasFindingTypes(
[findings_lib.UnrecognizedFieldFormatError]))
self.assertTrue(
type_folder.HasFindingTypes([findings_lib.DuplicateParentError]))
def testAddTypeUndefinedFields(self):
fields_universe = field_lib.FieldUniverse([])
fields_universe._namespace_map = {'': ('animal'), 'ANIMAL': ('meow')}
folderpath = 'ANIMAL/entity_types'
type_folder = entity_type_lib.EntityTypeFolder(folderpath,
fields_universe)
self.assertFalse(type_folder.GetFindings())
rel_typepath = os.path.join(folderpath, 'mammal')
# field 'claws' is undefined.
entity_type = entity_type_lib.EntityType(
filepath=rel_typepath,
typename='cat',
description='feline animal',
local_field_tuples=_FS(['ANIMAL/meow', 'ANIMAL/claws', '/animal']))
type_folder._AddType(entity_type)
self.assertTrue(
type_folder.local_namespace.HasFindingTypes(
[findings_lib.UndefinedFieldError]))
self.assertFalse(type_folder.local_namespace.valid_types_map)
def testFieldUniverseGetFieldMap(self):
meow_cat = field_lib.Field('meow_cat')
claws_cat = field_lib.Field('claws_cat')
global_folder = field_lib.FieldFolder(_GOOD_GLOBAL_PATH)
folder = field_lib.FieldFolder(_GOOD_PATH,
global_folder.local_namespace)
folder.local_namespace.PutIfAbsent(meow_cat)
global_folder.local_namespace.PutIfAbsent(claws_cat)
universe = field_lib.FieldUniverse([folder, global_folder])
local_fields = universe.GetFieldsMap(_GOOD_NAMESPACE)
global_fields = universe.GetFieldsMap('')
all_fields = universe.GetFieldsMap()
expected_local = {_GOOD_NAMESPACE + '/meow_cat': meow_cat}
expected_global = {'/claws_cat': claws_cat}
expected_all = {**expected_local, **expected_global}
self.assertDictEqual(local_fields, expected_local)
self.assertDictEqual(global_fields, expected_global)
self.assertDictEqual(all_fields, expected_all)
def testAnalyzeIgnoresPassthroughTypes(self):
yaml = {'literals': ['field1', 'field2', 'field3', 'field4']}
field_universe = field_lib.FieldUniverse(
[_GetFieldFolder(yaml)])
yaml = {
'parent': {
'description': 'parent',
'uses': ['field1', 'field2', 'field3']
},
'PASSTHROUGH': {
'description': 'PASSTHROUGH',
'allow_undefined_fields': True,
'uses': ['field1', 'field2', 'field3', 'field4']
},
}
type_folder = _GetEntityTypeFolder(
field_universe, yaml)
universe = _GetEntityTypeUniverse([type_folder])
manager = entity_type_manager.EntityTypeManager(universe)
findings = manager.Analyze()
self.assertEmpty(findings)
def testAnalyzeFindsFlexibleParents(self):
yaml = {'literals': ['field1', 'field2', 'field3', 'field4']}
field_universe = field_lib.FieldUniverse(
[_GetFieldFolder(yaml)])
yaml = {
'VAV_parent': {
'description': 'parent',
'is_canonical': True,
'uses': ['field1', 'field4'],
'opt_uses': ['field2', 'field3']
},
'VAV_child1': {
'description': 'child1',
'uses': ['field1', 'field4'],
'opt_uses': ['field2']
},
'VAV_child2': {
'description': 'child2',
'uses': ['field1', 'field3', 'field4']
},
'different_equip_type': {
'description': 'different',
'uses': ['field1', 'field3', 'field4']
},
'VAV_nomatch': {
'description': 'nomatch',
'uses': ['field1', 'field2', 'field3']
},
}
type_folder = _GetEntityTypeFolder(field_universe, yaml)
universe = _GetEntityTypeUniverse([type_folder])
manager = entity_type_manager.EntityTypeManager(universe)
manager.Analyze()
child1 = universe.GetEntityType('', 'VAV_child1')
child2 = universe.GetEntityType('', 'VAV_child2')
child2_nm = universe.GetEntityType('', 'different_equip_type')
parent = universe.GetEntityType('', 'VAV_parent')
nomatch = universe.GetEntityType('', 'VAV_nomatch')
self.assertTrue(parent.HasFindingTypes(
[findings_lib.OverlappingFlexTypeParentWarning]))
self.assertFalse(parent.HasFindingTypes(
[findings_lib.OverlappingFlexTypeChildWarning]))
self.assertTrue(child1.HasFindingTypes(
[findings_lib.OverlappingFlexTypeChildWarning]))
self.assertFalse(child1.HasFindingTypes(
[findings_lib.OverlappingFlexTypeParentWarning]))
self.assertTrue(child2.HasFindingTypes(
[findings_lib.OverlappingFlexTypeChildWarning]))
self.assertFalse(child2.HasFindingTypes(
[findings_lib.OverlappingFlexTypeParentWarning]))
self.assertFalse(child2_nm.HasFindingTypes(
[findings_lib.OverlappingFlexTypeChildWarning,
findings_lib.OverlappingFlexTypeParentWarning]))
self.assertFalse(nomatch.HasFindingTypes(
[findings_lib.OverlappingFlexTypeChildWarning,
findings_lib.OverlappingFlexTypeParentWarning]))
def create_simplified_universe(
) -> presubmit_validate_types_lib.ConfigUniverse:
"""Creates a simplified test universe with minimal configuration for testing.
Returns:
config_universe a partially defined ConfigUniverse
"""
# constant universes
state_universe = states.STATE_UNIVERSE
connection_universe = connections.CONNECTION_UNIVERSE
subfield_universe = subfields.SUBFIELD_UNIVERSE
# update unit folder with subfield_universe
unit_folder = unit_lib.UnitFolder(folderpath='units')
unit_folder.local_namespace.subfields = subfield_universe.GetSubfieldsMap(
unit_folder.local_namespace.namespace)
unit_folder.AddFromConfig(config_filename='units/units.yaml',
documents=[units.UNIT_DOCUMENT])
unit_universe = unit_lib.UnitUniverse(folders=[unit_folder])
# subfield universe has to validate unit universe
subfield_universe.ValidateUnits(unit_universe)
# field universe depends on subfield and state universes
field_folder = field_lib.FieldFolder(folderpath='fields')
field_folder.local_namespace.subfields = subfield_universe.GetSubfieldsMap(
field_folder.local_namespace.namespace)
field_folder.local_namespace.states = state_universe.GetStatesMap(
field_folder.local_namespace.namespace)
field_folder.AddFromConfig(config_filename='fields/telemetry_fields.yaml',
documents=[fields.TELEMETRY_FIELDS_DOCUMENT])
field_folder.AddFromConfig(config_filename='fields/metadata_fields.yaml',
documents=[fields.METADATA_FIELDS_DOCUMENT])
field_universe = field_lib.FieldUniverse(folders=[field_folder])
# entity type universe depends on field universe
global_type_folder = entity_type_lib.EntityTypeFolder(
folderpath='entity_types', field_universe=field_universe)
facilities_type_folder = entity_type_lib.EntityTypeFolder(
folderpath='FACILITIES/entity_types', field_universe=field_universe)
hvac_type_folder = entity_type_lib.EntityTypeFolder(
folderpath='HVAC/entity_types', field_universe=field_universe)
global_type_folder.AddFromConfig(
config_filename='entity_types/global.yaml',
documents=[types.GLOBAL_TYPES_DOCUMENT])
facilities_type_folder.AddFromConfig(
config_filename='FACILITIES/entity_types/Facilities.yaml',
documents=[types.FACILITIES_TYPES_DOCUMENT])
hvac_type_folder.AddFromConfig(
config_filename='HVAC/entity_types/ANALYSIS.yaml',
documents=[types.HVAC_ANALYSIS_TYPES_DOCUMENT])
hvac_type_folder.AddFromConfig(
config_filename='HVAC/entity_types/ABSTRACT.yaml',
documents=[types.HVAC_ABSTRACT_TYPES_DOCUMENT])
hvac_type_folder.AddFromConfig(
config_filename='HVAC/entity_types/CHWS.yaml',
documents=[types.HVAC_CHWS_TYPES_DOCUMENT])
hvac_type_folder.AddFromConfig(
config_filename='HVAC/entity_types/GENERALTYPES.yaml',
documents=[types.HVAC_GENERAL_TYPES_DOCUMENT])
hvac_type_folder.AddFromConfig(
config_filename='HVAC/entity_types/SDC.yaml',
documents=[types.HVAC_SDC_TYPES_DOCUMENT])
hvac_type_folder.AddFromConfig(
config_filename='HVAC/entity_types/DMP.yaml',
documents=[types.HVAC_DMP_TYPES_DOCUMENT])
entity_type_universe = entity_type_lib.EntityTypeUniverse(
entity_type_folders=[
global_type_folder, facilities_type_folder, hvac_type_folder
])
config_universe = presubmit_validate_types_lib.ConfigUniverse(
entity_type_universe=entity_type_universe,
field_universe=field_universe,
subfield_universe=subfield_universe,
state_universe=state_universe,
connection_universe=connection_universe,
unit_universe=unit_universe)
# call this to expand inherited fields
namespace_validator.NamespaceValidator(
config_universe.GetEntityTypeNamespaces())
return config_universe
