def GenerateGraph(yaml_object, graph):
"""Utility function to populate in the graph yaml concepts.
Populates an RDF graph from the yaml content.
Args:
yaml_object: the yaml content.
graph: the global graph where the ontology is being built in RDF.
Returns:
a graph with the newly built class
"""
# Create the node to add to the Graph
# Construct the classes and the subclasses
graph, multi_state = rdf_helper.CreateClassInGraph(
graph=graph,
class_name='State',
class_description=None,
parent_clazz=rdflib.OWL.Thing,
entity_namespace=constants.STATES_NS)
for clazz, clazz_content in yaml_object.items():
graph, _ = rdf_helper.CreateClassInGraph(
graph=graph,
class_name=clazz.capitalize(),
class_description=clazz_content,
parent_clazz=multi_state[0],
entity_namespace=constants.STATES_NS)
return graph
def GenerateGraph(yaml_object, graph):
"""Utility function to populate in the graph yaml concepts.
Populates an RDF graph from the yaml content.
Args:
yaml_object: the yaml content.
graph: the global graph where the ontology is being built in RDF.
Returns:
a graph with the newly built class
"""
# Create the node to add to the Graph
# Construct the classes and the subclasses
graph, subfield = rdf_helper.CreateClassInGraph(
graph=graph,
class_name='SubField',
class_description=None,
parent_clazz=rdflib.OWL.Thing,
entity_namespace=constants.SUBFIELDS_NS)
for clazz in yaml_object.keys():
graph, clazz_object = rdf_helper.CreateClassInGraph(
graph=graph,
class_name=clazz.capitalize(),
class_description=None,
parent_clazz=subfield[0],
entity_namespace=constants.SUBFIELDS_NS)
clazz_content = yaml_object.get(clazz)
for each_item in clazz_content:
graph, _ = rdf_helper.CreateClassInGraph(
graph=graph,
class_name=each_item.capitalize(),
class_description=clazz_content[each_item],
parent_clazz=clazz_object[0],
entity_namespace=constants.SUBFIELDS_NS)
return graph
def testInstanceHelperNoDescription(self):
graph = rdflib.Graph()
updated_graph, clazz_object = rdf_helper.CreateClassInGraph(
graph=graph,
class_name='class_name',
class_description='description',
parent_clazz=rdflib.OWL.Thing)
updated_graph, instance_object = rdf_helper.CreateInstanceInGraph(
graph=updated_graph,
instance_name='instance_name',
instance_description=None,
parent_clazz=clazz_object)
instance = rdflib.URIRef(
constants.DIGITAL_BUILDINGS_NS['instance_name'])
instance_object_test = (instance, rdflib.RDF.type,
rdflib.OWL.NamedIndividual)
self.assertEqual(instance_object, instance_object_test)
self.assertIn(instance_object_test, updated_graph)
self.assertIn((instance, rdflib.RDF.type, clazz_object[0]),
updated_graph)
self.assertIn(
(instance, rdflib.RDFS.label, rdflib.Literal('instance_name')),
updated_graph)
self.assertNotIn((instance, rdflib.RDFS.comment, rdflib.Literal('')),
updated_graph)
def testCreatesImplementsInGraph(self):
# Prepare data
graph = rdflib.Graph()
implements_list = ['CONTROL', 'MONITORING']
applications_set = set()
graph, application_class = rdf_helper.CreateClassInGraph(
graph=graph,
class_name='Application',
class_description=None,
parent_clazz=rdflib.OWL.Thing)
graph, clazz_object = rdf_helper.CreateClassInGraph(
graph=graph,
class_name='clazz',
class_description='description',
parent_clazz=application_class[0])
graph, applications_set = rdf_helper.CreatesImplementsInGraph(
graph, implements_list, applications_set, application_class,
clazz_object)
# Assertions that the applications_set is updated
self.assertIn('Control', applications_set)
self.assertIn('Monitoring', applications_set)
# Assertions for the class relations creations
self.assertIn(
(application_class[0], rdflib.RDFS.subClassOf, rdflib.OWL.Thing),
graph)
self.assertIn(
(clazz_object[0], rdflib.RDFS.subClassOf, application_class[0]),
graph)
self.assertIn((clazz_object[0], rdflib.RDFS.subClassOf,
constants.DIGITAL_BUILDINGS_NS['Control']), graph)
self.assertIn((clazz_object[0], rdflib.RDFS.subClassOf,
constants.DIGITAL_BUILDINGS_NS['Control']), graph)
self.assertIn((constants.DIGITAL_BUILDINGS_NS['Control'],
rdflib.RDFS.subClassOf, application_class[0]), graph)
self.assertIn((constants.DIGITAL_BUILDINGS_NS['Monitoring'],
rdflib.RDFS.subClassOf, application_class[0]), graph)
def testClassHelperNoDescription(self):
graph = rdflib.Graph()
updated_graph, clazz_object = rdf_helper.CreateClassInGraph(
graph=graph,
class_name='class_name',
class_description=None,
parent_clazz=rdflib.OWL.Thing)
clazz = rdflib.URIRef(constants.DIGITAL_BUILDINGS_NS['class_name'])
clazz_object_test = (clazz, rdflib.RDF.type, rdflib.OWL.Class)
self.assertEqual(clazz_object, clazz_object_test)
self.assertIn(clazz_object_test, updated_graph)
self.assertIn((clazz, rdflib.RDFS.subClassOf, rdflib.OWL.Thing),
updated_graph)
self.assertIn((clazz, rdflib.RDFS.label, rdflib.Literal('class_name')),
updated_graph)
self.assertNotIn((clazz, rdflib.RDFS.comment, rdflib.Literal('')),
updated_graph)
def testAbstractGraphGeneration(self):
fake_abstract = 'fake_resources/Abstract.yaml'
file_contents = rdf_helper.ReadFile(fake_abstract)
yaml_abstract = yaml_handler.ImportYamlFiles(file_contents)
# Create global graph
graph = rdflib.Graph()
# Generate the graph by the function handler
graph = rdflib_function_handler.GenerateGraph(yaml_abstract, graph)
# Build a second graph manually in order to compare it with the one above:
# DD:
# description: "Dual duct flow control (hot deck, cold deck)."
# is_abstract: true
# opt_uses:
# - discharge_air_temperature_sensor
# - run_command
# uses:
# - heating_air_flowrate_sensor
# - heating_air_flowrate_setpoint
# implements:
# - CONTROL
expected_graph = rdflib.Graph()
# Main Types
functionality = rdflib.URIRef(constants.HVAC_NS['Functionality'])
entity_type = rdflib.URIRef(
constants.DIGITAL_BUILDINGS_NS['EntityType'])
dd_description = 'Dual duct flow control (hot deck, cold deck).'
# Main Classes
dd_expected = infixowl.Class(identifier=constants.HVAC_NS['Dd'],
graph=expected_graph,
subClassOf=[functionality])
expected_graph, _ = rdf_helper.CreateClassInGraph(
graph=expected_graph,
class_name='Dd',
class_description=dd_description,
parent_clazz=functionality,
entity_namespace=constants.HVAC_NS)
infixowl.Class(identifier=constants.SUBFIELDS_NS['Point_type'],
graph=expected_graph)
uses_property = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS['uses'],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=expected_graph)
is_composed_of_property = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS['isComposedOf'],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=expected_graph)
uses_property_optionally = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS['usesOptional'],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=expected_graph)
infixowl.Class(identifier=constants.SUBFIELDS_NS['Air'],
graph=expected_graph)
infixowl.Class(identifier=constants.SUBFIELDS_NS['Flowrate'],
graph=expected_graph)
infixowl.Class(identifier=constants.SUBFIELDS_NS['Heating'],
graph=expected_graph)
infixowl.Class(identifier=constants.SUBFIELDS_NS['Run'],
graph=expected_graph)
infixowl.Class(identifier=constants.SUBFIELDS_NS['Command'],
graph=expected_graph)
infixowl.Class(identifier=constants.SUBFIELDS_NS['Discharge'],
graph=expected_graph)
infixowl.Class(identifier=constants.SUBFIELDS_NS['Temperature'],
graph=expected_graph)
infixowl.Class(identifier=constants.SUBFIELDS_NS['Sensor'],
graph=expected_graph)
infixowl.Class(identifier=constants.FIELDS_NS['Field'],
graph=expected_graph)
heating_air_flowrate_sensor = infixowl.Class(
identifier=constants.FIELDS_NS['Heating_air_flowrate_sensor'],
graph=expected_graph,
subClassOf=[constants.FIELDS_NS['Field']])
heating_air_flowrate_setpoint = infixowl.Class(
identifier=constants.FIELDS_NS['Heating_air_flowrate_setpoint'],
graph=expected_graph,
subClassOf=[constants.FIELDS_NS['Field']])
concat = heating_air_flowrate_sensor & heating_air_flowrate_setpoint
dd_expected.subClassOf = [uses_property | infixowl.only | concat]
discharge_air_temperature_sensor = infixowl.Class(
identifier=constants.FIELDS_NS['Discharge_air_temperature_sensor'],
graph=expected_graph,
subClassOf=[constants.FIELDS_NS['Field']])
run_command = infixowl.Class(
identifier=constants.FIELDS_NS['Run_command'],
graph=expected_graph,
subClassOf=[constants.FIELDS_NS['Field']])
concat2 = discharge_air_temperature_sensor | run_command
dd_expected.subClassOf = [
uses_property_optionally | infixowl.some | concat2
]
list_composition = rdf_helper.DecomposeStandardFieldName(
'Discharge_air_temperature_sensor')
expected_graph = rdf_helper.CreatesStandardFieldNameCompositionInGraph(
graph=expected_graph,
list_composition=list_composition,
standard_field_name='Discharge_air_temperature_sensor',
is_composed_of_property=is_composed_of_property)
list_composition = rdf_helper.DecomposeStandardFieldName('Run_command')
expected_graph = rdf_helper.CreatesStandardFieldNameCompositionInGraph(
graph=expected_graph,
list_composition=list_composition,
standard_field_name='Run_command',
is_composed_of_property=is_composed_of_property)
list_composition = rdf_helper.DecomposeStandardFieldName(
'Heating_air_flowrate_sensor')
expected_graph = rdf_helper.CreatesStandardFieldNameCompositionInGraph(
graph=expected_graph,
list_composition=list_composition,
standard_field_name='Heating_air_flowrate_sensor',
is_composed_of_property=is_composed_of_property)
list_composition = rdf_helper.DecomposeStandardFieldName(
'Heating_air_flowrate_setpoint')
expected_graph = rdf_helper.CreatesStandardFieldNameCompositionInGraph(
graph=expected_graph,
list_composition=list_composition,
standard_field_name='Heating_air_flowrate_setpoint',
is_composed_of_property=is_composed_of_property)
expected_graph, functionality_class = rdf_helper.CreateClassInGraph(
graph=expected_graph,
class_name='Functionality',
class_description=None,
parent_clazz=entity_type,
entity_namespace=constants.HVAC_NS)
expected_graph, application = rdf_helper.CreateClassInGraph(
graph=expected_graph,
class_name='Application',
class_description=None,
parent_clazz=entity_type)
expected_graph, control = rdf_helper.CreateClassInGraph(
graph=expected_graph,
class_name='Control',
class_description=None,
parent_clazz=application[0])
expected_graph, _ = rdf_helper.CreateClassInGraph(
graph=expected_graph,
class_name='Dd',
class_description=dd_description,
parent_clazz=functionality_class[0],
entity_namespace=constants.HVAC_NS)
expected_graph, _ = rdf_helper.CreateClassInGraph(
graph=expected_graph,
class_name='Dd',
class_description=dd_description,
parent_clazz=control[0],
entity_namespace=constants.HVAC_NS)
# Check if they are similar
self.assertTrue(compare.similar(graph, expected_graph))
def GenerateGraph(yaml_object, graph, entity_namespace):
"""Utility function updates an RDF graph with the yaml content.
Updates an RDF graph with the yaml content
Args:
yaml_object: the yaml content.
graph: the global graph where the ontology is being built in RDF.
entity_namespace: the namespace to be attributed to the given types
Returns:
a graph with the contents of the yaml file merged
"""
# Ignore entities implementing the following keywords in their definition
ignore_generation_set = {
"DEPRECATED", "INCOMPLETE", "IGNORE", "REMAP_REQUIRED"
}
field = rdflib.URIRef(constants.FIELDS_NS["Field"])
# Prepare properties to be added to the graph and not in the yaml
uses_property = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS["uses"],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=graph)
uses_property_optionally = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS["usesOptional"],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=graph)
is_composed_of_property = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS["isComposedOf"],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=graph)
infixowl.Class(identifier=constants.SUBFIELDS_NS["Point_type"],
graph=graph)
# Traverse the yaml content
for clazz, clazz_content in yaml_object.items():
class_name = clazz.capitalize()
implements = clazz_content.get("implements")
# implements content will decide if the class is added to the graph or not
ignore_class = False
if implements is not None:
for implements_item in implements:
if implements_item in ignore_generation_set:
ignore_class = True
# Generate the class if it does not have implements field
# or no (DEPRECATED or INCOMPLETE)
if ignore_class:
continue
# Create the class
parent = (entity_namespace[implements[0].capitalize()]
if implements is not None else namespace.OWL.Thing)
graph, _ = rdf_helper.CreateClassInGraph(
graph=graph,
class_name=class_name,
class_description=clazz_content.get("description"),
parent_clazz=parent,
entity_namespace=entity_namespace)
# update parents only if implements is not None
if implements is not None:
for implements_item in implements[1:]:
graph.add((entity_namespace[class_name.capitalize()],
rdflib.RDFS.subClassOf,
entity_namespace[implements_item.capitalize()]))
# check the mandatory fields
uses = clazz_content.get("uses")
if uses is not None and isinstance(uses, list):
for each_item in uses:
list_composition = rdf_helper.DecomposeStandardFieldName(
each_item)
graph = rdf_helper.CreatesStandardFieldNameCompositionInGraph(
graph=graph,
list_composition=list_composition,
standard_field_name=each_item,
is_composed_of_property=is_composed_of_property)
class_owl = infixowl.Class(
identifier=entity_namespace[class_name],
graph=graph,
subClassOf=[parent])
graph = rdf_helper.CreateCompositionInGraph(
list_standard_field_names=uses,
composition_operator="&",
composition_property=uses_property,
restriction=infixowl.only,
class_owl=class_owl,
graph=graph,
entity_namespace=constants.FIELDS_NS,
sub_class_of=[field])
# check the optional fields
opt_uses = clazz_content.get("opt_uses")
if opt_uses is not None and isinstance(opt_uses, list):
for each_item in opt_uses:
list_composition = rdf_helper.DecomposeStandardFieldName(
each_item)
graph = rdf_helper.CreatesStandardFieldNameCompositionInGraph(
graph=graph,
list_composition=list_composition,
standard_field_name=each_item,
is_composed_of_property=is_composed_of_property)
class_owl = infixowl.Class(
identifier=entity_namespace[class_name],
graph=graph,
subClassOf=[parent])
graph = rdf_helper.CreateCompositionInGraph(
list_standard_field_names=opt_uses,
composition_operator="|",
composition_property=uses_property_optionally,
restriction=infixowl.some,
class_owl=class_owl,
graph=graph,
entity_namespace=constants.FIELDS_NS,
sub_class_of=[field])
return graph
def GenerateGraph(yaml_object, graph):
"""Utility function updates an RDF graph with the yaml content of the GeneralTypes.yaml.
The content of each object is similar to the following:
CHL:
id: "9950288448474578944"
description: "Tag for chillers."
is_abstract: true
implements:
- EQUIPMENT
opt_uses:
- cooling_thermal_power_capacity
- power_capacity
- efficiency_percentage_specification
- flowrate_requirement
Updates an RDF graph with the yaml content.
Args:
yaml_object: the yaml content.
graph: the global graph where the ontology is being built in RDF.
Returns:
a graph with the contents of the yaml file merged
"""
# Applications Set used to avoid recreating applications again in the graph
applications_set = {"Equipment"}
# Prepare classes to be added to the graph and not in the yaml
equipment = rdflib.URIRef(constants.DIGITAL_BUILDINGS_NS["Equipment"])
entity_type = rdflib.URIRef(constants.DIGITAL_BUILDINGS_NS["EntityType"])
field = rdflib.URIRef(constants.FIELDS_NS["Field"])
infixowl.Class(identifier=constants.FIELDS_NS["Field"], graph=graph)
infixowl.Class(identifier=constants.SUBFIELDS_NS["Point_type"],
graph=graph)
graph, application_class = rdf_helper.CreateClassInGraph(
graph=graph,
class_name="Application",
class_description=None,
parent_clazz=entity_type)
graph, _ = rdf_helper.CreateClassInGraph(graph=graph,
class_name="Equipment",
class_description=None,
parent_clazz=entity_type)
# Prepare properties to be added to the graph and not in the yaml
uses_property = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS["uses"],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=graph)
uses_property_optionally = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS["usesOptional"],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=graph)
is_composed_of_property = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS["isComposedOf"],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=graph)
# Traverse the yaml content
for clazz in yaml_object.keys():
clazz_content = yaml_object.get(clazz)
class_name = clazz.capitalize()
implements = clazz_content.get("implements")
# implements will decide if the entity gets generated in the graph,
# for now the mother class is equipment, this might change in the near
# future due to changes in the ontology, keeping the implementation as it is
if implements is None:
continue
else:
mother_class = equipment
# Create the class
graph, clazz_object = rdf_helper.CreateClassInGraph(
graph=graph,
class_name=class_name,
class_description=clazz_content.get("description"),
parent_clazz=mother_class,
entity_namespace=constants.HVAC_NS)
if implements is not None:
graph, applications_set = rdf_helper.CreatesImplementsInGraph(
graph=graph,
implements_list=implements,
applications_set=applications_set,
application_class=application_class,
class_object=clazz_object)
uses = clazz_content.get("uses")
if uses is not None:
if isinstance(uses, list):
for each_item in uses:
list_composition = rdf_helper.DecomposeStandardFieldName(
each_item)
graph = rdf_helper.CreatesStandardFieldNameCompositionInGraph(
graph=graph,
list_composition=list_composition,
standard_field_name=each_item,
is_composed_of_property=is_composed_of_property)
class_owl = infixowl.Class(
identifier=constants.HVAC_NS[class_name],
graph=graph,
sub_class_of=[equipment])
graph = rdf_helper.CreateCompositionInGraph(
list_standard_field_names=uses,
composition_operator="&",
composition_property=uses_property,
restriction=infixowl.only,
class_owl=class_owl,
graph=graph,
entity_namespace=constants.FIELDS_NS,
sub_class_of=[field])
opt_uses = clazz_content.get("opt_uses")
if opt_uses is not None:
if isinstance(opt_uses, list):
for each_item in opt_uses:
list_composition = rdf_helper.DecomposeStandardFieldName(
each_item)
graph = rdf_helper.CreatesStandardFieldNameCompositionInGraph(
graph=graph,
list_composition=list_composition,
standard_field_name=each_item,
is_composed_of_property=is_composed_of_property)
class_owl = infixowl.Class(
identifier=constants.HVAC_NS[class_name],
graph=graph,
subClassOf=[equipment])
graph = rdf_helper.CreateCompositionInGraph(
list_standard_field_names=opt_uses,
composition_operator="|",
composition_property=uses_property_optionally,
restriction=infixowl.some,
class_owl=class_owl,
graph=graph,
entity_namespace=constants.FIELDS_NS,
sub_class_of=[field])
return graph
def GenerateGraph(yaml_object, graph):
"""Utility function to populate in the graph yaml concepts.
Populates an RDF graph from the yaml content.
The units yaml content is either a string or a dictionary, example below:
- kelvins: STANDARD
- degrees_celsius
- degrees_fahrenheit
Args:
yaml_object: the yaml content.
graph: the global graph where the ontology is being built in RDF.
Returns:
a graph with the newly built class
"""
# Create the node to add to the Graph
unit = rdflib.URIRef(constants.UNITS_NS['Unit'])
graph, _ = rdf_helper.CreateClassInGraph(
graph,
'Unit',
'Class of all units',
rdflib.OWL.Thing,
entity_namespace=constants.UNITS_NS)
graph, standard_unit_data_property_object = rdf_helper.CreateDataPropertyInGraph(
graph,
data_property_name='is_standard_unit',
data_property_description=
'The International System of Units (abbreviated SI from systeme internationale , the French version of the name) is a scientific method of expressing the magnitudes or quantities of important natural phenomena. There are seven base units in the system, from which other units are derived.'
)
# Construct the classes and the subclasses
for clazz in yaml_object.keys():
graph, clazz_object = rdf_helper.CreateClassInGraph(
graph=graph,
class_name=clazz.capitalize(),
class_description=None,
parent_clazz=unit,
entity_namespace=constants.UNITS_NS)
clazz_content = yaml_object.get(clazz)
for each_item in clazz_content:
# When a unit is standard it is a dict, example: kelvins: STANDARD.
if isinstance(each_item, dict):
instance_name = list(each_item.keys())[0]
is_standard = each_item[instance_name]
else:
is_standard = False
instance_name = each_item
# Construct the instances
graph, instance_object = rdf_helper.CreateInstanceInGraph(
graph=graph,
instance_name=instance_name,
instance_description=None,
parent_clazz=clazz_object,
entity_namespace=constants.UNITS_NS)
if is_standard:
graph.add(
(instance_object[0], standard_unit_data_property_object[0],
rdflib.Literal(True)))
else:
graph.add(
(instance_object[0], standard_unit_data_property_object[0],
rdflib.Literal(False)))
return graph
def GenerateGraph(yaml_object, graph):
"""Utility function updates an RDF graph with the yaml content of the Abstract.yaml.
The content of each object is similar to the following:
DXRC:
description: "Compressor run control on return air side (RC)."
opt_uses:
discharge_air_temperature_sensor
leaving_cooling_coil_temperature_sensor
cooling_thermal_power_capacity
uses:
return_air_temperature_setpoint
return_air_temperature_sensor
compressor_run_command
compressor_run_status
implements:
CONTROL
Updates an RDF graph with the yaml content.
Args:
yaml_object: the yaml content.
graph: the global graph where the ontology is being built in RDF.
Returns:
a graph with the contents of the yaml file merged
"""
# Applications Set used to avoid recreating applications again in the graph
applications_set = set()
# Prepare classes to be added to the graph and not in the yaml
functionality = rdflib.URIRef(constants.HVAC_NS["Functionality"])
entity_type = rdflib.URIRef(constants.DIGITAL_BUILDINGS_NS["EntityType"])
field = rdflib.URIRef(constants.FIELDS_NS["Field"])
infixowl.Class(identifier=constants.FIELDS_NS["Field"], graph=graph)
infixowl.Class(identifier=constants.SUBFIELDS_NS["Point_type"],
graph=graph)
graph, _ = rdf_helper.CreateClassInGraph(
graph=graph,
class_name="Functionality",
class_description=None,
parent_clazz=entity_type,
entity_namespace=constants.HVAC_NS)
graph, application_class = rdf_helper.CreateClassInGraph(
graph=graph,
class_name="Application",
class_description=None,
parent_clazz=entity_type)
# Prepare properties to be added to the graph and not in the yaml
uses_property = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS["uses"],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=graph)
uses_property_optionally = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS["usesOptional"],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=graph)
is_composed_of_property = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS["isComposedOf"],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=graph)
# Traverse the yaml content
for clazz, clazz_content in yaml_object.items():
class_name = clazz.capitalize()
graph, clazz_object = rdf_helper.CreateClassInGraph(
graph=graph,
class_name=class_name,
class_description=clazz_content.get("description"),
parent_clazz=functionality,
entity_namespace=constants.HVAC_NS)
implements = clazz_content.get("implements")
if implements is not None:
graph, applications_set = rdf_helper.CreatesImplementsInGraph(
graph=graph,
implements_list=implements,
applications_set=applications_set,
application_class=application_class,
class_object=clazz_object)
uses = clazz_content.get("uses")
if uses is not None:
if isinstance(uses, list):
for each_item in uses:
list_composition = rdf_helper.DecomposeStandardFieldName(
each_item)
graph = rdf_helper.CreatesStandardFieldNameCompositionInGraph(
graph=graph,
list_composition=list_composition,
standard_field_name=each_item,
is_composed_of_property=is_composed_of_property)
class_owl = infixowl.Class(
identifier=constants.HVAC_NS[class_name],
graph=graph,
subClassOf=[functionality])
graph = rdf_helper.CreateCompositionInGraph(
list_standard_field_names=uses,
composition_operator="&",
composition_property=uses_property,
restriction=infixowl.only,
class_owl=class_owl,
graph=graph,
entity_namespace=constants.FIELDS_NS,
sub_class_of=[field])
opt_uses = clazz_content.get("opt_uses")
if opt_uses is not None:
if isinstance(opt_uses, list):
for each_item in opt_uses:
list_composition = rdf_helper.DecomposeStandardFieldName(
each_item)
graph = rdf_helper.CreatesStandardFieldNameCompositionInGraph(
graph=graph,
list_composition=list_composition,
standard_field_name=each_item,
is_composed_of_property=is_composed_of_property)
class_owl = infixowl.Class(
identifier=constants.HVAC_NS[class_name],
graph=graph,
subClassOf=[functionality])
graph = rdf_helper.CreateCompositionInGraph(
list_standard_field_names=opt_uses,
composition_operator="|",
composition_property=uses_property_optionally,
restriction=infixowl.some,
class_owl=class_owl,
graph=graph,
entity_namespace=constants.FIELDS_NS,
sub_class_of=[field])
return graph
def GenerateGraph(yaml_object, graph):
"""Utility function updates an RDF graph with the yaml content.
Updates an RDF graph with the yaml content
Args:
yaml_object: the yaml content.
graph: the global graph where the ontology is being built in RDF.
Returns:
a graph with the contents of the yaml file merged
"""
# Create the node to add to the Graph
physical_location = rdflib.URIRef(
constants.FACILITIES_NS["PhysicalLocation"])
entity_type = rdflib.URIRef(constants.DIGITAL_BUILDINGS_NS["EntityType"])
has_physical_location = rdflib.URIRef(
constants.DIGITAL_BUILDINGS_NS["hasPhysicalLocation"])
has_floor = rdflib.URIRef(constants.DIGITAL_BUILDINGS_NS["hasFloor"])
has_room = rdflib.URIRef(constants.DIGITAL_BUILDINGS_NS["hasRoom"])
has_room_property = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS["hasRoom"],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=graph)
has_floor_property = infixowl.Property(
identifier=constants.DIGITAL_BUILDINGS_NS["hasFloor"],
baseType=infixowl.OWL_NS.ObjectProperty,
graph=graph)
# Add the OWL data to the graph
graph.add((physical_location, rdflib.RDF.type, rdflib.OWL.Class))
graph.add((physical_location, rdflib.RDFS.subClassOf, entity_type))
graph.add((physical_location, rdflib.RDFS.label,
rdflib.Literal("PhysicalLocation")))
graph.add((physical_location, rdflib.RDFS.comment,
rdflib.Literal("The class of all physical locations")))
# Construct the classes and the subclasses
map_name_object = {}
for clazz in yaml_object.keys():
clazz_content = yaml_object.get(clazz)
description = clazz_content.get("description")
clazz_object = rdf_helper.CreateClassInGraph(
graph,
clazz.capitalize(),
description,
physical_location,
entity_namespace=constants.FACILITIES_NS)
map_name_object[clazz.capitalize()] = clazz_object
# Construct the object properties
graph.add(
(has_physical_location, rdflib.RDF.type, rdflib.OWL.ObjectProperty))
graph.add((has_physical_location, rdflib.RDF.type,
rdflib.OWL.TransitiveProperty))
graph.add((has_floor, rdflib.RDF.type, rdflib.OWL.ObjectProperty))
graph.add((has_room, rdflib.RDF.type, rdflib.OWL.ObjectProperty))
# Construct the sub object properties
graph.add((has_floor, rdflib.RDFS.subPropertyOf, has_physical_location))
graph.add((has_room, rdflib.RDFS.subPropertyOf, has_physical_location))
# Link the graph together, done manually until the yaml evolves
class_floor = infixowl.Class(identifier=constants.FACILITIES_NS["Floor"],
graph=graph)
class_room = infixowl.Class(identifier=constants.FACILITIES_NS["Room"],
graph=graph)
class_building = infixowl.Class(
identifier=constants.FACILITIES_NS["Building"], graph=graph)
class_building.subClassOf = [
has_floor_property | infixowl.only | class_floor
]
class_floor.subClassOf = [has_room_property | infixowl.only | class_room]
return graph
