def read_attribute(self, attribute_tag, model_name):
dmtype = ''
arraysize = 2
vodml_element = None
logger.info("Parsing attribute")
#print(etree.dump(attribute_tag))
for attribute_tag_child in attribute_tag.findall('*'):
if attribute_tag_child.tag == "vodml-id":
vodmlid = model_name + ":" + attribute_tag_child.text
elif attribute_tag_child.tag == "name":
name = attribute_tag_child.text
elif attribute_tag_child.tag == "multiplicity":
for multiplicity_tag_child in attribute_tag_child.findall(
'maxOccurs'):
arraysize = int(multiplicity_tag_child.text)
elif attribute_tag_child.tag == "datatype" or attribute_tag_child.tag == 'reference':
for vodml_ref_tag_child in attribute_tag_child.findall(
'vodml-ref'):
dmtype = vodml_ref_tag_child.text
break
if dmtype in self.object_types.keys():
vodml_element = copy.copy(self.object_types[dmtype])
elif dmtype in self.data_types.keys():
vodml_element = copy.copy(self.data_types[dmtype])
retour = VodmlAttribute(vodmlid, dmtype, False, array_size=arraysize)
return retour
def read_object_type(self, model_name, object_type_tag):
attributes = dict()
constraints = VodmlConstraintDict()
superclass = ''
abstract = False
if object_type_tag.get("abstract") == "true":
abstract = True
for object_type_child in object_type_tag.findall('*'):
if object_type_child.tag == "vodml-id":
vodml_type = model_name + ":" + object_type_child.text
logger.info("READING OBJECT TYPE " + vodml_type)
elif object_type_child.tag == "name":
name = object_type_child.text
elif object_type_child.tag == "composition" or object_type_child.tag == "attribute" :
#or multiplicity_tag_child in object_type_child.findall('maxOccurs'):
# array_size = int(multiplicity_tag_child.text)
att = self.read_attribute(object_type_child, model_name)
attributes[att.vodmlid] = att
elif object_type_child.tag == "extends":
for super_type_child in object_type_child.findall('vodml-ref'):
superclass = super_type_child.text
break
elif object_type_child.tag == "reference":
att = self.read_reference(model_name,object_type_child)
attributes[att.vodmlid] = att
elif object_type_child.tag == "constraint":
ct = self.read_constraint(object_type_child)
constraints.add_contraint(ct)
retour = VodmlObjectType(vodml_type, superclass, attributes, constraints, abstract=abstract)
return retour
def __init__(self, vodmlid, name, dmtype, array_size, is_reference):
self.vodmlid = vodmlid
self.name = name
self.dmtype = dmtype
self.array_size = array_size
self.is_reference = is_reference
if dmtype == "":
logger.info(name + " " + vodmlid + " has not dmtype")
def _resolve_constraint(self, vodml_component):
logger.info("_resolve_constraint for " + vodml_component.vodml_type)
for att_type, const in vodml_component.vodml_constraints.items():
if const.is_subset:
logger.info("add subset " + const.__repr__() + " to " + vodml_component.vodml_type)
att = vodml_component.attributes[att_type]
att.vodml_type = const.subset
att.vodml_component = None
def map_object_type(self, object_type):
logger.info("map object " + object_type)
if object_type in self.object_types.keys():
retour = copy.copy(self.object_types[object_type])
elif object_type in self.data_types.keys():
retour = copy.copy(self.data_types[object_type])
self.generate_mapping(retour)
return retour
def _parse_vodml_file(self, filename):
if self.filename.startswith("http://") or self.filename.startswith(
"https://"):
tree = etree.ElementTree(file=urllib.request.urlopen(
filename, context=ssl._create_unverified_context()))
else:
tree = etree.parse(filename)
root = tree.getroot()
model_name = root.find("name").text
logger.info("Reading FILE " + filename + " for model " + model_name)
for node in tree.xpath("*"):
if node.tag == 'package':
self.read_package(model_name, node)
elif node.tag == 'primitiveType' or node.tag == 'enumeration':
dt = self.read_data_type(model_name, node)
logger.info("ADD primitiveType " + dt.vodml_type)
self.primitive_types[dt.vodml_type] = dt
elif node.tag == 'dataType' or node.tag == 'reference':
dt = self.read_data_type(model_name, node)
logger.info("ADD dataType " + dt.vodml_type)
self.data_types[dt.vodml_type] = dt
elif node.tag == 'objectType':
dt = self.read_object_type(model_name, node)
logger.info("ADD objectType " + dt.vodml_type)
self.object_types[dt.vodml_type] = dt
def generate_mapping(self, vodml_root_type):
self.xml_string = ""
logger.info("Generate mapping fotr " + vodml_root_type.vodml_type)
self._append_xml("<MODEL_INSTANCE>")
self._append_xml("<MODELS>")
for k, v in self.imports.items():
self._append_xml("<MODEL>")
self._append_xml("<NAME>" + k + "</NAME>")
self._append_xml("<URL>" + v + "</URL>")
self._append_xml("</MODEL>")
self._append_xml("</MODELS>")
self._append_xml("<GLOBALS>")
self._append_xml("</GLOBALS>")
self._append_xml("<TABLE_MAPPING tableref='Results' >")
self.generate_object_mapping("root", vodml_root_type)
self._append_xml("</TABLE_MAPPING>")
self._append_xml("</MODEL_INSTANCE>")
def generate_mapping(self, vodml_root_type):
self.xml_string = ""
logger.info("Generate mapping fotr " + vodml_root_type.vodml_type)
self._append_xml("<VODML>")
self._append_xml("<MODELS>")
for k,v in self.imports.items():
self._append_xml("<MODEL>")
self._append_xml("<NAME>" + k + "</NAME>")
self._append_xml("<URL>" + v + "</URL>")
self._append_xml("</MODEL>")
self._append_xml("</MODELS>")
self._append_xml("<GLOBALS>")
self._append_xml("</GLOBALS>")
self._append_xml("<TEMPLATES table_ref='Results' >")
self.generate_object_mapping("root", vodml_root_type)
self._append_xml("</TEMPLATES>")
self._append_xml("</VODML>")
def _parse_imports(self, filename):
if filename.startswith("http://") or filename.startswith("https://") :
tree = etree.ElementTree(file=urllib.request.urlopen(filename))
else :
tree = etree.parse(filename)
root = tree.getroot()
name = root.find("name").text
if not name in self.imports.keys():
logger.info(" add file " + name + " " + filename)
self.imports[name]=filename
for node in tree.xpath("import"):
name = node.find('name').text
url = node.find('url').text
if not name in self.imports:
if not name in self.imports.keys():
logger.info(" add file " + name + " " + url)
self.imports[name]=url
def read_data_type(self, model_name, datatype_tag):
vodml_type = ''
name = ''
superclass = ''
ref = ''
attributes = dict()
constraints = VodmlConstraintDict()
abstract = False
if datatype_tag.get("abstract") == "true":
abstract = True
for datatype_tag_child in datatype_tag.findall('*'):
if datatype_tag_child.tag == "vodml-id":
vodml_type = model_name + ":" + datatype_tag_child.text
logger.info("READING DATA TYPE " + vodml_type)
elif datatype_tag_child.tag == "name":
name = datatype_tag_child.text
elif datatype_tag_child.tag == "vodml-ref":
ref = datatype_tag_child.text
elif datatype_tag_child.tag == "attribute" or datatype_tag_child.tag == "reference":
att = self.read_attribute(datatype_tag_child, model_name)
attributes[att.vodmlid] = att
elif datatype_tag_child.tag == "extends":
for super_type_child in datatype_tag_child.findall(
'vodml-ref'):
superclass = super_type_child.text
break
elif datatype_tag_child.tag == "constraint":
ct = self.read_constraint(datatype_tag_child)
constraints.add_contraint(ct)
elif datatype_tag_child.tag == "reference":
att = self.read_reference(model_name, datatype_tag_child)
attributes[att.vodmlid] = att
retour = VodmlDataType(vodml_type,
superclass,
attributes,
constraints,
ref=ref,
abstract=abstract)
return retour
def _resolve_inheritance(self, vodml_component):
logger.info("resolve_inheritance for " + vodml_component.vodml_type)
nb_att0 = len(vodml_component.attributes)
while vodml_component.superclass != '':
sup_obj = None
logger.info(" merge att of " + vodml_component.superclass)
if vodml_component.superclass in self.data_types:
sup_obj = self.data_types[vodml_component.superclass]
elif vodml_component.superclass in self.object_types:
sup_obj = self.object_types[vodml_component.superclass]
elif vodml_component.superclass in self.primitive_types:
sup_obj = self.primitive_types[vodml_component.superclass]
else:
logger.error(vodml_component.superclass +
" Neither in dataType nor in primitive types")
sys.exit()
for k, v in sup_obj.attributes.items():
vodml_component.attributes[k] = v
vodml_component.superclass = sup_obj.superclass
nb_att1 = len(vodml_component.attributes)
if nb_att0 != nb_att1:
logger.info("resolve_inheritance: " + vodml_component.vodml_type +
" " + str(nb_att0) + "->" + str(nb_att1) + " atts")
#for k,v in sup_obj.vodml_constraints.constraints.items():
# print(sup_obj.vodml_constraints.constraints)
# obj.vodml_constraints.merge(v)
superclass = sup_obj.superclass
def read_package(self, model_name, package_node):
if package_node.tag == 'package':
package_name = package_node.find("name").text
logger.info("read_package", "Reading package " + package_name)
for child in package_node.findall('*'):
if child.tag == "objectType":
ot = self.read_object_type(model_name, child)
logger.info("ADD OBJECT " + ot.__repr__())
self.object_types[ot.vodmlid] = ot
elif child.tag == 'primitiveType' or child.tag == 'enumeration':
dt = self.read_data_type(model_name, child)
logger.info("ADD PRIM TYPE " + dt.__repr__())
self.primitive_types[dt.vodmlid] = dt
elif child.tag == "dataType":
ot = self.read_data_type(model_name, child)
logger.info("ADD DATA TYPE " + ot.__repr__())
self.data_types[ot.vodmlid] = ot
elif child.tag == 'package':
self.read_package(model_name, child)
def parse_vodml_files(self):
for model, url in self.imports.items():
logger.info("parse " + model + " " + url)
self._parse_vodml_file(url)
self._resolve_inheritances()
self._resolve_constraints()
