def getVersion(extrBcfPath: str, versionSchemaPath: str):
"""
Tries to open `extrBcfPath`/bcf.version. If successful it parses it
into a python dictonary and returns the content of the attribute
`VersionId` of the element `Version`.
If `bcf.version` was not found a ValueError is raised. If `bcf.version`
does not parse against versionSchema then `None` is returned.
"""
logger.debug("Retrieving version from the BCF project")
versionFileName = "bcf.version"
versionFilePath = os.path.join(extrBcfPath, versionFileName)
if not os.path.exists(versionFilePath):
raise ValueError("{} was not found in the extracted zip archive {}."\
"Make sure that you opened a correct bcf zip archive.".format(
versionFileName,
os.path.basename(extrBcfPath)))
versionSchema = XMLSchema(versionSchemaPath)
if not versionSchema.is_valid(versionFilePath):
return None
versionDict = versionSchema.to_dict(versionFilePath)
version = versionDict["@VersionId"]
logger.debug("Version of the BCF project is {}".format(version))
return version
def is_valid(self):
""" Check if XML is valid with XSD file """
if self.xsd_path is not None:
xsd_file = XMLSchema(self.xsd_path)
xml_file = ElementTree.parse(self.get_xml_path())
return xsd_file.is_valid(xml_file)
return False
class EntriesParser:
def __init__(self):
self.db = Database()
self.schema = XMLSchema(f"res{os.sep}schemas{os.sep}plugin_schema.xsd")
def validatePluginSchema(self, instancePath):
xml = open(instancePath, "r").read().strip()
return self.schema.is_valid(xml)
def getPluginFromXml(self, instancePath):
xml = open(instancePath, "r").read().strip()
tree = ET.fromstring(xml)
plugin = PluginItem()
plugin.name = tree[0].text
plugin.description = tree[1].text
plugin.types = ["All"] + [t.text for t in tree[2]]
plugin.outputs = [o.text for o in tree[3]]
for i in range(4, len(tree)):
poi = {}
poi['name'] = tree[i][0].text
poi['type'] = tree[i][1].text
poi['map'] = tree[i][2].text
plugin.pois[tree[i][0].text] = poi
self.db.updateEntry("plugin", plugin.asDictionary())
def updateEntry(self, which, item):
if which == "project":
self.db.updateEntry("project", item.asDictionary())
if which == "plugin":
self.db.updateEntry("plugin", item.asDictionary())
def getEntries(self, which):
if which == "plugin":
entries = {}
for entry in self.db.getEntries('plugin'):
item = PluginItem()
item.id = entry['_id']
item.name = entry['name']
item.description = entry['description']
item.outputs = entry['fields']
item.pois = entry['pois']
item.types = entry['types']
entries[item.name] = item
return entries
if which == "project":
entries = {}
for entry in self.db.getEntries('project'):
item = ProjectItem()
item.id = entry['_id']
item.name = entry['name']
item.description = entry['description']
item.binaryPath = entry['path']
item.binaryProperties = entry['properties']
item.results = entry['results']
entries[item.name] = item
return entries
def deleteEntry(self, which, item):
self.db.deleteEntry(which, item.id)
def parser(self, xml, xsd, pattern=None):
"""
Validate xml to match with xsd. Calling parsers to get Model from xml. If provided pattern, filtering Model.
:param xml: path to MOBILE_API.xml
:param xsd: path to MOBILE_API.xsd
:param pattern: regex-pattern from command-line arguments to filter element from initial Model
:return: initial Model
"""
self.logger.info(
'''Validating XML and generating model with following parameters:
Source xml : %s
Source xsd : %s''', xml, xsd)
try:
schema = XMLSchema(xsd)
if not schema.is_valid(xml):
raise GenerateError(schema.validate(xml))
interface = Parser().parse(xml)
except (InterfaceError, XMLSchemaError, GenerateError) as message1:
self.logger.critical('Invalid XML file content: %s, %s', xml,
message1)
sys.exit(1)
enum_names = tuple(interface.enums.keys())
struct_names = tuple(interface.structs.keys())
if pattern:
intermediate = OrderedDict()
intermediate.update({'params': interface.params})
for kind, content in vars(interface).items():
if kind == 'params':
continue
for name, item in content.items():
if re.match(pattern, item.name):
self.logger.info('%s/%s match with %s', kind,
item.name, pattern)
if kind in intermediate:
intermediate[kind].update({name: item})
else:
intermediate.update({kind: {name: item}})
interface = Interface(**intermediate)
self.logger.debug({
'enums':
tuple(interface.enums.keys()),
'structs':
tuple(interface.structs.keys()),
'functions':
tuple(
map(lambda i: i.function_id.name,
interface.functions.values())),
'params':
interface.params
})
return enum_names, struct_names, interface
def parse(self, filename, xsd=None):
filename = str(filename)
if not xsd:
if not Path(filename).exists():
raise modelParseError('File not found: ' + filename)
replace = filename.replace('.xml', '.xsd')
if Path(replace).exists():
xsd = replace
else:
raise modelParseError('File not found: ' + replace)
try:
schema = XMLSchema(xsd)
if not schema.is_valid(filename):
raise modelParseError('Invalid XML file content:\n' +
schema.validate(filename))
return super(Parser, self).parse(filename)
except xmlParseError as error:
raise modelParseError(error)
def load_xml(schema: XMLSchema, p: Path) -> Dict:
assert schema.is_valid(str(p)), f"invalid xml detected! {p}"
return schema.to_dict(str(p))
