def __init__(self, out = sys.stdout, encoding = "utf-8", indent = "", addindent = "", newl = ""):
XMLGenerator.__init__(self, out, encoding)
# XMLGenerator does not export _write()
self.write = self.ignorableWhitespace
self.indents = [indent]
self.addindent = addindent
self.newl = newl
class XmlWriter(AbstractXmlWriter):
def __init__(self, path):
self.path = path
self._output = open(path, 'wb')
self._writer = XMLGenerator(self._output, 'UTF-8')
self._writer.startDocument()
self.closed = False
def start(self, name, attributes={}, newline=True):
attrs = AttributesImpl(attributes)
self._writer.startElement(name, attrs)
if newline:
self.content('\n')
def content(self, content):
if content is not None:
self._writer.characters(self._encode(content))
def end(self, name, newline=True):
self._writer.endElement(name)
if newline:
self.content('\n')
def close(self):
self._writer.endDocument()
self._output.close()
self.closed = True
def test_conditional_formatting_update(self):
class WS():
conditional_formatting = ConditionalFormatting()
worksheet = WS()
rules = {'A1:A4': [{'type': 'colorScale', 'priority': 13,
'colorScale': {'cfvo': [{'type': 'min'}, {'type': 'max'}], 'color':
[Color('FFFF7128'), Color('FFFFEF9C')]}}]}
worksheet.conditional_formatting.update(rules)
temp_buffer = StringIO()
doc = XMLGenerator(out=temp_buffer, encoding='utf-8')
write_worksheet_conditional_formatting(doc, worksheet)
doc.endDocument()
xml = temp_buffer.getvalue()
temp_buffer.close()
diff = compare_xml(xml, """
<conditionalFormatting sqref="A1:A4">
<cfRule type="colorScale" priority="1">
<colorScale>
<cfvo type="min" />
<cfvo type="max" />
<color rgb="FFFF7128" />
<color rgb="FFFFEF9C" />
</colorScale>
</cfRule>
</conditionalFormatting>
""")
assert diff is None, diff
def _close(self):
"""close an already opened channel"""
generator = XMLGenerator(self.worker)
generator.endElement('channel')
# XXX
self.worker.write('\n')
self.exit = True
def unparse(input_dict, output=None, encoding='utf-8', full_document=True, **kwargs):
"""
dict(json)转xml格式
:param input_dict:
:param output:
:param encoding:
:param full_document:
:param kwargs:
:return:
"""
if full_document and len(input_dict) != 1:
raise ValueError('Document must have exactly one root.')
must_return = False
if output is None:
output = StringIO()
must_return = True
content_handler = XMLGenerator(output, encoding)
if full_document:
content_handler.startDocument()
for k, v in input_dict.items():
_emit(k, v, content_handler, full_document=full_document, **kwargs)
if full_document:
content_handler.endDocument()
if must_return:
rep_value = output.getvalue()
try:
rep_value = rep_value.decode(encoding)
except AttributeError:
pass
return rep_value
def __init__(self, break_into=None, break_after=1000, out=None, *args, **kwargs):
XMLGenerator.__init__(self, out, *args, **kwargs)
self.out_file = out
self.break_into = break_into
self.break_after = break_after
self.context = []
self.count = 0
class ExportExtractor(XMLFilterBase):
def __init__(self, file):
XMLFilterBase.__init__(self)
self.generator = XMLGenerator(file, 'UTF-8')
self.generator.startPrefixMapping(u'', u'http://www.eucalyptus.com/ns/reporting/export/2012-08-24/')
self.replyData = StringIO()
self.replyGenerator = XMLGenerator( self.replyData, 'UTF-8' )
self.switchTarget( self.replyGenerator )
def startDocument(self):
self.generator.startDocument()
XMLFilterBase.startDocument(self)
def endElementNS(self, name, qname):
XMLFilterBase.endElementNS(self, name, qname)
namespace, element = name
if namespace == u'http://www.eucalyptus.com/ns/reporting/export/2012-08-24/' and element == u'Export':
self.switchTarget( self.replyGenerator )
def startElementNS(self, name, qname, attrs):
namespace, element = name
if namespace == u'http://www.eucalyptus.com/ns/reporting/export/2012-08-24/' and element == u'Export':
self.switchTarget( self.generator )
XMLFilterBase.startElementNS(self, name, qname, attrs)
def switchTarget(self, target):
self._cont_handler = target
self._dtd_handler = target
self._ent_handler = target
self._err_handler = target
def getReply(self):
return self.replyData.getvalue()
def encode(self, obj, root='root'):
buf = StringIO()
xml = XMLGenerator(buf, encoding='utf-8')
xml.startDocument()
self.encode_obj(xml, root, obj)
xml.endDocument()
return buf.getvalue()
def __init__(self, out, enc, reader):
XMLGenerator.__init__(self, GetFile(out, "w"), enc)
self.reader = reader
self.num_read_nodes = 0
self.num_read_ways = 0
self.num_read_relations = 0
def unparse(input_dict, output=None, encoding='utf-8', full_document=True,
**kwargs):
"""Emit an XML document for the given `input_dict` (reverse of `parse`).
The resulting XML document is returned as a string, but if `output` (a
file-like object) is specified, it is written there instead.
Dictionary keys prefixed with `attr_prefix` (default=`'@'`) are interpreted
as XML node attributes, whereas keys equal to `cdata_key`
(default=`'#text'`) are treated as character data.
The `pretty` parameter (default=`False`) enables pretty-printing. In this
mode, lines are terminated with `'\n'` and indented with `'\t'`, but this
can be customized with the `newl` and `indent` parameters.
"""
if full_document and len(input_dict) != 1:
raise ValueError('Document must have exactly one root.')
must_return = False
if output is None:
output = StringIO()
must_return = True
content_handler = XMLGenerator(output, encoding)
if full_document:
content_handler.startDocument()
for key, value in input_dict.items():
_emit(key, value, content_handler, full_document=full_document,
**kwargs)
if full_document:
content_handler.endDocument()
if must_return:
value = output.getvalue()
try: # pragma no cover
value = value.decode(encoding)
except AttributeError: # pragma no cover
pass
return value
def __init__(self, output, encoding, top_level_tag, attrs):
xml_writer = XMLGenerator(output, encoding, True)
xml_writer.startDocument()
xml_writer.startElement(top_level_tag, attrs)
self._xml_writer = xml_writer
self.top_level_tag = top_level_tag
self.ident=4
self._xml_writer.characters('\n')
def startElement(self, tag, attrs={}):
attrs_write = {'CREATED': gMF(attrs['created_mindmap']),
'MODIFIED': gMF(max(attrs['modified_mindmap'],
attrs['modified_openerp'])),
'ID': attrs['id_mindmap'] or 'ID_' + str(random.randint(1, 10**10)),
'TEXT': attrs['name'],
}
XMLGenerator.startElement(self, tag, attrs_write)
def startElement(self, name, attrs, indent = True, newl = True):
if indent:
self.ignorableWhitespace("".join(self.indents))
self.indents.append(self.addindent)
XMLGenerator.startElement(self, name, attrs)
if newl:
self.ignorableWhitespace(self.newl)
def endElement(self, name, indent = True, newl = True):
self.indents.pop()
if indent:
self.ignorableWhitespace("".join(self.indents))
XMLGenerator.endElement(self, name)
if newl:
self.ignorableWhitespace(self.newl)
def characters(self, content):
try:
if content.lstrip().startswith("<"):
etree.fromstring(content)
self._write(content)
else:
XMLGenerator.characters(self, content)
except (AttributeError, Exception):
#TODO could be more specific on errors caught
XMLGenerator.characters(self, content)
def manifest_xml(f, files):
from xml.sax.saxutils import XMLGenerator
xml = XMLGenerator(f, 'utf-8')
xml.startDocument()
uri = 'urn:oasis:names:tc:opendocument:xmlns:manifest:1.0'
prefix = 'manifest'
xml.startPrefixMapping(prefix, uri)
def startElement(name, attrs):
attrs = dict( ((uri, n), v) for n, v in attrs.iteritems() )
xml.startElementNS( (uri, name), prefix+':'+name, attrs)
def endElement(name):
xml.endElementNS( (uri, name), prefix+':'+name)
def file_entry(full_path, media_type, **kwargs):
attrs = {'media-type': media_type, 'full-path': full_path}
attrs.update(dict((n.replace('_', '-'), v) for n, v in kwargs.iteritems()))
startElement('file-entry', attrs)
endElement('file-entry')
startElement( 'manifest', dict(version='1.2') )
file_entry('/', 'application/vnd.oasis.opendocument.text', version='1.2')
for e in files:
e = dict(e)
full_path = e.pop('full_path')
media_type = e.pop('media_type', 'application/octet-stream')
file_entry(full_path, media_type)
endElement( 'manifest' )
xml.endPrefixMapping(prefix)
xml.endDocument()
def manifest_xml(f, files):
from xml.sax.saxutils import XMLGenerator
xml = XMLGenerator(f, "utf-8")
xml.startDocument()
uri = "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"
prefix = "manifest"
xml.startPrefixMapping(prefix, uri)
def startElement(name, attrs):
attrs = dict(((uri, n), v) for n, v in attrs.iteritems())
xml.startElementNS((uri, name), prefix + ":" + name, attrs)
def endElement(name):
xml.endElementNS((uri, name), prefix + ":" + name)
def file_entry(full_path, media_type, **kwargs):
attrs = {"media-type": media_type, "full-path": full_path}
attrs.update(dict((n.replace("_", "-"), v) for n, v in kwargs.iteritems()))
startElement("file-entry", attrs)
endElement("file-entry")
startElement("manifest", dict(version="1.2"))
file_entry("/", "application/vnd.oasis.opendocument.text", version="1.2")
for e in files:
e = dict(e)
full_path = e.pop("full_path")
media_type = e.pop("media_type", "application/octet-stream")
file_entry(full_path, media_type)
endElement("manifest")
xml.endPrefixMapping(prefix)
xml.endDocument()
def test_conditional_font(self):
"""Test to verify font style written correctly."""
class WS():
conditional_formatting = ConditionalFormatting()
worksheet = WS()
# Create cf rule
redFill = Fill()
redFill.start_color.index = 'FFEE1111'
redFill.end_color.index = 'FFEE1111'
redFill.fill_type = Fill.FILL_SOLID
whiteFont = Font()
whiteFont.color.index = "FFFFFFFF"
worksheet.conditional_formatting.add('A1:A3', CellIsRule(operator='equal', formula=['"Fail"'], stopIfTrue=False,
font=whiteFont, fill=redFill))
worksheet.conditional_formatting.setDxfStyles(self.workbook)
# First, verify conditional formatting xml
temp_buffer = StringIO()
doc = XMLGenerator(out=temp_buffer, encoding='utf-8')
write_worksheet_conditional_formatting(doc, worksheet)
doc.endDocument()
xml = temp_buffer.getvalue()
temp_buffer.close()
diff = compare_xml(xml, """
<conditionalFormatting sqref="A1:A3">
<cfRule dxfId="0" operator="equal" priority="1" type="cellIs">
<formula>"Fail"</formula>
</cfRule>
</conditionalFormatting>
""")
assert diff is None, diff
# Second, verify conditional formatting dxf styles
w = StyleWriter(self.workbook)
w._write_dxfs()
xml = get_xml(w._root)
diff = compare_xml(xml, """
<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
<dxfs count="1">
<dxf>
<font>
<color rgb="FFFFFFFF" />
</font>
<fill>
<patternFill patternType="solid">
<fgColor rgb="FFEE1111" />
<bgColor rgb="FFEE1111" />
</patternFill>
</fill>
</dxf>
</dxfs>
</styleSheet>
""")
assert diff is None, diff
def export(self,filename,transport):
vprint( "osm-xml export...",1)
#remember all nodes already exported
unodes = {}
fp = open(filename, "w")
x = XMLGenerator(fp, "UTF-8")
x.startDocument()
x.startElement('osm',{"version":"0.6","generator":"crazy py script"})
for w in self.ways.itervalues():
if not 'highway' in w.tags:
continue
if transport == "all" or transport == "pt":
if not (w.tags['highway']=='bus' or w.tags['highway']=='tram'):
continue
if transport == "all" or transport == "hw":
if (w.tags['highway']=='bus' or w.tags['highway']=='tram'):
continue
w.toOSM(x)
for nid in w.nds:
if nid in unodes:#already used
continue
unodes[nid]=True
if w.nds.index(nid)==0 or w.nds.index(nid)==len(w.nds)-1:
self.nodes[nid].toOSM(x,True)
else:
self.nodes[nid].toOSM(x)
x.endElement('osm')
x.endDocument()
def startElement(self, name, attrs={}, children=False):
"""Starts an XML element.
Arguments:
name -- String of element name.
attrs -- Dictionary of element attributes.
children -- Boolean, whether the element has children or not.
"""
self.ignorableWhitespace(self._indent * self._level)
XMLGenerator.startElement(self, name, attrs)
def __init__(self, out=None, encoding="iso-8859-1", increment=2):
"""out Opened output file; sys.stdout if None given.
encoding Character encoding to use.
increment Indentation increment to use.
"""
XMLGenerator.__init__(self, out=out, encoding=encoding)
self._element_stack = []
self._in_cdata = False
self._indent_increment = increment
self._newline_flag = False
self._indent_level = 0
def endElement(self, tagname=None, forceNewLine=True):
"""Finish the current element.
The tagname argument is not required and is in fact currently ignored,
since the internal element tagname stack is used."""
self._indent_level -= self._indent_increment
if not self._newline_flag:
self.ignorableWhitespace(' ' * self._indent_level)
XMLGenerator.endElement(self, self._element_stack.pop())
self._newline_flag = True
if forceNewLine:
self.newline()
def __init__(self, root, out, encoding='UTF-8', acceptAttributes=True, acceptUnknownTags=True,
shortEmptyElements=True):
'''
@param out: file object with write
The file object to write the updated xml, needs to have a 'write' method that accepts text.
@see: Digester.__init__
@see: XMLGenerator.__init__
'''
XMLGenerator.__init__(self, out, encoding, shortEmptyElements)
Digester.__init__(self, root, acceptAttributes, acceptUnknownTags)
def startElement(self, tagname, forceNewLine=True, **attrs):
"""Start a new element, with appropriate indentation."""
if not self._newline_flag:
self.ignorableWhitespace(' ' * self._indent_level)
XMLGenerator.startElement(self, tagname,
self.translate_name_aliases(**attrs))
self._element_stack.append(tagname)
self._newline_flag = True
self._indent_level += self._indent_increment
if forceNewLine:
self.newline()
def startElement(self, name, attrs):
pos = name.find(':')
tag = name if pos == -1 else name[pos+1:]
attr = self.rules.get(tag)
XMLGenerator.startElement(self, name, attrs)
if attr is None:
self.trans = False
elif attr is True:
self.trans = True
else:
self.trans = attrs.get(attr[0]) == attr[1]
def __init__(self, out, enc, reader=None, check_intersection=None, poly=None, poly_buffered=None):
XMLGenerator.__init__(self, GetFile(out, "w"), enc)
self.reader = reader
self.check_intersection = check_intersection
self.poly = []
self.poly.append(poly)
self.poly.append(poly_buffered)
self.poly_num = 2
self.num_read_nodes = 0
self.num_read_ways = 0
self.num_read_relations = 0
def endElementNS(self, ns, el) :
self.__level = self.__level - 1
if self.__last == "end" :
self.ignorableWhitespace("\n")
if self.__last == 'end' :
self.ignorableWhitespace(" " * (self.__level * self.__indent))
XMLGenerator.endElementNS(self, ns, el)
self.__last = 'end'
def test_xmlgen_basic():
result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startElement("doc", {})
gen.endElement("doc")
gen.endDocument()
return result.getvalue() == start + "<doc></doc>"
def test_xmlgen_basic(self):
result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startElement("doc", {})
gen.endElement("doc")
gen.endDocument()
self.assertEqual(result.getvalue(), start + "<doc></doc>")
def test_xmlgen_basic_empty(self):
result = StringIO()
gen = XMLGenerator(result, short_empty_elements=True)
gen.startDocument()
gen.startElement("doc", {})
gen.endElement("doc")
gen.endDocument()
self.assertEqual(result.getvalue(), start + "<doc/>")
def check_parse(self, f):
from xml.sax import parse
result = StringIO()
parse(f, XMLGenerator(result, 'utf-8'))
self.assertEqual(result.getvalue(), xml_str(self.data, 'utf-8'))
def test_xmlgen_encoding_bytes(self):
encodings = ('iso-8859-15', 'utf-8', 'utf-8-sig', 'utf-16', 'utf-16be',
'utf-16le', 'utf-32', 'utf-32be', 'utf-32le')
for encoding in encodings:
result = self.ioclass()
gen = XMLGenerator(result, encoding=encoding)
gen.startDocument()
gen.startElement('doc', {'a': '€'})
gen.characters('€'.encode(encoding))
gen.ignorableWhitespace(' '.encode(encoding))
gen.endElement('doc')
gen.endDocument()
self.assertEqual(
result.getvalue(),
self.xml('<doc a="€">€ </doc>', encoding=encoding))
def test_1463026_3(self):
result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startPrefixMapping('my', 'qux')
gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'): 'c'})
gen.endElementNS(('qux', 'a'), 'a')
gen.endPrefixMapping('my')
gen.endDocument()
self.assertEqual(result.getvalue(),
start + '<my:a xmlns:my="qux" b="c"></my:a>')
class XMLSerializer:
"""
Serializes data to XML for MKM requests.
Original author: https://github.com/evonove
"""
def __init__(self):
self.generator = None
def serialize(self, data):
"""
Serializes data to XML so that it can be sent to backend, if data is not a dictionary.
:raise SerializationException: On serialize error.
:param data: A dictionary containing the data to serialize
:return: Returns a string containing data serialized to XML
"""
if not isinstance(data, dict):
raise SerializationException(
"Can't serialize data, must be a dictionary.")
stream = StringIO()
self.generator = XMLGenerator(stream, 'utf-8')
self.generator.startDocument()
self.generator.startElement('request', {})
self._parse(data)
self.generator.endElement('request')
self.generator.endDocument()
return stream.getvalue()
def _parse(self, data, previous_element_tag=None):
"""
Recursively parses data and creates the relative elements.
:param data: Data to parse
:param previous_element_tag: When parsing a list we pass the previous element tag
:return:
"""
if isinstance(data, dict):
for key in data:
value = data[key]
self._parse(value, key)
elif isinstance(data, (list, tuple)):
for item in data:
if isinstance(item, dict):
self.generator.startElement(previous_element_tag, {})
self._parse(item, previous_element_tag)
if isinstance(item, dict):
self.generator.endElement(previous_element_tag)
else:
self.generator.startElement(previous_element_tag, {})
self.generator.characters(f'{data}')
self.generator.endElement(previous_element_tag)
class Preferences(connector.Publisher):
def __setattr__(self, attr, value):
if not hasattr(self, attr) or getattr(self, attr) != value:
self.__dict__[attr] = value
self.issue(CHANGED, attr, value)
def load(self, filename=None):
import xml.sax
from xml.sax.xmlreader import InputSource
content_handler = XMLPrefReader(pref=self)
error_handler = ErrorHandler()
entity_resolver = EntityResolver()
dtd_handler = DTDHandler()
try:
input = open(filename, "r")
input_source = InputSource()
input_source.setByteStream(input)
xml_reader = xml.sax.make_parser()
xml_reader.setContentHandler(content_handler)
xml_reader.setErrorHandler(error_handler)
xml_reader.setEntityResolver(entity_resolver)
xml_reader.setDTDHandler(dtd_handler)
xml_reader.parse(input_source)
input.close
except:
pass
def save(self, filename=None):
if len(self.__dict__) == 0 or filename == None:
return
from xml.sax.saxutils import XMLGenerator
try:
file = open(filename, 'w')
except (IOError, os.error), value:
import sys
sys.stderr('cannot write preferences into %s: %s' %
( ` filename `, value[1]))
return
writer = XMLGenerator(out=file, encoding=self.system_encoding)
writer.startDocument()
defaults = Preferences.__dict__
items = self.__dict__.items()
items.sort()
writer.startElement('preferences', {})
writer.characters('\n')
for key, value in items:
if defaults.has_key(key) and defaults[key] == value:
continue
writer.characters(' ')
writer.startElement('%s' % key, {})
if type(value) == PointType:
to_write = '(%g, %g)' % tuple(value)
writer.characters('Point%s' % to_write)
else:
writer.characters('%s' % ` value `)
writer.endElement('%s' % key)
writer.characters('\n')
writer.endElement('preferences')
writer.endDocument()
file.close
class Logger:
def __init__(self) -> None:
self.logfile = os.environ.get("LOGFILE", "/dev/null")
self.logfile_handle = codecs.open(self.logfile, "wb")
self.xml = XMLGenerator(self.logfile_handle, encoding="utf-8")
self.queue: "Queue[Dict[str, str]]" = Queue(1000)
self.xml.startDocument()
self.xml.startElement("logfile", attrs={})
def close(self) -> None:
self.xml.endElement("logfile")
self.xml.endDocument()
self.logfile_handle.close()
def sanitise(self, message: str) -> str:
return "".join(ch for ch in message
if unicodedata.category(ch)[0] != "C")
def maybe_prefix(self, message: str, attributes: Dict[str, str]) -> str:
if "machine" in attributes:
return "{}: {}".format(attributes["machine"], message)
return message
def log_line(self, message: str, attributes: Dict[str, str]) -> None:
self.xml.startElement("line", attributes)
self.xml.characters(message)
self.xml.endElement("line")
def log(self, message: str, attributes: Dict[str, str] = {}) -> None:
eprint(self.maybe_prefix(message, attributes))
self.drain_log_queue()
self.log_line(message, attributes)
def enqueue(self, message: Dict[str, str]) -> None:
self.queue.put(message)
def drain_log_queue(self) -> None:
try:
while True:
item = self.queue.get_nowait()
attributes = {"machine": item["machine"], "type": "serial"}
self.log_line(self.sanitise(item["msg"]), attributes)
except Empty:
pass
@contextmanager
def nested(self,
message: str,
attributes: Dict[str, str] = {}) -> Iterator[None]:
eprint(self.maybe_prefix(message, attributes))
self.xml.startElement("nest", attrs={})
self.xml.startElement("head", attributes)
self.xml.characters(message)
self.xml.endElement("head")
tic = time.time()
self.drain_log_queue()
yield
self.drain_log_queue()
toc = time.time()
self.log("({:.2f} seconds)".format(toc - tic))
self.xml.endElement("nest")
class Logger:
def __init__(self) -> None:
self.logfile = os.environ.get("LOGFILE", "/dev/null")
self.logfile_handle = codecs.open(self.logfile, "wb")
self.xml = XMLGenerator(self.logfile_handle, encoding="utf-8")
self.queue: "Queue[Dict[str, str]]" = Queue()
self.xml.startDocument()
self.xml.startElement("logfile", attrs={})
self._print_serial_logs = True
@staticmethod
def _eprint(*args: object, **kwargs: Any) -> None:
print(*args, file=sys.stderr, **kwargs)
def close(self) -> None:
self.xml.endElement("logfile")
self.xml.endDocument()
self.logfile_handle.close()
def sanitise(self, message: str) -> str:
return "".join(ch for ch in message
if unicodedata.category(ch)[0] != "C")
def maybe_prefix(self, message: str, attributes: Dict[str, str]) -> str:
if "machine" in attributes:
return "{}: {}".format(attributes["machine"], message)
return message
def log_line(self, message: str, attributes: Dict[str, str]) -> None:
self.xml.startElement("line", attributes)
self.xml.characters(message)
self.xml.endElement("line")
def info(self, *args, **kwargs) -> None: # type: ignore
self.log(*args, **kwargs)
def warning(self, *args, **kwargs) -> None: # type: ignore
self.log(*args, **kwargs)
def error(self, *args, **kwargs) -> None: # type: ignore
self.log(*args, **kwargs)
sys.exit(1)
def log(self, message: str, attributes: Dict[str, str] = {}) -> None:
self._eprint(self.maybe_prefix(message, attributes))
self.drain_log_queue()
self.log_line(message, attributes)
def log_serial(self, message: str, machine: str) -> None:
self.enqueue({"msg": message, "machine": machine, "type": "serial"})
if self._print_serial_logs:
self._eprint(Style.DIM + "{} # {}".format(machine, message) +
Style.RESET_ALL)
def enqueue(self, item: Dict[str, str]) -> None:
self.queue.put(item)
def drain_log_queue(self) -> None:
try:
while True:
item = self.queue.get_nowait()
msg = self.sanitise(item["msg"])
del item["msg"]
self.log_line(msg, item)
except Empty:
pass
@contextmanager
def nested(self,
message: str,
attributes: Dict[str, str] = {}) -> Iterator[None]:
self._eprint(self.maybe_prefix(message, attributes))
self.xml.startElement("nest", attrs={})
self.xml.startElement("head", attributes)
self.xml.characters(message)
self.xml.endElement("head")
tic = time.time()
self.drain_log_queue()
yield
self.drain_log_queue()
toc = time.time()
self.log("(finished: {}, in {:.2f} seconds)".format(
message, toc - tic))
self.xml.endElement("nest")
def test_1463026_2_empty(self):
result = StringIO()
gen = XMLGenerator(result, short_empty_elements=True)
gen.startDocument()
gen.startPrefixMapping(None, 'qux')
gen.startElementNS(('qux', 'a'), 'a', {})
gen.endElementNS(('qux', 'a'), 'a')
gen.endPrefixMapping(None)
gen.endDocument()
self.assertEqual(result.getvalue(), start + '<a xmlns="qux"/>')
def test_xmlgen_content_escape(self):
result = self.ioclass()
gen = XMLGenerator(result)
gen.startDocument()
gen.startElement('doc', {})
gen.characters('<huhei&')
gen.endElement('doc')
gen.endDocument()
self.assertEqual(result.getvalue(),
self.xml('<doc><huhei&</doc>'))
def test_xmlgen_attr_escape(self):
result = self.ioclass()
gen = XMLGenerator(result)
gen.startDocument()
gen.startElement('doc', {'a': '"'})
gen.startElement('e', {'a': "'"})
gen.endElement('e')
gen.startElement('e', {'a': '\'"'})
gen.endElement('e')
gen.startElement('e', {'a': '\n\r\t'})
gen.endElement('e')
gen.endElement('doc')
gen.endDocument()
self.assertEqual(
result.getvalue(),
self.xml(
'<doc a=\'"\'><e a="\'"></e><e a="\'""></e><e a=" 	"></e></doc>'
))
def test_1463026_3_empty(self):
result = self.ioclass()
gen = XMLGenerator(result, short_empty_elements=True)
gen.startDocument()
gen.startPrefixMapping('my', 'qux')
gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'): 'c'})
gen.endElementNS(('qux', 'a'), 'a')
gen.endPrefixMapping('my')
gen.endDocument()
self.assertEqual(result.getvalue(),
self.xml('<my:a xmlns:my="qux" b="c"/>'))
def test_1463026_2(self):
result = self.ioclass()
gen = XMLGenerator(result)
gen.startDocument()
gen.startPrefixMapping(None, 'qux')
gen.startElementNS(('qux', 'a'), 'a', {})
gen.endElementNS(('qux', 'a'), 'a')
gen.endPrefixMapping(None)
gen.endDocument()
self.assertEqual(result.getvalue(), self.xml('<a xmlns="qux"></a>'))
def test_xmlgen_unencodable(self):
result = self.ioclass()
gen = XMLGenerator(result, encoding='ascii')
gen.startDocument()
gen.startElement('doc', {'a': '€'})
gen.characters('€')
gen.endElement('doc')
gen.endDocument()
self.assertEqual(
result.getvalue(),
self.xml('<doc a="€">€</doc>', encoding='ascii'))
def __init__(self, file):
super().__init__(file, "1.0")
self.xmlgen = XMLGenerator(self.file, 'utf-8')
self._level = 0
class _XmlAnnotationWriter(_AnnotationWriter):
def __init__(self, file):
super().__init__(file, "1.0")
self.xmlgen = XMLGenerator(self.file, 'utf-8')
self._level = 0
def _indent(self, newline=True):
if newline:
self.xmlgen.ignorableWhitespace("\n")
self.xmlgen.ignorableWhitespace(" " * self._level)
def _add_version(self):
self._indent()
self.xmlgen.startElement("version", {})
self.xmlgen.characters(self.version)
self.xmlgen.endElement("version")
def open_root(self):
self.xmlgen.startDocument()
self.xmlgen.startElement("annotations", {})
self._level += 1
self._add_version()
def _add_meta(self, meta):
self._level += 1
for k, v in meta.items():
if isinstance(v, OrderedDict):
self._indent()
self.xmlgen.startElement(k, {})
self._add_meta(v)
self._indent()
self.xmlgen.endElement(k)
elif type(v) == list:
self._indent()
self.xmlgen.startElement(k, {})
for tup in v:
self._add_meta(OrderedDict([tup]))
self._indent()
self.xmlgen.endElement(k)
else:
self._indent()
self.xmlgen.startElement(k, {})
self.xmlgen.characters(v)
self.xmlgen.endElement(k)
self._level -= 1
def add_meta(self, meta):
self._indent()
self.xmlgen.startElement("meta", {})
self._add_meta(meta)
self._indent()
self.xmlgen.endElement("meta")
def open_track(self, track):
self._indent()
self.xmlgen.startElement("track", track)
self._level += 1
def open_image(self, image):
self._indent()
self.xmlgen.startElement("image", image)
self._level += 1
def open_box(self, box):
self._indent()
self.xmlgen.startElement("box", box)
self._level += 1
def add_attribute(self, attribute):
self._indent()
self.xmlgen.startElement("attribute", {"name": attribute["name"]})
self.xmlgen.characters(attribute["value"])
self.xmlgen.endElement("attribute")
def close_box(self):
self._level -= 1
self._indent()
self.xmlgen.endElement("box")
def close_image(self):
self._level -= 1
self._indent()
self.xmlgen.endElement("image")
def close_track(self):
self._level -= 1
self._indent()
self.xmlgen.endElement("track")
def close_root(self):
self._level -= 1
self._indent()
self.xmlgen.endElement("annotations")
self.xmlgen.endDocument()
def gen():
stream = io.StringIO()
try:
writer = XMLGenerator(stream, 'utf-8')
writer.startDocument()
start_element_attrs = {}
if xmlns and schema_name:
start_element_attrs['xmlns'] = xmlns
start_element_attrs[
'xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance'
schema_url = get_xml_schema_url(xmlns, schema_name)
start_element_attrs['xsi:schemaLocation'] = '{} {}'.format(
xmlns, schema_url)
for elem_name in root_element_name.split('.'):
writer.startElement(elem_name, attrs=start_element_attrs)
stream.seek(0)
yield stream.getvalue()
stream.truncate(0)
i = 0
iterator = models.iterator(
chunk_size=10000) if isinstance(models, QuerySet) else models
for m in iterator:
model_to_xml(writer,
m,
field_map,
model_name,
related_models_filter_function=
related_models_filter_function,
show_sequence_index=show_sequence_index,
sequence_index=i)
stream.seek(0)
yield stream.getvalue()
stream.truncate(0)
i += 1
if sub_models is not None and sub_models_field_map is not None and sub_models_element_name is not None:
writer.startElement(sub_models_element_name, attrs={})
stream.seek(0)
yield stream.getvalue()
stream.truncate(0)
i = 0
iterator = sub_models.iterator(chunk_size=10000) if isinstance(
sub_models, QuerySet) else sub_models
for m in iterator:
model_to_xml(writer,
m,
sub_models_field_map,
sub_model_name,
related_models_filter_function=
sub_related_models_filter_function,
show_sequence_index=show_sequence_index,
sequence_index=i)
stream.seek(0)
yield stream.getvalue()
stream.truncate(0)
i += 1
writer.endElement(sub_models_element_name)
for elem_name in root_element_name.split('.')[::-1]:
writer.endElement(elem_name)
writer.endDocument()
stream.seek(0)
yield stream.getvalue()
except Exception as e:
logger.error('Error in iterator: {}'.format(str(e)))
raise
finally:
stream.close()
class XmlItemExporter(BaseItemExporter):
def __init__(self, file, **kwargs):
self.item_element = kwargs.pop('item_element', 'item')
self.root_element = kwargs.pop('root_element', 'items')
super().__init__(**kwargs)
if not self.encoding:
self.encoding = 'utf-8'
self.xg = XMLGenerator(file, encoding=self.encoding)
def _beautify_newline(self, new_item=False):
if self.indent is not None and (self.indent > 0 or new_item):
self.xg.characters('\n')
def _beautify_indent(self, depth=1):
if self.indent:
self.xg.characters(' ' * self.indent * depth)
def start_exporting(self):
self.xg.startDocument()
self.xg.startElement(self.root_element, {})
self._beautify_newline(new_item=True)
def export_item(self, item):
self._beautify_indent(depth=1)
self.xg.startElement(self.item_element, {})
self._beautify_newline()
for name, value in self._get_serialized_fields(item, default_value=''):
self._export_xml_field(name, value, depth=2)
self._beautify_indent(depth=1)
self.xg.endElement(self.item_element)
self._beautify_newline(new_item=True)
def finish_exporting(self):
self.xg.endElement(self.root_element)
self.xg.endDocument()
def _export_xml_field(self, name, serialized_value, depth):
self._beautify_indent(depth=depth)
self.xg.startElement(name, {})
if hasattr(serialized_value, 'items'):
self._beautify_newline()
for subname, value in serialized_value.items():
self._export_xml_field(subname, value, depth=depth + 1)
self._beautify_indent(depth=depth)
elif is_listlike(serialized_value):
self._beautify_newline()
for value in serialized_value:
self._export_xml_field('value', value, depth=depth + 1)
self._beautify_indent(depth=depth)
elif isinstance(serialized_value, str):
self.xg.characters(serialized_value)
else:
self.xg.characters(str(serialized_value))
self.xg.endElement(name)
self._beautify_newline()
def __init__(self, destination, encoding):
XMLGenerator.__init__(self, destination, encoding)
def endElement(self, name):
"""End and XML element of the given name."""
XMLGenerator.endElement(self, name)
self.write(u'\n')
def test_xmlgen_pi(self):
result = self.ioclass()
gen = XMLGenerator(result)
gen.startDocument()
gen.processingInstruction('test', 'data')
gen.startElement('doc', {})
gen.endElement('doc')
gen.endDocument()
self.assertEqual(result.getvalue(),
self.xml('<?test data?><doc></doc>'))
def test_5027_2(self):
# The xml prefix (as in xml:lang below) is reserved and bound by
# definition to http://www.w3.org/XML/1998/namespace. XMLGenerator had
# a bug whereby a KeyError is thrown because this namespace is missing
# from a dictionary.
#
# This test demonstrates the bug by direct manipulation of the
# XMLGenerator.
result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startPrefixMapping('a', 'http://example.com/ns')
gen.startElementNS(('http://example.com/ns', 'g1'), 'g1', {})
lang_attr = {('http://www.w3.org/XML/1998/namespace', 'lang'): 'en'}
gen.startElementNS(('http://example.com/ns', 'g2'), 'g2', lang_attr)
gen.characters('Hello')
gen.endElementNS(('http://example.com/ns', 'g2'), 'g2')
gen.endElementNS(('http://example.com/ns', 'g1'), 'g1')
gen.endPrefixMapping('a')
gen.endDocument()
self.assertEqual(
result.getvalue(),
start + ('<a:g1 xmlns:a="http://example.com/ns">'
'<a:g2 xml:lang="en">Hello</a:g2>'
'</a:g1>'))
def check_parseString(self, s):
from xml.sax import parseString
result = StringIO()
parseString(s, XMLGenerator(result, 'utf-8'))
self.assertEqual(result.getvalue(), xml_bytes(self.data, 'utf-8'))
def test_xmlgen_content_empty(self):
result = self.ioclass()
gen = XMLGenerator(result, short_empty_elements=True)
gen.startDocument()
gen.startElement('doc', {})
gen.characters('huhei')
gen.endElement('doc')
gen.endDocument()
self.assertEqual(result.getvalue(), self.xml('<doc>huhei</doc>'))
def test_xmlgen_ignorable_empty(self):
result = StringIO()
gen = XMLGenerator(result, short_empty_elements=True)
gen.startDocument()
gen.startElement("doc", {})
gen.ignorableWhitespace(" ")
gen.endElement("doc")
gen.endDocument()
self.assertEqual(result.getvalue(), start + "<doc> </doc>")
def test_5027_2(self):
result = self.ioclass()
gen = XMLGenerator(result)
gen.startDocument()
gen.startPrefixMapping('a', 'http://example.com/ns')
gen.startElementNS(('http://example.com/ns', 'g1'), 'g1', {})
lang_attr = {('http://www.w3.org/XML/1998/namespace', 'lang'): 'en'}
gen.startElementNS(('http://example.com/ns', 'g2'), 'g2', lang_attr)
gen.characters('Hello')
gen.endElementNS(('http://example.com/ns', 'g2'), 'g2')
gen.endElementNS(('http://example.com/ns', 'g1'), 'g1')
gen.endPrefixMapping('a')
gen.endDocument()
self.assertEqual(
result.getvalue(),
self.xml(
'<a:g1 xmlns:a="http://example.com/ns"><a:g2 xml:lang="en">Hello</a:g2></a:g1>'
))
def test_xmlgen_ignorable_empty(self):
result = self.ioclass()
gen = XMLGenerator(result, short_empty_elements=True)
gen.startDocument()
gen.startElement('doc', {})
gen.ignorableWhitespace(' ')
gen.endElement('doc')
gen.endDocument()
self.assertEqual(result.getvalue(), self.xml('<doc> </doc>'))
def func(out):
gen = XMLGenerator(out)
gen.startDocument()
gen.startElement('doc', {})
def test_xmlgen_fragment(self):
result = self.ioclass()
gen = XMLGenerator(result)
gen.startElement('foo', {'a': '1.0'})
gen.characters('Hello')
gen.endElement('foo')
gen.startElement('bar', {'b': '2.0'})
gen.endElement('bar')
self.assertEqual(
result.getvalue(),
self.xml('<foo a="1.0">Hello</foo><bar b="2.0"></bar>')
[len(self.xml('')):])
def test_xmlgen_ns_empty(self):
result = self.ioclass()
gen = XMLGenerator(result, short_empty_elements=True)
gen.startDocument()
gen.startPrefixMapping('ns1', ns_uri)
gen.startElementNS((ns_uri, 'doc'), 'ns1:doc', {})
gen.startElementNS((None, 'udoc'), None, {})
gen.endElementNS((None, 'udoc'), None)
gen.endElementNS((ns_uri, 'doc'), 'ns1:doc')
gen.endPrefixMapping('ns1')
gen.endDocument()
self.assertEqual(
result.getvalue(),
self.xml('<ns1:doc xmlns:ns1="%s"><udoc/></ns1:doc>' % ns_uri))
def test_xmlgen_ns_empty(self):
result = StringIO()
gen = XMLGenerator(result, short_empty_elements=True)
gen.startDocument()
gen.startPrefixMapping("ns1", ns_uri)
gen.startElementNS((ns_uri, "doc"), "ns1:doc", {})
# add an unqualified name
gen.startElementNS((None, "udoc"), None, {})
gen.endElementNS((None, "udoc"), None)
gen.endElementNS((ns_uri, "doc"), "ns1:doc")
gen.endPrefixMapping("ns1")
gen.endDocument()
self.assertEqual(result.getvalue(), start + \
('<ns1:doc xmlns:ns1="%s"><udoc/></ns1:doc>' %
ns_uri))
