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
def _read_xml(self, filename, xsd):
schema = XMLSchema(os.path.join(cwd, "xsd", xsd))
filepath = os.path.join(self.filepath, filename)
(data, errors) = schema.to_dict(filepath, validation="lax")
for error in errors:
self.logger.error(error)
return data
def buildProject(projectFilePath: str, projectSchema: str):
logger.debug("Building new project object.")
if projectFilePath is None or projectSchema is None:
logger.warning("No file and/or no schema file is given.")
return None
if not os.path.exists(projectFilePath):
logger.error("Path of the project file does not exist"\
" '{}'".format(projectFilePath))
return None
if not os.path.exists(projectSchema):
logger.error("Path of the schema file does not exist"\
" '{}'".format(projectSchema))
return None
schema = XMLSchema(projectSchema)
(projectDict, errors) = schema.to_dict(projectFilePath, validation="lax")
errorList = [str(err) for err in errors]
if len(errorList) > 0:
logger.error(errorList)
# can do that because the project file is valid and ProjectId is required
# by the schema
pId = UUID(projectDict["Project"]["@ProjectId"])
pName = str()
pExtensionSchema = str()
if "Name" in projectDict["Project"]:
pName = projectDict["Project"]["Name"]
if "ExtensionSchema" in projectDict:
pExtensionSchema = projectDict["ExtensionSchema"]
p = Project(pId, pName, pExtensionSchema)
logger.debug("New project object created '{}'".format(p))
return p
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 setUpClass(cls):
cls.schema_class = XMLSchema
cls.xsd_types = XMLSchema.builtin_types()
cls.content_pattern = re.compile(r'(xs:sequence|xs:choice|xs:all)')
cls.default_namespaces = {
'ns': 'ns',
'xsi': 'http://www.w3.org/2001/XMLSchema-instance'
}
cls.vh_dir = cls.abspath('cases/examples/vehicles')
cls.vh_xsd_file = cls.abspath('cases/examples/vehicles/vehicles.xsd')
cls.vh_xml_file = cls.abspath('cases/examples/vehicles/vehicles.xml')
cls.vh_json_file = cls.abspath('cases/examples/vehicles/vehicles.json')
cls.vh_schema = XMLSchema(cls.vh_xsd_file)
cls.vh_namespaces = fetch_namespaces(cls.vh_xml_file)
cls.col_dir = cls.abspath('cases/examples/collection')
cls.col_xsd_file = cls.abspath(
'cases/examples/collection/collection.xsd')
cls.col_xml_file = cls.abspath(
'cases/examples/collection/collection.xml')
cls.col_json_file = cls.abspath(
'cases/examples/collection/collection.json')
cls.col_schema = XMLSchema(cls.col_xsd_file)
cls.col_namespaces = fetch_namespaces(cls.col_xml_file)
cls.st_xsd_file = cls.abspath(
'cases/features/decoder/simple-types.xsd')
cls.st_schema = xmlschema.XMLSchema(cls.st_xsd_file)
cls.models_xsd_file = cls.abspath('cases/features/models/models.xsd')
cls.models_schema = xmlschema.XMLSchema(cls.models_xsd_file)
def test_data_element_converter(self):
col_schema = XMLSchema(self.col_xsd_filename,
converter=DataElementConverter)
obj = col_schema.decode(self.col_xml_filename)
self.assertIsInstance(obj, DataElement)
self.assertEqual(obj.tag, self.col_xml_root.tag)
self.assertEqual(obj.nsmap, self.col_nsmap)
def setUpClass(cls):
cls.test_dir = os.path.dirname(__file__)
cls.xs1 = XMLSchema(
os.path.join(cls.test_dir, "cases/examples/vehicles/vehicles.xsd"))
cls.xs2 = XMLSchema(
os.path.join(cls.test_dir,
"cases/examples/collection/collection.xsd"))
cls.cars = cls.xs1.elements['vehicles'].type.content_type[0]
cls.bikes = cls.xs1.elements['vehicles'].type.content_type[1]
def test_strip_namespace_argument(self):
# Test for issue #161
converter = XMLSchemaConverter(strip_namespaces=True)
col_xsd_filename = self.casepath('examples/collection/collection.xsd')
col_xml_filename = self.casepath('examples/collection/collection.xml')
col_schema = XMLSchema(col_xsd_filename, converter=converter)
self.assertIn('@xmlns:', str(col_schema.decode(col_xml_filename, strip_namespaces=False)))
self.assertNotIn('@xmlns:', str(col_schema.decode(col_xml_filename)))
class LibDocLib(object):
def __init__(self, interpreter=None):
self.interpreter = interpreter
self.schema = XMLSchema(join(ROOT, 'doc', 'schema', 'libdoc.02.xsd'))
@property
def libdoc(self):
return self.interpreter.libdoc
@property
def encoding(self):
return SYSTEM_ENCODING \
if not self.interpreter.is_ironpython else CONSOLE_ENCODING
def run_libdoc(self, args):
cmd = self.libdoc + self._split_args(args)
cmd[-1] = cmd[-1].replace('/', os.sep)
logger.info(' '.join(cmd))
result = run(cmd,
cwd=join(ROOT, 'src'),
stdout=PIPE,
stderr=STDOUT,
encoding=self.encoding,
timeout=120,
universal_newlines=True)
logger.info(result.stdout)
return result.stdout
def _split_args(self, args):
lexer = shlex.shlex(args, posix=True)
lexer.escape = ''
lexer.whitespace_split = True
return list(lexer)
def get_libdoc_model_from_html(self, path):
with open(path, encoding='UTF-8') as html_file:
model_string = self._find_model(html_file)
model = json.loads(model_string.replace('\\x3c/', '</'))
logger.info(pprint.pformat(model))
return model
def _find_model(self, html_file):
for line in html_file:
if line.startswith('libdoc = '):
return line.split('=', 1)[1].strip(' \n;')
raise RuntimeError('No model found from HTML')
def validate_spec(self, path):
self.schema.validate(path)
def relative_source(self, path, start):
if not exists(path):
return path
try:
return relpath(path, start)
except ValueError:
return normpath(path)
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 test_decode_encode_parker_converter(self):
col_schema = XMLSchema(self.col_xsd_filename,
converter=ParkerConverter)
obj1 = col_schema.decode(self.col_xml_filename)
with self.assertRaises(XMLSchemaValidationError) as ec:
col_schema.encode(obj1,
path='./col:collection',
namespaces=self.col_nsmap)
self.assertIn("missing required attribute 'id'", str(ec.exception))
def validate_single_file(file_to_test: ConnectorFile, path_to_file: Path,
xml_violations_buffer: List[str],
properties: ConnectorProperties) -> bool:
"""
Arguments:
file_to_test {ConnectorFile} -- path to a single file to test
path_to_file {Path} -- path to the file
xml_violations_buffer {list[str]} -- a list of strings that holds the xml violation messages
properties {ConnectorProperties} -- an object contating properties that apply to the entire connector
Returns:
bool -- True if the xml file passes validation, false if it does not or there is an error
Any xml violation messages will be appended to xml_violations_buffer
"""
logger.debug("Validating " + str(path_to_file))
if file_to_test.file_type == 'connection-dialog':
properties.uses_tcd = True
xsd_file = get_xsd_file(file_to_test)
if not xsd_file:
xml_violations_buffer.append("Error: No valid XSD for file type:" +
file_to_test.file_type)
return False
manifest_schema = XMLSchema(str(PATH_TO_XSD_FILES / Path(xsd_file)))
# If the file is too big, we shouldn't try and parse it, just log the violation and move on
if path_to_file.stat().st_size > MAX_FILE_SIZE:
xml_violations_buffer.append(file_to_test.file_name +
" exceeds maximum size of " +
str(int(MAX_FILE_SIZE / 1024)) + " KB")
return False
# Try to validate the xml. If the xml validation error is thrown, save the violation information to the buffer
try:
manifest_schema.validate(str(path_to_file))
except Exception:
saved_error_type = sys.exc_info()[0]
saved_error = sys.exc_info()[1]
xml_violations_buffer.append("File: " + file_to_test.file_name +
" Error Type: " + str(saved_error_type) +
"\n" + str(saved_error))
logger.error("XML Validation failed for " + file_to_test.file_name)
return False
if not validate_file_specific_rules(file_to_test, path_to_file,
xml_violations_buffer, properties):
logger.error("XML Validation failed for " + file_to_test.file_name)
return False
return True
def test_decode_encode_unordered_converter_with_preserve_root(self):
col_schema = XMLSchema(self.col_xsd_filename,
converter=UnorderedConverter)
# Decode from XML file
obj1 = col_schema.decode(self.col_xml_filename, preserve_root=True)
self.assertIn("'col:collection'", repr(obj1))
self.assertIn("'@xmlns:col'", repr(obj1))
root = col_schema.encode(obj1,
path='./col:collection',
namespaces=self.col_nsmap,
preserve_root=True)
self.assertIsNone(
etree_elements_assert_equal(self.col_xml_root, root, strict=False))
root = col_schema.encode(obj1, preserve_root=True)
self.assertIsNone(
etree_elements_assert_equal(self.col_xml_root, root, strict=False))
# Decode from lxml.etree.Element tree
obj2 = col_schema.decode(self.col_lxml_root, preserve_root=True)
self.assertIn("'col:collection'", repr(obj2))
self.assertIn("'@xmlns:col'", repr(obj2))
self.assertEqual(obj1, obj2)
# Decode from ElementTree.Element tree providing namespaces
obj2 = col_schema.decode(self.col_xml_root,
namespaces=self.col_nsmap,
preserve_root=True)
self.assertIn("'col:collection'", repr(obj2))
self.assertIn("'@xmlns:col'", repr(obj2))
self.assertEqual(obj1, obj2)
# Decode from ElementTree.Element tree without namespaces
obj2 = col_schema.decode(self.col_xml_root, preserve_root=True)
self.assertNotIn("'col:collection'", repr(obj2))
self.assertNotIn("'@xmlns:col'", repr(obj2))
self.assertNotEqual(obj1, obj2)
root = col_schema.encode(obj2,
path='./col:collection',
namespaces=self.col_nsmap,
preserve_root=True)
self.assertIsNone(
etree_elements_assert_equal(self.col_xml_root, root, strict=False))
root = col_schema.encode(
obj2, preserve_root=True) # No namespace unmap is required
self.assertIsNone(
etree_elements_assert_equal(self.col_xml_root, root, strict=False))
def test_exception_repr(self):
xs = XMLSchema(
os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xsd'))
error = XMLSchemaValidatorError(xs, 'unknown error')
self.assertEqual(str(error), 'unknown error')
self.assertEqual(error.msg, 'unknown error')
error = XMLSchemaValidatorError(xs, 'unknown error', elem=xs.root)
lines = str(error).split('\n')
self.assertEqual(lines[0], 'unknown error:')
self.assertEqual(lines[2], 'Schema:')
self.assertTrue(lines[4].strip().startswith('<xs:schema '))
self.assertEqual(lines[-2].strip(), '</xs:schema>')
schema = XMLSchema("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root" type="xs:integer"/>
</xs:schema>""")
root = lxml.etree.XML('<root a="10"/>')
with self.assertRaises(XMLSchemaValidationError) as ctx:
schema.validate(root)
lines = str(ctx.exception).split('\n')
self.assertEqual(
lines[0],
"failed validating {'a': '10'} with XsdAttributeGroup():")
self.assertEqual(lines[2],
"Reason: 'a' attribute not allowed for element.")
self.assertEqual(lines[8], "Instance (line 1):")
self.assertEqual(lines[12], "Path: /root")
self.assertEqual(
repr(ctx.exception), "XMLSchemaValidationError(reason=\"'a' "
"attribute not allowed for element.\")")
error = XMLSchemaValidationError(schema.elements['root'], root)
self.assertIsNone(error.reason)
self.assertNotIn("Reason:", str(error))
self.assertIn("Schema:", str(error))
error = XMLSchemaValidationError(schema, root)
self.assertNotIn("Reason:", str(error))
self.assertNotIn("Schema:", str(error))
error = XMLSchemaValidationError(schema, 10)
self.assertEqual(
str(error), "failed validating 10 with XMLSchema10(namespace='')")
def test_columnar_converter(self):
col_schema = XMLSchema(self.col_xsd_filename,
converter=ColumnarConverter)
obj = col_schema.decode(self.col_xml_filename)
self.assertIn("'authorid'", str(obj))
self.assertNotIn("'author_id'", str(obj))
self.assertNotIn("'author__id'", str(obj))
obj = col_schema.decode(self.col_xml_filename, attr_prefix='_')
self.assertNotIn("'authorid'", str(obj))
self.assertIn("'author_id'", str(obj))
self.assertNotIn("'author__id'", str(obj))
obj = col_schema.decode(self.col_xml_filename, attr_prefix='__')
self.assertNotIn("'authorid'", str(obj))
self.assertNotIn("'author_id'", str(obj))
self.assertIn("'author__id'", str(obj))
col_schema = XMLSchema(self.col_xsd_filename)
obj = col_schema.decode(self.col_xml_filename,
converter=ColumnarConverter,
attr_prefix='__')
self.assertNotIn("'authorid'", str(obj))
self.assertNotIn("'author_id'", str(obj))
self.assertIn("'author__id'", str(obj))
def test_parquet_converter(self):
col_xsd_filename = self.casepath('examples/collection/collection.xsd')
col_xml_filename = self.casepath('examples/collection/collection.xml')
col_schema = XMLSchema(col_xsd_filename, converter=ColumnarConverter)
obj = col_schema.decode(col_xml_filename)
self.assertIn("'authorid'", str(obj))
self.assertNotIn("'author_id'", str(obj))
self.assertNotIn("'author__id'", str(obj))
obj = col_schema.decode(col_xml_filename, attr_prefix='_')
self.assertNotIn("'authorid'", str(obj))
self.assertIn("'author_id'", str(obj))
self.assertNotIn("'author__id'", str(obj))
obj = col_schema.decode(col_xml_filename, attr_prefix='__')
self.assertNotIn("'authorid'", str(obj))
self.assertNotIn("'author_id'", str(obj))
self.assertIn("'author__id'", str(obj))
col_schema = XMLSchema(col_xsd_filename)
obj = col_schema.decode(col_xml_filename,
converter=ColumnarConverter,
attr_prefix='__')
self.assertNotIn("'authorid'", str(obj))
self.assertNotIn("'author_id'", str(obj))
self.assertIn("'author__id'", str(obj))
def buildViewpoint(viewpointFilePath: str, viewpointSchemaPath: str):
logger.debug("Building new Viewpoint object")
vpSchema = XMLSchema(viewpointSchemaPath)
vpSchema = modifyVisinfoSchema(vpSchema)
(vpDict, errors) = vpSchema.to_dict(viewpointFilePath, validation="lax")
errorList = [str(err) for err in errors]
if len(errorList) > 0:
logger.error(errorList)
id = UUID(vpDict["@Guid"])
componentsDict = getOptionalFromDict(vpDict, "Components", None)
components = None
if componentsDict:
components = buildComponents(componentsDict)
oCamDict = getOptionalFromDict(vpDict, "OrthogonalCamera", None)
oCam = None
if oCamDict:
oCam = buildOrthogonalCamera(oCamDict)
pCamDict = getOptionalFromDict(vpDict, "PerspectiveCamera", None)
pCam = None
if pCamDict:
pCam = buildPerspectiveCamera(pCamDict)
linesDict = getOptionalFromDict(vpDict, "Lines", None)
lines = list()
if linesDict:
linesList = getOptionalFromDict(linesDict, "Line", list())
lines = [buildLine(line) for line in linesList]
clippingPlaneDict = getOptionalFromDict(vpDict, "ClippingPlanes", None)
clippingPlanes = list()
if clippingPlaneDict:
clippingPlaneList = getOptionalFromDict(clippingPlaneDict,
"ClippingPlane", list())
clippingPlanes = [
buildClippingPlane(clipDict) for clipDict in clippingPlaneList
]
bitmapList = getOptionalFromDict(vpDict, "Bitmap", list())
bitmaps = [buildBitmap(bmDict) for bmDict in bitmapList]
viewpoint = Viewpoint(id, components, oCam, pCam, lines, clippingPlanes,
bitmaps)
logger.debug("New Viewpoint object created")
return viewpoint
def test_document_init(self):
with self.assertRaises(XmlDocumentError) as context:
XmlDocument()
self.assertEqual(str(context.exception),
"missing schema for XML data!")
schema = os.path.join(self.schemas_dir, 'qes.xsd')
with self.assertRaises(XmlDocumentError) as context:
XmlDocument(schema)
self.assertEqual(str(context.exception), "source is an XSD schema")
document = XmlDocument(schema=schema)
self.assertIsInstance(document, XmlDocument)
self.assertIsNone(document.root)
self.assertIsNone(document.filename)
self.assertIsNone(document.format)
self.assertIsInstance(document.schema, XMLSchema)
if platform.system() == 'Linux':
self.assertTrue(document.schema.url.endswith(schema))
else:
self.assertTrue(
document.schema.url.endswith('qeschema/schemas/qes.xsd'))
document = XmlDocument(schema=XMLSchema(schema))
self.assertIsInstance(document.schema, XMLSchema)
if platform.system() == 'Linux':
self.assertTrue(document.schema.url.endswith(schema))
else:
self.assertTrue(
document.schema.url.endswith('qeschema/schemas/qes.xsd'))
def test_document_init(self):
schema = os.path.join(self.schemas_dir, 'qes.xsd')
document = XmlDocument(schema)
self.assertIsInstance(document, XmlDocument)
self.assertIsNone(document.root)
self.assertIsNone(document.filename)
self.assertIsNone(document.format)
self.assertTrue(document.schema.url.endswith(schema))
self.assertIsInstance(document.schema, XMLSchema)
document = XmlDocument(schema=XMLSchema(schema))
self.assertTrue(document.schema.url.endswith(schema))
self.assertIsInstance(document.schema, XMLSchema)
self.assertIsInstance(PwDocument(), PwDocument)
self.assertIsInstance(PwDocument(schema=schema), PwDocument)
schema = os.path.join(self.schemas_dir, 'ph_temp.xsd')
self.assertIsInstance(PhononDocument(), PhononDocument)
self.assertIsInstance(PhononDocument(schema=schema), PhononDocument)
schema = os.path.join(self.schemas_dir, 'qes_neb.xsd')
self.assertIsInstance(NebDocument(), NebDocument)
self.assertIsInstance(NebDocument(schema=schema), NebDocument)
schema = os.path.join(self.schemas_dir, 'tddfpt.xsd')
self.assertIsInstance(TdDocument(), TdDocument)
self.assertIsInstance(TdDocument(schema=schema), TdDocument)
schema = os.path.join(self.schemas_dir, 'qes_spectrum.xsd')
self.assertIsInstance(TdSpectrumDocument(), TdSpectrumDocument)
self.assertIsInstance(TdSpectrumDocument(schema=schema),
TdSpectrumDocument)
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)
class TestResources(XMLSchemaTestCase):
xs1 = XMLSchema("examples/vehicles/vehicles.xsd")
xs2 = XMLSchema("examples/collection/collection.xsd")
cars = xs1.elements['vehicles'].type.content_type[0]
bikes = xs1.elements['vehicles'].type.content_type[1]
def test_absolute_path(self):
url1 = "https://example.com/xsd/other_schema.xsd"
self.assertTrue(
normalize_url(url1, base_url="/path_my_schema/schema.xsd") == url1)
def test_fetch_resource(self):
self.assertRaises(XMLSchemaURLError, fetch_resource,
'examples/resources/issue017.txt')
self.assertTrue(
fetch_resource('examples/resources/issue 017.txt').endswith(
'e%20017.txt'))
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 test_cdata_mapping(self):
schema = XMLSchema("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root">
<xs:complexType mixed="true">
<xs:sequence>
<xs:element name="node" type="xs:string" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
""")
self.assertEqual(
schema.decode('<root>1<node/>2<node/>3</root>'), {'node': [None, None]}
)
self.assertEqual(
schema.decode('<root>1<node/>2<node/>3</root>', cdata_prefix='#'),
{'#1': '1', 'node': [None, None], '#2': '2', '#3': '3'}
)
def __init__(self, filename: str, umlFrame: UmlClassDiagramsFrame):
self.logger: Logger = getLogger(__name__)
self._umlFrame: UmlClassDiagramsFrame = umlFrame
self.schema: XMLSchema = XMLSchema(filename)
self.position: Tuple[int, int] = self._positionGenerator()
self._schemaTypeNames: List[str] = []
self.classTree: Dict[str, ElementTreeData] = {}
def setUpClass(cls):
cls.col_xsd_filename = cls.casepath(
'examples/collection/collection.xsd')
cls.col_xml_filename = cls.casepath(
'examples/collection/collection.xml')
cls.col_xml_root = ElementTree.parse(cls.col_xml_filename).getroot()
cls.col_lxml_root = lxml_etree.parse(cls.col_xml_filename).getroot()
cls.col_nsmap = fetch_namespaces(cls.col_xml_filename)
cls.col_namespace = cls.col_nsmap['col']
cls.col_schema = XMLSchema(cls.col_xsd_filename,
converter=cls.converter)
def test_exception_init(self):
xs = XMLSchema(os.path.join(CASES_DIR, 'examples/vehicles/vehicles.xsd'))
with self.assertRaises(ValueError) as ctx:
XMLSchemaValidatorError(xs, 'unknown error', elem='wrong')
self.assertIn("'elem' attribute requires an Element", str(ctx.exception))
error = XMLSchemaNotBuiltError(xs, 'schema not built!')
self.assertEqual(error.message, 'schema not built!')
schema = XMLSchema("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:group name="group1">
<xs:choice>
<xs:element name="root" type="xs:integer"/>
</xs:choice>
</xs:group>
</xs:schema>""")
error = XMLSchemaModelDepthError(schema.groups['group1'])
self.assertEqual("maximum model recursion depth exceeded", error.message[:38])
def validateFile(validateFilePath: str, schemaPath: str, bcfFile: str):
""" Validates `validateFileName` against the XSD file referenced by
`schemaPath`.
If successful an empty string is returned, else an error string is
returned.
"""
logger.debug("Validating file {} against {}".format(
validateFilePath, schemaPath))
schema = XMLSchema(schemaPath)
try:
schema.validate(validateFilePath)
except Exception as e:
# get parent directory of file, useful for the user if the file is a
# markup.bcf file inside some topic
parentDir = os.path.abspath(os.path.join(validateFilePath, os.pardir))
return "{} file inside {} of {} could not be validated against"\
" {}\nError:{}".format(validateFilePath, parentDir, bcfFile,
os.path.basename(schemaPath), str(e))
return ""
def create_app() -> 'Flask':
"""
Create application
:return: flask application object
"""
app = Flask(__name__)
app.config.from_object(environ.get('VOICE_CONFIG', 'config.ProductionConfig'))
db.init_app(app)
tasks.init_app(app)
app.register_blueprint(api.bp)
setattr(api.bp, 'entity_schema', XMLSchema(app.config['ENTITY_XSD']))
return app
def validate_file(path: Path, schema: xmlschema.XMLSchema,
validators: List[ScenarioValidator]):
scenarios = []
paths = []
if path.suffix == ".xosc":
paths.append(path)
scenarios.append(schema.to_dict(str(path)))
else:
output = Path("/tmp").joinpath("xosc")
for converted_path in convert(path, output, verbose=False):
paths.append(converted_path)
scenarios.append(schema.to_dict(str(converted_path)))
for scenario, path in zip(scenarios, paths):
overall_result = True
try:
for validator in validators:
if not validator(scenario):
overall_result = False
except:
overall_result = False
print(str(path) + " : " + str(overall_result))
def buildMarkup(markupFilePath: str, markupSchemaPath: str):
logger.debug("Building new Markup object")
markupSchema = XMLSchema(markupSchemaPath)
(markupDict, errors) = markupSchema.to_dict(markupFilePath,
validation="lax")
errorList = [str(err) for err in errors]
if len(errorList) > 0:
logger.error(errorList)
commentList = getOptionalFromDict(markupDict, "Comment", list())
comments = [buildComment(comment) for comment in commentList]
topicDict = markupDict["Topic"]
topic = buildTopic(topicDict)
headerDict = getOptionalFromDict(markupDict, "Header", None)
header = None
# there may be instances that define an empty header element
if headerDict and len(headerDict) > 0:
header = buildHeader(headerDict)
viewpointList = getOptionalFromDict(markupDict, "Viewpoints", list())
viewpoints = [buildViewpointReference(vpDict) for vpDict in viewpointList]
markupDir = os.path.abspath(os.path.dirname(markupFilePath))
snapshotList = buildSnapshotList(markupDir)
markup = Markup(topic, header, comments, viewpoints, snapshotList)
# Add the right viewpoint references to each comment
for comment in comments:
if comment.viewpoint:
cViewpointRefGuid = comment.viewpoint.xmlId
viewpointRef = markup.getViewpointRefByGuid(cViewpointRefGuid)
comment.viewpoint = viewpointRef
logger.debug("New Markup object created")
return markup
