def _get_xml(self, path):
try:
return self.open_xml_file(path)
except IOError:
raise IOError("Cannot find {}".format(path))
except ExpatError as ex:
raise ExpatError("{} is invalid xml '{}'".format(path, ex))
def _render_xml(self, xml_document, **kwargs):
# Prepare the xml object to be processed by jinja2
self.log.debug('Rendering XML object')
template_string = ""
try:
self.template_images = dict()
self._prepare_document_tags(xml_document)
xml_source = xml_document.toxml()
xml_source = xml_source.encode('ascii', 'xmlcharrefreplace')
jinja_template = self.environment.from_string(
self._unescape_entities(xml_source.decode('utf-8'))
)
result = jinja_template.render(**kwargs)
result = self._encode_escape_chars(result)
final_xml = parseString(result.encode('ascii', 'xmlcharrefreplace'))
if self.template_images:
self.replace_images(final_xml)
return final_xml
except ExpatError as e:
near = result.split('\n')[e.lineno -1][e.offset-200:e.offset+200]
raise ExpatError('ExpatError "%s" at line %d, column %d\nNear of: "[...]%s[...]"' % \
(ErrorString(e.code), e.lineno, e.offset, near))
except:
self.log.error('Error rendering template:\n%s',
xml_document.toprettyxml(), exc_info=True)
self.log.error('Unescaped template was:\n{0}'.format(template_string))
raise
finally:
self.log.debug('Rendering xml object finished')
def _get_metadata(metadata, element, tag):
values = []
try:
metadatadom = minidom.parse(metadata)
except ExpatError as e:
raise ExpatError("%s: %s" % (
metadata,
e,
))
try:
elements = metadatadom.getElementsByTagName(element)
if not elements:
return values
except NotFoundErr:
return values
try:
for _element in elements:
node = _element.getElementsByTagName(tag)
try:
values.append(node[0].childNodes[0].data)
except IndexError:
pass
except NotFoundErr:
raise NotFoundErr("%s: Malformed input: missing 'flag' tag(s)" %
(metadata))
metadatadom.unlink()
return values
def testLoad(self):
""" Tests the initialization of the data store handler. """
self._fileStorerMock.methodNameResultMap = {"exists": (True, None), "readData": (SimpleMock(""), None)}
self._parseStringMock.value = datastores.datastores([datastores.default(name="name1", storeType=constants.DEFAULT_STORE),
datastores.default(name="name2", storeType=constants.DEFAULT_STORE)])
self._datastoreHandler.load()
self.assertEquals(len(self._datastoreHandler.datastores), 2)
self._fileStorerMock.methodNameResultMap = {"exists": (False, None)}
self.assertRaises(ConfigurationError, self._datastoreHandler.load)
self._fileStorerMock.methodNameResultMap = {"exists": (None, PersistenceError(""))}
self.assertRaises(ConfigurationError, self._datastoreHandler.load)
self._fileStorerMock.methodNameResultMap = {"exists": (True, None), "readData": (None, PersistenceError(""))}
self.assertRaises(ConfigurationError, self._datastoreHandler.load)
self._fileStorerMock.methodNameResultMap = {"exists": (True, None), "readData": (SimpleMock(""), None)}
self._parseStringMock.error = ExpatError("")
self.assertRaises(ConfigurationError, self._datastoreHandler.load)
self._fileStorerMock.methodNameResultMap = {"exists": (True, None), "readData": (SimpleMock(""), None)}
self._parseStringMock.error = ValueError("")
self.assertRaises(ConfigurationError, self._datastoreHandler.load)
def wrapper(*args, **kwargs):
rtc_obj = args[0].get_rtc_obj()
if not hasattr(rtc_obj, "headers") or rtc_obj.headers is None:
# still in the initialization or relogin
# directly call the method
return func(*args, **kwargs)
else:
# check whether token expires
try:
resp = func(*args, **kwargs)
xmltodict.parse(resp.content)
return resp
except ExpatError as excp:
if "invalid token" in str(excp):
# expires
try:
rtc_obj.relogin()
except RTCException:
raise RTCException("Relogin Failed: "
"Invalid username or password")
kwargs["headers"]["Cookie"] = rtc_obj.headers["Cookie"]
return func(*args, **kwargs)
else:
# not expires
# raise the actual exception
raise ExpatError(excp)
def _get_metadata(metadata, element, tag):
values = []
try:
metadatadom = minidom.parse(metadata)
except ExpatError as e:
raise ExpatError("%s: %s" % (metadata, e,))
try:
elements = metadatadom.getElementsByTagName(element)
if not elements:
return values
except NotFoundErr:
return values
try:
for _element in elements:
node = _element.getElementsByTagName(tag)
if tag == "herd" and (not node or not node[0].childNodes):
# print >> stderr, "'%s' is missing a <herd> tag or it is empty," % metadata
# print >> stderr, "please file a bug at https://bugs.gentoo.org and refer to http://www.gentoo.org/proj/en/devrel/handbook/handbook.xml?part=2&chap=4"
values.append("no-herd")
continue
try:
values.append(node[0].childNodes[0].data)
except IndexError:
pass
except NotFoundErr:
raise NotFoundErr("%s: Malformed input: missing 'flag' tag(s)" % (metadata))
metadatadom.unlink()
return values
def get_response(self, url, payload):
self.headers['Content-Length'] = str(len(payload))
status_code = 0
i = 0
while status_code != 200 and i < 10:
response = requests.post(url, data=payload, headers=self.headers)
status_code = response.status_code
i += 1
if i >= 10 and status_code != 200:
raise TimeoutError(
'Aparentemente o webservice dos Correios está indisponível no momento'
'Tente novamente mais tarde.')
try:
response = xmltodict.parse(
response.text)['cResultado']['Servicos']['cServico']
return response
except KeyError:
response = xmltodict.parse(
response.text
)['cResultadoServicos']['ServicosCalculo']['cServicosCalculo']
return response
except ExpatError:
raise ExpatError(
'Não foi possível parsear o XML de resposta do webservice dos Correios'
)
def _importBody(self, body):
"""Import the object from the file body.
"""
try:
dom = parseString(body)
except ExpatError, e:
filename = (self.filename
or '/'.join(self.context.getPhysicalPath()))
raise ExpatError('%s: %s' % (filename, e))
def test_GIVEN_invalid_xml_WHEN_adding_ioc_THEN_error(self):
error_str = "No configs Exist"
self.file_access.open_xml_file = Mock(side_effect=ExpatError(error_str))
adder = AddToBaseIOCs(None, None, None)
result = adder.perform(self.file_access, self.logger)
assert_that(result, is_(-1), "result")
assert_that(self.logger.log_err, has_item("IOC file appears not be valid XML, error '{}'".format(error_str)))
def xml_to_json(body):
try:
dict = xmltodict.parse(body)
except ExpatError as e:
# Something went wrong--probably malformed XML. Pass the
# error back up to the caller.
raise ExpatError('Malformed XML - ' + str(e))
# TODO: Error handling here? Can this go wrong?
return json.dumps(dict[DATA_ELEMENT])
def __call__(self):
full_path = os.path.join(self._path, METADATA_XML)
if not os.path.exists(full_path):
return {}
with open(full_path, 'r') as fp:
try:
return self.parseXML(fp.read())
except ExpatError as e:
raise ExpatError('%s: %s' % (full_path, e))
def xml_pickler(json_conf, filename, default_header,
cache=None,
max_target_seqs=10):
valid, _, exc = BlastOpener(filename).sniff(default_header=default_header)
engine = connect(json_conf, strategy="threadlocal")
session = Session(bind=engine)
if not valid:
err = "Invalid BLAST file: %s" % filename
raise TypeError(err)
dbname, conn, cursor = _create_xml_db(filename)
if not isinstance(cache, dict) or set(cache.keys()) != {"query", "target"}:
cache = dict()
cache["query"] = dict((item.query_name, item.query_id) for item in session.query(Query))
cache["target"] = dict((item.target_name, item.target_id) for item in session.query(Target))
try:
with BlastOpener(filename) as opened:
try:
qmult, tmult = None, None
for query_counter, record in enumerate(opened, start=1):
if qmult is None:
qmult, tmult = get_multipliers(record)
off_by_one = get_off_by_one(record)
hits, hsps, cache = objectify_record(
record, [], [], cache, max_target_seqs=max_target_seqs,
qmult=qmult, tmult=tmult, off_by_one=off_by_one)
try:
jhits = json.dumps(hits, number_mode=json.NM_NATIVE)
jhsps = json.dumps(hsps, number_mode=json.NM_NATIVE)
except ValueError:
jhits = json.dumps(hits)
jhsps = json.dumps(hsps)
cursor.execute("INSERT INTO dump VALUES (?, ?, ?)",
(query_counter,
jhits,
jhsps))
except ExpatError as err:
raise ExpatError("{} is an invalid BLAST file, sending back anything salvageable.\n{}".format(filename,
err))
except xml.etree.ElementTree.ParseError as err:
# logger.error("%s is an invalid BLAST file, sending back anything salvageable", filename)
raise xml.etree.ElementTree.ParseError(
"{} is an invalid BLAST file, sending back anything salvageable.\n{}".format(filename, err))
except ValueError as err:
# logger.error("Invalid BLAST entry")
raise ValueError(
"{} is an invalid BLAST file, sending back anything salvageable.\n{}".format(filename, err))
cursor.close()
conn.commit()
conn.close()
return dbname
def _context(self):
self.p = ParserCreate(namespace_separator='}')
self.p.StartElementHandler = self._start_element
self.p.EndElementHandler = self._end_element
self.p.CharacterDataHandler = self._char_data
self._ancestors = []
self._root = None
try:
yield
except ExpatError as err:
e = ExpatError(ErrorString(err.code))
e.lineno = err.lineno
e.offset = err.offset
e.filename = self.filename
raise e
except ValueError as err:
err.lineno = self.p.CurrentLineNumber
err.offset = self.p.CurrentColumnNumber
err.filename = self.filename
raise err
except self.Exit:
pass
def test_parse_when_minidom_fails_without_apk_path(self, mock_file,
mock_file_parser,
mock_minidom):
file = any_file(filename="AndroidManifest.xml")
mock_parser_instance = any_file_parser(file=file)
mock_file_parser.return_value = mock_parser_instance
mock_minidom.parse.side_effect = ExpatError()
with self.assertRaises(AndroidManifestParsingError):
self.sut.parse(filepath="any-file-path",
binary=False,
apk_path=None,
extended_processing=False)
def _context(self):
self.p = ParserCreate(namespace_separator='}')
self.p.StartElementHandler = self._start_element
self.p.EndElementHandler = self._end_element
self.p.CharacterDataHandler = self._char_data
self._ancestors = []
self._root = None
try:
yield
except ExpatError as err:
e = ExpatError(ErrorString(err.code))
e.lineno = err.lineno
e.offset = err.offset
e.filename = self.filename
raise e
except ValueError as err:
err.lineno = self.p.CurrentLineNumber
err.offset = self.p.CurrentColumnNumber
err.filename = self.filename
raise err
except self.Exit:
pass
def xml_pickler(json_conf, filename, default_header, max_target_seqs=10):
valid, _, exc = BlastOpener(filename).sniff(default_header=default_header)
engine = connect(json_conf, strategy="threadlocal")
session = Session(bind=engine)
if not valid:
err = "Invalid BLAST file: %s" % filename
raise TypeError(err)
dbname, conn, cursor = _create_xml_db(filename)
cache = {"query": dict(), "target": dict()}
try:
with BlastOpener(filename) as opened:
try:
for query_counter, record in enumerate(opened, start=1):
hits, hsps, cache = objectify_record(
session,
record, [], [],
cache,
max_target_seqs=max_target_seqs)
try:
jhits = json.dumps(hits, number_mode=json.NM_NATIVE)
jhsps = json.dumps(hsps, number_mode=json.NM_NATIVE)
except ValueError:
jhits = json.dumps(hits)
jhsps = json.dumps(hsps)
cursor.execute("INSERT INTO dump VALUES (?, ?, ?)",
(query_counter, jhits, jhsps))
except ExpatError as err:
# logger.error("%s is an invalid BLAST file, sending back anything salvageable", filename)
raise ExpatError(
"{} is an invalid BLAST file, sending back anything salvageable.\n{}"
.format(filename, err))
except xml.etree.ElementTree.ParseError as err:
# logger.error("%s is an invalid BLAST file, sending back anything salvageable", filename)
raise xml.etree.ElementTree.ParseError(
"{} is an invalid BLAST file, sending back anything salvageable.\n{}"
.format(filename, err))
except ValueError as err:
# logger.error("Invalid BLAST entry")
raise ValueError(
"{} is an invalid BLAST file, sending back anything salvageable.\n{}"
.format(filename, err))
cursor.close()
conn.commit()
conn.close()
return dbname
def test_parse_when_minidom_fails_with_apk_path_and_extended_processing(
self, mock_file, mock_file_parser, mock_minidom, mock_aapt):
file = any_file(filename="AndroidManifest.xml")
mock_parser_instance = any_file_parser(file=file)
mock_file_parser.return_value = mock_parser_instance
mock_minidom.parse.side_effect = ExpatError()
mock_aapt.get_apk_info.return_value = self.any_aapt_apk_info(
package_name="any-package-name",
version_code=1,
version_name="any-version-name",
sdk_max="20",
sdk_min="10",
sdk_target="15")
mock_aapt.get_app_permissions.return_value = [
"any-permission-0", "any-permission-1", "any-permission-2"
]
mock_aapt.get_manifest_info.return_value = self.any_aapt_manifest_info(
activities=["any-activity-name"],
services=["any-service-name"],
receivers=["any-broadcast-receiver-name"])
manifest = self.sut.parse(filepath="any-file-path",
binary=False,
apk_path="any_apk_path",
extended_processing=True)
assert_file_parser_called_once_with(mock_parser_instance,
filepath="any-file-path",
filename="AndroidManifest.xml")
mock_file.assert_called_with("any-file-path", "rb")
mock_minidom.parse.assert_called_with("any-file-path")
mock_aapt.get_apk_info.assert_called_with("any_apk_path")
mock_aapt.get_app_permissions.assert_called_with("any_apk_path")
mock_aapt.get_manifest_info.assert_called_with("any_apk_path")
assert_file_equal(self, expected=file, actual=manifest)
self.assert_manifest_equal(
manifest=manifest,
package_name="any-package-name",
version=AppVersion(code=1, name="any-version-name"),
sdk=AppSdk(min_version="10", target_version="15",
max_version="20"),
permissions=[
"any-permission-0", "any-permission-1", "any-permission-2"
],
activities=[AppActivity(name="any-activity-name")],
services=[AppService(name="any-service-name")],
receivers=[
AppBroadcastReceiver(name="any-broadcast-receiver-name")
])
def testStore(self):
""" Tests the storing of the preferences. """
self._handler.load()
writeDataMock = _WriteDataMock()
self._fileStorerMock.writeData = writeDataMock
self._handler.showDottedFilesLocal = True
self._handler.showDottedFilesRemote = False
self._handler.addConnection(
"http://192.168.125.130/repos/config/test2", "test", "test", False,
"ldap://", "OU=DLR,DC=intra,DC=dlr,DC=de", False, None, "ds1",
"ds2")
self._handler.addConnection(
"http://192.168.125.130/repos/config/test1", None, None)
self._handler.addScriptUri("path")
self._handler.addScriptUri("path2")
self._handler.addSearchQuery("query", "query")
self._handler.addSearchQuery("query2", "query2")
self._handler.store()
self.assertEquals(writeDataMock.content, _VALID_CONFIGURATION)
del self._fileStorerMock.writeData
self._handler.load()
self._fileStorerMock.methodNameResultMap = {
"exists": (None, PersistenceError())
}
self.assertRaises(ConfigurationError, self._handler.store)
self._fileStorerMock.methodNameResultMap = {
"exists": (False, None),
"createResource": (None, PersistenceError())
}
self.assertRaises(ConfigurationError, self._handler.store)
self._fileStorerMock.methodNameResultMap = {
"exists": (True, None),
"writeData": (None, PersistenceError())
}
self.assertRaises(ConfigurationError, self._handler.store)
self._handler._preferences = SimpleMock(error=ExpatError())
self._fileStorerMock.methodNameResultMap = {"exists": (True, None)}
self.assertRaises(ConfigurationError, self._handler.store)
def fix_xml(needle):
needle = replace_escape_chars(needle)
# first, we need to make sure the needle is valid html
"""
try:
validate_html(needle)
except HTMLParser.HTMLParseError:
print "error with: %s"%needle
raise
"""
# then we close all the open-ended tags to make sure it will compare
# properly
#needle = bs(needle).prettify()
needle = xhtmlify(needle)
try:
needle_node = etree.fromstring(needle)
except ExpatError, e:
raise ExpatError('Could not parse %s into xml. %s' % (
needle, e.args[0]
))
def test_ncbi_fails(self):
exceptions = [ChunkedEncodingError(), ConnectionError(), ReadTimeout(),
ExpatError(), RuntimeError('bad record')]
for code in [400, 429]:
http_exception = HTTPError()
http_exception.response = Response()
http_exception.response.status_code = code
exceptions.append(http_exception)
for exception in exceptions:
self.ncbi_exception = exception
with self.assertLogs(level='DEBUG') as log:
seq, tax = self.get_ncbi_data(query='MT345279.1')
tax = tax.view(DataFrame)
self.assertEqual(
tax['Taxon']['MT345279.1'],
'k__Fungi; p__Basidiomycota; c__Agaricomycetes; '
'o__Boletales; f__Boletaceae; g__Boletus; s__edulis'
)
self.assertTrue('Retrying' in log.output[0])
def testImport(self):
""" Tests the import of data store configurations. """
self._createFileStorerMock.value = SimpleMock(SimpleMock())
self._parseStringMock.value = datastores.datastores([datastores.default(name="name1", storeType=constants.DEFAULT_STORE),
datastores.default(name="name2", storeType=constants.DEFAULT_STORE)])
self._datastoreHandler.importDataStores("/local/file/path")
self.assertEquals(len(self._datastoreHandler.datastores), 2)
self._parseStringMock.error = ExpatError("")
self.assertRaises(ConfigurationError, self._datastoreHandler.importDataStores, "/local/file/path")
self.assertEquals(len(self._datastoreHandler.datastores), 2)
self._createFileStorerMock.value = SimpleMock(error=PersistenceError(""))
self.assertRaises(ConfigurationError, self._datastoreHandler.importDataStores, "/local/file/path")
self.assertEquals(len(self._datastoreHandler.datastores), 2)
self._createFileStorerMock.error = PersistenceError("")
self.assertRaises(ConfigurationError, self._datastoreHandler.importDataStores, "/local/file/path")
self.assertEquals(len(self._datastoreHandler.datastores), 2)
def testLoad(self):
""" Tests the loading of the persisted data model. """
self._fileStorerMock.methodNameResultMap = {
"exists": (True, None),
"readData": (SimpleMock(""), None)
}
self._parseStringMock.value = self._persistedDataModel
self._dataModelHandler.load()
self.assertEquals(self._dataModelHandler.datatypes, self._dataTypes)
self.assertEquals(self._dataModelHandler.relations, self._relations)
self._fileStorerMock.methodNameResultMap = None
self._fileStorerMock.value = False
self.assertRaises(ConfigurationError, self._dataModelHandler.load)
self._fileStorerMock.error = PersistenceError("")
self.assertRaises(ConfigurationError, self._dataModelHandler.load)
self._parseStringMock.error = ExpatError("")
self.assertRaises(ConfigurationError, self._dataModelHandler.load)
self._parseStringMock.error = ValueError("")
self.assertRaises(ConfigurationError, self._dataModelHandler.load)
def read_label(filename,
strip_extra_whitespace=True,
enforce_default_prefixes=False,
include_namespace_map=False,
decode_py2=False):
""" Reads a PDS4 XML Label into an ``ElementTree`` Element object.
Parameters
----------
filename : str or unicode
The filename, including the path, of the XML label.
strip_extra_whitespace : bool, optional
If True, then for element text and attribute values, it collapses
contiguous whitespaces (including space, tab and newlines) into a
single space, and removes leading and trailing whitespace altogether.
However, this only done if the value has a single line with
non-whitespace characters. Defaults to False.
enforce_default_prefixes : bool, optional
If True, strips the default namespace, and ensures that
default PDS4 prefixes are used for known namespaces (PDS4_NAMESPACES).
Defaults to False.
include_namespace_map : bool, optional
If True, changes method return to a tuple, where the first
value is the label ElementTree object as usual and the second
is a ``dict`` with keys being the namespace URIs and values being
the namespace prefixes in this label. Defaults to False.
decode_py2 : bool, optional
If True, decodes UTF-8 byte strings (``str``) into ``unicode``
strings in Python 2. Option is ignored in Python 3. Defaults to False.
Returns
-------
``ElementTree`` Element
Root element for the read-in PDS4 label
"""
# Read-in XML tree
try:
xml_tree = ET.iterparse(filename, events=('start-ns', 'end'))
except IOError:
raise IOError('Unable to locate or read label file: ' + filename)
# Adjust XML tree
try:
namespace_map = {}
for event, elem in xml_tree:
# Add namespace to the namespace map
if event == 'start-ns':
if enforce_default_prefixes:
for prefix, uri in six.iteritems(PDS4_NAMESPACES):
# Ensure the PDS4 namespace is the default prefix
if elem[1] == PDS4_NAMESPACES['pds']:
elem = ('', elem[1])
# Ensure that dictionaries which are referred to in code
# by prefix (such as disp and sp) have the expected prefix
elif uri == elem[1]:
elem = (prefix, elem[1])
# Add namespace to map (different prefixes for an existing namespace URI are skipped)
# Technical note: this map is stored dict[URI] = prefix for two reasons:
# (1) ElementTree itself internally stores the namespace map like this, despite taking
# it in opposite relation from user
# (2) It seems ever slightly more legitimate to remember a single prefix to referring to
# multiple URI (e.g. via local prefixes) than to remember two prefixes referring to
# the same URI.
# These are not necessarily good reasons.
if elem[1] not in namespace_map:
namespace_map[elem[1]] = elem[0]
continue
# Strip PDS4 namespace tag (a continuation of ensuring default prefix is PDS4 namespace)
if (enforce_default_prefixes) and (PDS4_NAMESPACES['pds']
in elem.tag):
elem.tag = elem.tag.split('{', 1)[0] + elem.tag.split('}',
1)[1]
# Strip whitespace in elements and attributes if requested
if strip_extra_whitespace:
subiter = compat.ET_Tree_iter(ET.ElementTree(elem))
attribs = six.iteritems(elem.attrib)
# Strip whitespaces at beginning and end of value in elements that do not have children
if len(elem) == 0:
for elem_content in subiter:
if (elem_content.text) and (_non_blank_line_count(
elem_content.text) == 1):
elem_content.text = _normalize(elem_content.text)
# Strip whitespaces at beginning and end of attribute values
for name, value in attribs:
if _non_blank_line_count(value) == 1:
elem.attrib[name] = _normalize(value)
label_xml_root = xml_tree.root
# For Python 2, we can decode all ``str`` to ``unicode``, such that all meta data strings
# are consistently unicode.
if six.PY2 and decode_py2:
label_xml_root = _decode_tree(label_xml_root)
# Raise exception if XML cannot be parsed. In Python 3 we raise from None to avoid confusing re-raise
except (ExpatError, compat.ET_ParseError):
six.raise_from(
ExpatError(
'The requested PDS4 label file does not appear contain valid XML: '
+ filename), None)
if include_namespace_map:
return label_xml_root, namespace_map
else:
return label_xml_root
def xml_pickler(configuration,
filename,
default_header,
cache=None,
max_target_seqs=10):
valid, _, exc = BlastOpener(filename).sniff(default_header=default_header)
engine = connect(configuration, strategy="threadlocal")
session = Session(bind=engine)
if not valid:
err = "Invalid BLAST file: %s" % filename
raise TypeError(err)
directory = os.path.dirname(filename)
with tempfile.NamedTemporaryFile(suffix=".db",
dir=directory,
mode="wb",
delete=False) as dbhandle:
dbname = dbhandle.name
if not isinstance(cache,
dict) or set(cache.keys()) != {"query", "target"}:
cache = dict()
cache["query"] = dict((item.query_name, item.query_id)
for item in session.query(Query))
cache["target"] = dict((item.target_name, item.target_id)
for item in session.query(Target))
rows = b""
try:
with BlastOpener(filename) as opened:
try:
qmult, tmult = None, None
for query_counter, record in enumerate(opened, start=1):
if qmult is None:
qmult, tmult = get_multipliers(record)
off_by_one = get_off_by_one(record)
hits, hsps, cache = objectify_record(
record, [], [],
cache,
max_target_seqs=max_target_seqs,
qmult=qmult,
tmult=tmult,
off_by_one=off_by_one)
record = {"hits": hits, "hsps": hsps}
jrecord = dumper(record)
write_start = dbhandle.tell()
write_length = dbhandle.write(msgpack.dumps(jrecord))
rows += struct_row.pack(query_counter, write_start,
write_length)
except ExpatError as err:
raise ExpatError(
"{} is an invalid BLAST file, sending back anything salvageable.\n{}"
.format(filename, err))
except xml.etree.ElementTree.ParseError as err:
# logger.error("%s is an invalid BLAST file, sending back anything salvageable", filename)
raise xml.etree.ElementTree.ParseError(
"{} is an invalid BLAST file, sending back anything salvageable.\n{}"
.format(filename, err))
except ValueError as err:
# logger.error("Invalid BLAST entry")
raise ValueError(
"{} is an invalid BLAST file, sending back anything salvageable.\n{}"
.format(filename, err))
return dbname, zlib.compress(rows)
def handle_invalid_xmpp_element(*args: Any) -> None:
raise ExpatError('Found invalid xmpp stream element: %s' % str(args))
def _render_xml(self, xml_document, **kwargs):
# Prepare the xml object to be processed by jinja2
self.log.debug('Rendering XML object')
template_string = ""
try:
self.template_images = dict()
self._prepare_document_tags(xml_document)
xml_source = xml_document.toxml()
xml_source = xml_source.encode('ascii', 'xmlcharrefreplace')
jinja_template = self.environment.from_string(
self._unescape_entities(xml_source.decode('utf-8')))
result = jinja_template.render(**kwargs)
final_xml = parseString(result.encode('ascii',
'xmlcharrefreplace'))
# float convert
if self.FLOAT_CONVERT != FLOAT_CONVERT_NONE:
paras = final_xml.getElementsByTagName('text:p')
for p in paras:
for ch in p.childNodes:
if ch.nodeType == ch.TEXT_NODE:
try:
if self.FLOAT_CONVERT == FLOAT_CONVERT_ONLY_FLOAT_STYLE:
style = p.parentNode.getAttribute(
'table:style-name')
if 'float' not in style.lower():
continue
float(ch.data)
p.parentNode.attributes[
'office:value-type'] = 'float'
p.parentNode.attributes[
'calcext:value-type'] = 'float'
p.parentNode.attributes[
'office:value'] = ch.data
except Exception as e:
continue
if self.template_images:
self.replace_images(final_xml)
return final_xml
except ExpatError as e:
if not 'result' in locals():
result = xml_source
near = result.split('\n')[e.lineno - 1][e.offset - 200:e.offset +
200]
raise ExpatError('ExpatError "%s" at line %d, column %d\nNear of: "[...]%s[...]"' % \
(ErrorString(e.code), e.lineno, e.offset, near))
except:
self.log.error('Error rendering template:\n%s',
xml_document.toprettyxml(),
exc_info=True)
self.log.error(
'Unescaped template was:\n{0}'.format(template_string))
raise
finally:
self.log.debug('Rendering xml object finished')
def test_xmlsimpleparser_init_failed(self):
"""Ensure the simple XML parser fails correctly."""
self.mod.ParserCreate = Mock()
self.mod.ParserCreate.return_value.ParseFile.side_effect = ExpatError()
with self.assertRaises(OSError):
self.mod.XMLSimpleParser(self.normal_kml, 2, 3, 4, 5)
def request(self, host, handler, request, verbose=None):
raise ExpatError("mismatched tag")
