class xmlreport:
def __init__(self, filename, xslfile):
self.fp = open(filename, "wb")
self.xmlgen = XMLGenerator(self.fp, "utf-8")
self.xmlgen.startDocument()
self.xmlgen.processingInstruction("xml-stylesheet", 'type="text/xsl" href="{}"'.format(xslfile))
attrs = AttributesNSImpl({}, {})
self.xmlgen.startElementNS((None, "report"), "report", attrs)
def write(self, path, code, message):
attr_vals = {
(None, "code"): code,
(None, "path"): path
}
attr_qnames = {
(None, "code"): "code",
(None, "path"): "path"
}
attrs = AttributesNSImpl(attr_vals, attr_qnames)
self.xmlgen.startElementNS((None, "file"), "file", attrs)
self.xmlgen.characters(message)
self.xmlgen.endElementNS((None, "file"), "file")
def newline(self):
#self.fp.write("\n")
self.xmlgen.characters("\n")
def close(self):
self.xmlgen.endElementNS((None, "report"), "report")
self.xmlgen.endDocument()
self.fp.close()
def characters(self, content: str) -> None:
if content and re.search(r"[\x00-\x08\x0B-\x0C\x0E-\x1F]", content):
# Fail loudly when content has control chars (unsupported in XML 1.0)
# See http://www.w3.org/International/questions/qa-controls
raise UnserializableContentError(
"Control characters are not supported in XML 1.0")
XMLGenerator.characters(self, content)
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
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
class XmlItemExporter(BaseItemExporter):
def __init__(self, file, **kwargs):
self.item_element = kwargs.pop('item_element', 'item')
self.root_element = kwargs.pop('root_element', 'items')
self._configure(kwargs)
self.xg = XMLGenerator(file, encoding=self.encoding)
def start_exporting(self):
self.xg.startDocument()
self.xg.startElement(self.root_element, {})
def export_item(self, item):
self.xg.startElement(self.item_element, {})
for name, value in self._get_serialized_fields(item, default_value=''):
self._export_xml_field(name, value)
self.xg.endElement(self.item_element)
def finish_exporting(self):
self.xg.endElement(self.root_element)
self.xg.endDocument()
def _export_xml_field(self, name, serialized_value):
self.xg.startElement(name, {})
if hasattr(serialized_value, '__iter__'):
for value in serialized_value:
self._export_xml_field('value', value)
else:
self.xg.characters(serialized_value)
self.xg.endElement(name)
def execute(self, transform_manager, input):
with open(transform_manager('xml'), 'w') as output:
transform_manager.start(self, [input])
generator = XMLGenerator(output, encoding='utf-8')
generator.startDocument()
generator.startElement('TEI', {'xmlns':'http://www.tei-c.org/ns/1.0'})
generator.startElement('text', {})
generator.startElement('body', {})
for sheet in self.sheets(input):
generator.startElement('table', {})
generator.startElement('head', {})
generator.characters(sheet.name)
generator.endElement('head')
for i, row in enumerate(sheet.rows):
generator.startElement('row', {'n': unicode(int(i) + 1)})
for j, cell in enumerate(row.cells):
generator.startElement('cell', {'n': unicode(j + 1)})
generator.characters(unicode(cell))
generator.endElement('cell')
generator.endElement('row')
generator.endElement('table')
generator.endElement('body')
generator.endElement('text')
generator.endElement('TEI')
transform_manager.end([output.name])
return output.name
class BBXMLRepoint(BBXML):
"""Repoints filenames in the XML.
Silently converts paths to Windows-style path separators.
Arguments:
parser: the xml.sax.make_parser() object
output: the output file object
coords: a coordinate dictionary with int keys 'track' and 'clip'
newname: the new name for the clip at those coordinates
"""
def __init__(self, parser, output, coords, newname):
super().__init__(parser)
self._output = XMLGenerator(output)
self._coords = coords
# BitBox uses windows-style paths
self._newname = pathlib.PureWindowsPath(newname) if newname != '' else ''
def startElement(self, name, attrs):
super().startElement(name, attrs)
new_attrs = dict(attrs)
if name == 'clip':
if self._cur_track == self._coords['track'] and self._cur_clip == self._coords['clip']:
new_attrs['file'] = "0"
new_attrs['filename'] = str(self._newname)
self._output.startElement(name, new_attrs)
def endElement(self, name):
super().endElement(name)
self._output.endElement(name)
def characters(self, content):
self._output.characters(content)
class XmlFormat(ModelEventHandler):
def __init__(self, out):
self.xmlgen = XMLGenerator(out, 'utf-8')
def startDocument(self):
self.xmlgen.startDocument()
def startModel(self, model, attributes, **context):
logger.debug('xmlmodel.XmlFormat: model: %s, %s', model.__name__, attributes)
logger.debug('xmlmodel.XmlFormat: context: %s', context)
recordid = context.get('recordid', ('UNKNOWN', 'UNKNOWN', -1))
hwptag = context.get('hwptag', '')
logger.info('xmlmodel.XmlFormat: rec:%d %s', recordid[2], hwptag)
if model is Text:
text = attributes.pop('text')
else:
text = None
for x in startelement(context, self.xmlgen, (model, attributes)): x[0](*x[1:])
if model is Text and text is not None:
self.xmlgen.characters(text)
unparsed = context.get('unparsed', '')
if len(unparsed) > 0:
logger.debug('UNPARSED: %s', hexdump(unparsed, True))
def endModel(self, model):
self.xmlgen.endElement(model.__name__)
def endDocument(self):
self.xmlgen.endDocument()
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 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 raised 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 endElement(self, name):
"""
Signals the end of an element.
Data stored in global vars of the class, time to create our objects and fire their processing
@param name: the name of the element
@type name: str
@param attrs: of the element type as a string and the attrs parameter holds an object of the Attributes interface containing the attributes of the element.
@type attrs: Attributes
"""
self.ss_text = "".join(self.ss_text)
#get rid of annoying leading spaces
self.ss_text = self.ss_text.strip()
#all of the elements have to be declared here
#for each element, create the objects and clear "buffers"
if name == self.IN_TAG["src"]:
self.src = SimpleSentence(self.ss_text, self.ss_attributes)
self.ss_text = []
elif name == self.IN_TAG["tgt"]:
self.tgt.append(SimpleSentence(self.ss_text, self.ss_attributes))
self.ss_text = []
elif name == self.IN_TAG["sent"]:
#when the judged sentence gets closed, all previously inserted data have to be converted to objects
parallelsentence = ParallelSentence(self.src, self.tgt, self.ref, self.ps_attributes)
#apply feature generators
for fg in self.feature_generators:
parallelsentence = fg.add_features_parallelsentence(parallelsentence)
#parallelsentence.add_attributes( fg.get_features_parallelsentence(parallelsentence) )
#print parallelsentence
src = self.src
# #print src.get_string()
# for fg in self.feature_generators:
# src = fg.add_features_src(src, parallelsentence)
# #src.add_attributes( fg.get_features_src(src, parallelsentence) )
# parallelsentence.set_source(src)
#display modifications on output file
XMLGenerator._write(self, "\n\t")
XMLGenerator.startElement(self, name, parallelsentence.get_attributes())
XMLGenerator._write(self, "\n\t\t")
XMLGenerator.startElement(self, self.OUT_TAG["src"], src.get_attributes())
XMLGenerator.characters(self, src.get_string())
XMLGenerator.endElement(self, self.OUT_TAG["src"])
for tgt in parallelsentence.get_translations():
# for fg in self.feature_generators:
# tgt = fg.add_features_tgt(tgt, parallelsentence)
# #tgt.add_attributes( fg.get_features_tgt(tgt, parallelsentence) )
XMLGenerator._write(self, "\n\t\t")
XMLGenerator.startElement(self, self.OUT_TAG["tgt"], tgt.get_attributes())
XMLGenerator.characters(self, tgt.get_string())
XMLGenerator.endElement(self, self.OUT_TAG["tgt"])
XMLGenerator._write(self, "\n\t")
XMLGenerator.endElement(self, name)
class XmlWriter(AbstractXmlWriter):
def __init__(self, output):
self._output = self._create_output(output)
self._writer = XMLGenerator(self._output, encoding='UTF-8')
self._writer.startDocument()
self.closed = False
def _create_output(self, output):
return open(output, 'w') \
if isinstance(output, basestring) else output
def _start(self, name, attrs):
self._writer.startElement(name, AttributesImpl(attrs))
def _content(self, content):
self._writer.characters(content)
def _end(self, name):
self._writer.endElement(name)
def _newline(self):
self._output.write('\n')
# Workaround for http://ironpython.codeplex.com/workitem/29474
if sys.platform == 'cli':
def _escape(self, content):
return AbstractXmlWriter._escape(self, content).encode('UTF-8')
class xmlFile:
def __init__(self,
filename):
self._fp = open(filename, 'w')
self._xg = XMLGenerator(self._fp)
self._xg.startDocument()
self._xg.startElement(u'ConfigRoot', {})
def Write(self,
item,
val):
attrs = {'id' : "%04i" % (int(val[1])) }
self._xg.startElement(u'ConfigEntry', attrs)
self._xg.startElement(u'objID', {})
self._xg.characters(str(val[0]))
self._xg.endElement(u'objID')
self._xg.startElement(u'vmxCfgPath', {})
self._xg.characters(escape(item).encode('UTF-8'))
self._xg.endElement(u'vmxCfgPath')
self._xg.endElement(u'ConfigEntry')
def Close(self):
self._xg.endElement(u'ConfigRoot')
self._xg.endDocument()
self._fp.close()
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>'))
class XmlItemExporter(BaseItemExporter):
def __init__(self, file, **kwargs):
self.item_element = kwargs.pop('item_element', 'item')
self.root_element = kwargs.pop('root_element', 'items')
self._configure(kwargs)
self.xg = XMLGenerator(file, encoding=self.encoding)
def start_exporting(self):
self.xg.startDocument()
self.xg.startElement(self.root_element, {})
def export_item(self, item):
self.xg.startElement(self.item_element, {})
for name, value in self._get_serialized_fields(item, default_value=''):
self._export_xml_field(name, value)
self.xg.endElement(self.item_element)
def finish_exporting(self):
self.xg.endElement(self.root_element)
self.xg.endDocument()
def _export_xml_field(self, name, serialized_value):
self.xg.startElement(name, {})
if hasattr(serialized_value, '__iter__'):
for value in serialized_value:
self._export_xml_field('value', value)
else:
self.xg.characters(serialized_value)
self.xg.endElement(name)
class XmlLogger(object):
def __init__(self, path):
if os.access(path, os.F_OK):
os.rename(path, path + '.bak-' + str(load_time))
self.output = open(path, 'w')
self.xml_gen = XMLGenerator(self.output, 'utf-8')
self.lock = RLock()
def start_log(self, tag, attributes):
self.doc_tag = tag
with self.lock:
self.xml_gen.startDocument()
self.xml_gen.startElement(tag, attributes)
def end_log(self):
with self.lock:
self.xml_gen.endElement(self.doc_tag)
self.xml_gen.endDocument()
@contextmanager
def element(self, name, attrs={}):
with self.lock:
attrs = dict((key, str(value)) for key, value in attrs.items())
self.text('\n')
self.xml_gen.startElement(name, attrs)
yield
self.xml_gen.endElement(name)
def text(self, text):
with self.lock:
self.xml_gen.characters(str(text))
def output(self, stream = sys.stdout):
xg = XMLGenerator(stream, encoding='utf-8')
def elemWithContent(name, content):
xg.startElement(name, AttributesImpl({}))
if content is not None:
xg.characters(content)
xg.endElement(name)
xg.startElement("opml", AttributesImpl({'version': '1.1'}))
xg.characters("\n")
xg.startElement("head", AttributesImpl({}))
for key in ('title', 'dateCreated', 'dateModified', 'ownerName',
'ownerEmail', 'expansionState', 'vertScrollState',
'windowTop', 'windowBotton', 'windowRight', 'windowLeft'):
if self.has_key(key) and self[key] != "":
elemWithContent(key, self[key].encode('utf-8'))
xg.endElement("head")
xg.characters("\n")
xg.startElement("body", AttributesImpl({}))
for o in self.outlines:
o.output(xg)
xg.characters("\n")
xg.endElement("body")
xg.characters("\n")
xg.endElement("opml")
xg.characters("\n")
def dump_xml(self, output_dir):
"""
Dumps test result to xml
"""
self.buffer = False
with open(os.path.join(output_dir, 'junit.xml'), 'w') as output:
document = XMLGenerator(output, 'utf-8')
document.startDocument()
document.startElement('testsuites', AttributesImpl({}))
suites = groupby(self.testInfos, key=lambda test_info: self.test_case_name(test_info.test_method))
for suite_name, suite in suites:
document.startElement('testsuite', AttributesImpl({'name' : suite_name}))
for test_info in suite:
document.startElement('testcase', AttributesImpl({
'classname' : suite_name,
'name' : self.test_method_name(test_info.test_method),
'time' : '%3f' % total_seconds(test_info.end_time - test_info.start_time)
}))
if test_info.result == TestInfo.RESULT.ERROR:
document.startElement('error', AttributesImpl({
'message' : smart_text(test_info.err[1])
}))
document.characters(self._exc_info_to_string(test_info.err, test_info.test_method))
document.endElement('error')
elif test_info.result == TestInfo.RESULT.FAILURE:
document.startElement('failure', AttributesImpl({
'message' : smart_text(test_info.err[1])
}))
document.characters(self._exc_info_to_string(test_info.err, test_info.test_method))
document.endElement('failure')
elif test_info.result == TestInfo.RESULT.UNEXPECTED_SUCCESS:
document.startElement('error', AttributesImpl({
'message' : 'Unexpected success'
}))
document.endElement('error')
elif test_info.result == TestInfo.RESULT.SKIPPED:
document.startElement('skipped', AttributesImpl({}))
document.characters(test_info.reason)
document.endElement('skipped')
if test_info.stdout:
document.startElement('system-out', AttributesImpl({}))
document.characters(test_info.stdout)
document.endElement('system-out')
if test_info.stderr:
document.startElement('system-err', AttributesImpl({}))
document.characters(test_info.stderr)
document.endElement('system-err')
document.endElement('testcase')
document.endElement('testsuite')
document.endElement('testsuites')
document.endDocument()
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 XMLSerializer:
"""Serializes data to XML"""
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
raises a SerializationException
Params:
`data`: A dictionary containing the data to serialize
Return:
`xml`: 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):
"""
Parses data and creates the relative elements
Params:
`data`: Data to parse
`previous_element_tag`: When parsing a list we pass the previous element tag
"""
if isinstance(data, dict):
for key in data:
value = data[key]
self._parse(value, key)
elif isinstance(data, (list, tuple)):
for item in data:
self.generator.startElement(previous_element_tag, {})
self._parse(item, previous_element_tag)
self.generator.endElement(previous_element_tag)
else:
self.generator.startElement(previous_element_tag, {})
self.generator.characters("%s" % data)
self.generator.endElement(previous_element_tag)
def characters(self, content):
try:
if content.lstrip().startswith("<"):
etree.fromstring(content)
self._write(content)
else:
XMLGenerator.characters(self, content)
except:
XMLGenerator.characters(self, content)
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_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 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 characters(self, content):
try:
if content.lstrip().startswith("<"):
etree.fromstring(content)
self._write(content)
else:
XMLGenerator.characters(self, content)
except (AttributeError, ValueError, etree.XMLSyntaxError, Exception):
#TODO could be more specific on errors caught
XMLGenerator.characters(self, content)
def test_xmlgen_escaped_content():
result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startElement("doc", {})
gen.characters(unicode("\xa0\\u3042", "unicode-escape"))
gen.endElement("doc")
gen.endDocument()
return result.getvalue() == start + "<doc>\xa0あ</doc>"
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'))
class XMLStreamWriter(object):
""" class for writing an xml file iteratively """
def __init__(self, file_handle=None, header='<?xml version="1.0" ?>'):
""" initializes the writer with a stream to write to. If
`filehandle=None`, the output is written to sys.stdout """
if file_handle is None:
file_handle = sys.stdout
self.file_handle = file_handle
if header:
self.file_handle.write(header)
self._generator = XMLGenerator(file_handle, 'utf-8')
self._tags = []
def start_tag(self, name, attr=None, body=None, namespace=None):
""" start tag `name` with attributes `attr` and body `body` """
attr_vals = {}
attr_keys = {}
if attr is not None:
for key, val in attr.items():
key_tuple = (namespace, key)
attr_vals[key_tuple] = str(val)
attr_keys[key_tuple] = key
attr_obj = AttributesNSImpl(attr_vals, attr_keys)
self._generator.startElementNS((namespace, name), name, attr_obj)
if body:
self._generator.characters(str(body))
self._tags.append(name)
def end_tag(self, name=None, namespace=None):
""" and tag `name` """
close_tag = self._tags.pop()
if name is not None:
if name != close_tag:
raise ValueError('Cannot close tag `%s`, since the last opened '
'tag was `%s`' % (name, close_tag))
self._generator.endElementNS((namespace, name), name)
def tag(self, name, attr=None, body=None, namespace=None):
""" write tag `name` """
self.start_tag(name, attr, body, namespace)
self.end_tag(name, namespace)
def test_xmlgen_content_escape():
result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startElement("doc", {})
gen.characters("<huhei&")
gen.endElement("doc")
gen.endDocument()
return result.getvalue() == start + "<doc><huhei&</doc>"
def test_xmlgen_content(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_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_content_escape():
result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startElement("doc", {})
gen.characters("<huhei&")
gen.endElement("doc")
gen.endDocument()
return result.getvalue() == start + "<doc><huhei&</doc>"
def test_xmlgen_content(self):
result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startElement("doc", {})
gen.characters("huhei")
gen.endElement("doc")
gen.endDocument()
self.assertEqual(result.getvalue(), start + "<doc>huhei</doc>")
def test_xmlgen_escaped_content():
result = StringIO()
gen = XMLGenerator(result)
gen.startDocument()
gen.startElement("doc", {})
gen.characters(unicode("\xa0\\u3042", "unicode-escape"))
gen.endElement("doc")
gen.endDocument()
return result.getvalue() == start + "<doc>\xa0あ</doc>"
def test_xmlgen_content_empty(self):
result = StringIO()
gen = XMLGenerator(result, short_empty_elements=True)
gen.startDocument()
gen.startElement("doc", {})
gen.characters("huhei")
gen.endElement("doc")
gen.endDocument()
self.assertEqual(result.getvalue(), start + "<doc>huhei</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_unencodable(self):
result = self.ioclass()
gen = XMLGenerator(result, encoding='ascii')
gen.startDocument()
gen.startElement("doc", {"a": '\u20ac'})
gen.characters("\u20ac")
gen.endElement("doc")
gen.endDocument()
self.assertEqual(result.getvalue(),
self.xml('<doc a="€">€</doc>', encoding='ascii'))
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_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(),
start + "<doc><huhei&</doc>")
class XmlItemExporter(BaseItemExporter):
def __init__(self, file, **kwargs):
self.item_element = kwargs.pop('item_element', 'item')
self.root_element = kwargs.pop('root_element', 'items')
self._configure(kwargs)
if not self.encoding:
self.encoding = 'utf-8'
self.xg = XMLGenerator(file, encoding=self.encoding)
def start_exporting(self):
self.xg.startDocument()
self.xg.startElement(self.root_element, {})
def export_item(self, item):
self.xg.startElement(self.item_element, {})
for name, value in self._get_serialized_fields(item, default_value=''):
self._export_xml_field(name, value)
self.xg.endElement(self.item_element)
def finish_exporting(self):
self.xg.endElement(self.root_element)
self.xg.endDocument()
def _export_xml_field(self, name, serialized_value):
self.xg.startElement(name, {})
if hasattr(serialized_value, 'items'):
for subname, value in serialized_value.items():
self._export_xml_field(subname, value)
elif is_listlike(serialized_value):
for value in serialized_value:
self._export_xml_field('value', value)
elif isinstance(serialized_value, six.text_type):
self._xg_characters(serialized_value)
else:
self._xg_characters(str(serialized_value))
self.xg.endElement(name)
# Workaround for http://bugs.python.org/issue17606
# Before Python 2.7.4 xml.sax.saxutils required bytes;
# since 2.7.4 it requires unicode. The bug is likely to be
# fixed in 2.7.6, but 2.7.6 will still support unicode,
# and Python 3.x will require unicode, so ">= 2.7.4" should be fine.
if sys.version_info[:3] >= (2, 7, 4):
def _xg_characters(self, serialized_value):
if not isinstance(serialized_value, six.text_type):
serialized_value = serialized_value.decode(self.encoding)
return self.xg.characters(serialized_value)
else: # pragma: no cover
def _xg_characters(self, serialized_value):
return self.xg.characters(serialized_value)
def test_xmlgen_unencodable(self):
result = self.ioclass()
gen = XMLGenerator(result, encoding='ascii')
gen.startDocument()
gen.startElement("doc", {"a": u'\u20ac'})
gen.characters(u"\u20ac")
gen.endElement("doc")
gen.endDocument()
self.assertEqual(
result.getvalue(), '<?xml version="1.0" encoding="ascii"?>\n'
'<doc a="€">€</doc>')
def test_xmlgen_unencodable(self):
result = self.ioclass()
gen = XMLGenerator(result, encoding='ascii')
gen.startDocument()
gen.startElement("doc", {"a": u'\u20ac'})
gen.characters(u"\u20ac")
gen.endElement("doc")
gen.endDocument()
self.assertEqual(result.getvalue(),
'<?xml version="1.0" encoding="ascii"?>\n'
'<doc a="€">€</doc>')
class XmlItemExporter(BaseItemExporter):
def __init__(self, file, **kwargs):
self.item_element = kwargs.pop("item_element", "item")
self.root_element = kwargs.pop("root_element", "items")
self._configure(kwargs)
self.xg = XMLGenerator(file, encoding=self.encoding)
def start_exporting(self):
self.xg.startDocument()
self.xg.startElement(self.root_element, {})
def export_item(self, item):
self.xg.startElement(self.item_element, {})
for name, value in self._get_serialized_fields(item, default_value=""):
self._export_xml_field(name, value)
self.xg.endElement(self.item_element)
def finish_exporting(self):
self.xg.endElement(self.root_element)
self.xg.endDocument()
def _export_xml_field(self, name, serialized_value):
self.xg.startElement(name, {})
if hasattr(serialized_value, "items"):
for subname, value in serialized_value.items():
self._export_xml_field(subname, value)
elif is_listlike(serialized_value):
for value in serialized_value:
self._export_xml_field("value", value)
elif isinstance(serialized_value, six.text_type):
self._xg_characters(serialized_value)
else:
self._xg_characters(str(serialized_value))
self.xg.endElement(name)
# Workaround for http://bugs.python.org/issue17606
# Before Python 2.7.4 xml.sax.saxutils required bytes;
# since 2.7.4 it requires unicode. The bug is likely to be
# fixed in 2.7.6, but 2.7.6 will still support unicode,
# and Python 3.x will require unicode, so ">= 2.7.4" should be fine.
if sys.version_info[:3] >= (2, 7, 4):
def _xg_characters(self, serialized_value):
if not isinstance(serialized_value, six.text_type):
serialized_value = serialized_value.decode(self.encoding)
return self.xg.characters(serialized_value)
else: # pragma: no cover
def _xg_characters(self, serialized_value):
return self.xg.characters(serialized_value)
def test_xmlgen_encoding(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('€')
gen.endElement('doc')
gen.endDocument()
self.assertEqual(
result.getvalue(),
self.xml('<doc a="€">€</doc>', encoding=encoding))
def store(self):
self.makeId("blogentry")
log.debug("storing BlogEntry %s/%d" % (self.datetime[0], self.id))
try:
outf = TransactionalFile(
BlogEntry.determineFileName(self.getStoragePath(),
self.datetime[0], self.id), "wb")
gen = XMLGenerator(out=outf, encoding="UTF-8")
gen.startDocument()
gen.startElement("blogentry", {"id": str(self.id)})
gen.characters("\n")
for attr in self.__slots__:
if attr == "datetime":
gen.startElement("timestamp", {
"date": self.datetime[0],
"time": self.datetime[1]
})
gen.endElement("timestamp")
gen.characters("\n")
else:
# other attribute
gen.startElement(attr, {})
gen.characters(getXMLvalue(self, attr))
gen.endElement(attr)
gen.characters('\n')
gen.endElement("blogentry")
gen.endDocument()
outf.commit()
os.chmod(outf.name, FILEPROT)
except EnvironmentError, x:
raise StorageError(str(x))
def test_xmlgen_fragment(self):
result = self.ioclass()
gen = XMLGenerator(result)
# Don't call gen.startDocument()
gen.startElement("foo", {"a": "1.0"})
gen.characters("Hello")
gen.endElement("foo")
gen.startElement("bar", {"b": "2.0"})
gen.endElement("bar")
# Don't call gen.endDocument()
self.assertEqual(result.getvalue(),
'<foo a="1.0">Hello</foo><bar b="2.0"></bar>')
def save(self, filename=None):
if self.filename and filename is None: filename = self.filename
if len(self.__dict__) == 0 or filename == None: return
try:
fileobj = open(filename, 'w')
except:
print 'ERROR>>> cannot write preferences into %s' % filename
return
writer = XMLGenerator(out=fileobj, encoding=self.system_encoding)
writer.startDocument()
defaults = XmlConfigParser.__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
if key in ['filename', 'app']: continue
writer.characters('\t')
writer.startElement('%s' % key, {})
str_value = path_unicode(value.__str__())
if isinstance(value, str):
str_value = "'%s'" % (escape_quote(str_value))
writer.characters(str_value)
writer.endElement('%s' % key)
writer.characters('\n')
writer.endElement('preferences')
writer.endDocument()
fileobj.close
def test_xmlgen_fragment(self):
result = self.ioclass()
gen = XMLGenerator(result)
# Don't call gen.startDocument()
gen.startElement("foo", {"a": "1.0"})
gen.characters("Hello")
gen.endElement("foo")
gen.startElement("bar", {"b": "2.0"})
gen.endElement("bar")
# Don't call gen.endDocument()
self.assertEqual(result.getvalue(),
self.xml('<foo a="1.0">Hello</foo><bar b="2.0"></bar>')[len(self.xml('')):])
class BBXMLOverwrite(BBXML):
"""Overwrites clip metadata in the XML.
Arguments:
parser: the xml.sax.make_parser() object
output: the output file object
coords: a coordinate dictionary with int keys 'track' and 'clip'
clipdata: a dictionary of clip data as returned by clips()
"""
def __init__(self, parser, output, coords, clipdata):
super().__init__(parser)
self._output = XMLGenerator(output)
self._coords = coords
self._clipdata = clipdata
self._in_clip = False
def startElement(self, name, attrs):
super().startElement(name, attrs)
new_attrs = dict(attrs)
if name == 'clip':
self._in_clip = True
if self._cur_track == self._coords['track'] and self._cur_clip == self._coords['clip']:
for k in self._clipdata:
if k == 'slices':
continue
new_attrs[k] = str(self._clipdata[k])
self._output.startElement(name, new_attrs)
self._output.characters('\n ')
self._output.startElement('slices', {})
for sl in self._clipdata['slices']:
self._output.characters('\n ')
self._output.startElement('slice', {'pos': sl})
self._output.endElement('slice')
if self._clipdata['slices']:
self._output.characters('\n ')
self._output.endElement('slices')
return
if name.startswith('slice'):
if self._cur_track == self._coords['track'] and self._cur_clip == self._coords['clip']:
return
self._output.startElement(name, new_attrs)
def endElement(self, name):
super().endElement(name)
# To make whitespace preservation work, we say we're done with a clip after
# we see the close tag for the slices.
if name == 'slices':
self._in_clip = False
if name.startswith('slice'):
if self._cur_track == self._coords['track'] and self._cur_clip == self._coords['clip']:
return
self._output.endElement(name)
def characters(self, content):
if self._in_clip:
if self._cur_track == self._coords['track'] and self._cur_clip == self._coords['clip']:
return
self._output.characters(content)
def xml_node( self, node ):
if node not in self.nodes:
raise ValueError("Unknown node.")
output = cStringIO.StringIO()
gen = XMLGenerator( output, 'utf-8' )
gen.startDocument()
output.write('<!DOCTYPE storage-mapping>\n')
gen.startElement('storage-mapping',{})
gen.characters('\n\t\t')
self.nodes[node].xml(gen)
gen.endElement('storage-mapping')
gen.characters('\n')
gen.endDocument()
cherrypy.response.headers['Content-Type'] = 'text/xml'
return output.getvalue()
def get_check_result_as_xml(status, comment=None):
out = StringIO.StringIO("")
g = XMLGenerator(out, encoding='UTF-8')
g.startDocument()
g.startElement("response", {})
g.startElement("result", {})
g.characters(status)
g.endElement("result")
if comment:
g.startElement("comment", {})
g.characters(comment)
g.endElement("comment")
g.endElement("response")
g.endDocument()
return out.getvalue()
def xml_node(self, node):
if node not in self.nodes:
raise ValueError("Unknown node.")
output = StringIO.StringIO()
gen = XMLGenerator(output, 'utf-8')
gen.startDocument()
output.write('<!DOCTYPE storage-mapping>\n')
gen.startElement('storage-mapping', {})
gen.characters('\n\t\t')
self.nodes[node].xml(gen)
gen.endElement('storage-mapping')
gen.characters('\n')
gen.endDocument()
cherrypy.response.headers['Content-Type'] = 'text/xml'
return output.getvalue()
def endElement(self, name):
if self.founditem:
if name == "user":
self.founditem = False
XMLGenerator.startElement(self, 'user', self.user_attrs)
for id_, naam, tekst in self.cats:
XMLGenerator.startElement(self, "categorie", {
"id": str(id_),
"naam": naam
})
XMLGenerator.characters(self, tekst)
XMLGenerator.endElement(self, "categorie")
XMLGenerator.endElement(self, 'user')
else:
XMLGenerator.endElement(self, name)
class _PrettyXMLWriter(object):
def __init__(self,
output,
encoding='UTF-8',
namespace=('bibtex', 'http://bibtexml.sf.net/'),
header=True):
self.prefix, self.uri = namespace
self.generator = XMLGenerator(output, encoding=encoding)
if header:
self.generator.startDocument()
self.generator.startPrefixMapping(self.prefix, self.uri)
self.stack = []
def write(self, data):
self.generator.characters(data)
def newline(self):
self.write('\n')
def indent_line(self):
self.write(' ' * (len(self.stack) * 4))
def start(self, tag, attrs=None, newline=True):
if attrs is None:
attrs = {}
else:
attrs = {(None, key): value for key, value in attrs.items()}
self.indent_line()
self.stack.append(tag)
self.generator.startElementNS((self.uri, tag), tag,
AttributesImpl(attrs))
if newline:
self.newline()
def end(self, indent=True):
tag = self.stack.pop()
if indent:
self.indent_line()
self.generator.endElementNS((self.uri, tag), tag)
self.newline()
def element(self, tag, data):
self.start(tag, newline=False)
self.write(data)
self.end(indent=False)
def close(self):
self.generator.endDocument()
def xml(self):
"""generate XML version of a configuration message"""
out = StringIO()
generator = XMLGenerator(out)
# "stringify" entries for XML conversion
state = {}
for k in self.attr:
state[k] = str(getattr(self, k))
generator.startElement('message', state)
generator.characters(self.data)
generator.endElement('message')
xml_msg = out.getvalue()
out.close()
return xml_msg
def test_xmlgen_encoding(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": '\u20ac'})
gen.characters("\u20ac")
gen.endElement("doc")
gen.endDocument()
self.assertEqual(result.getvalue(),
self.xml('<doc a="\u20ac">\u20ac</doc>', encoding=encoding))
def startDocument( self, output, encoding='UTF-8' ):
gen = XMLGenerator( output, encoding )
gen.startDocument()
try:
static_location = '/static/content'
static_object = self.globals['static']
static_location = static_object.metadata.get('base_url','/static')
static_location += '/content'
except:
pass
output.write('<?xml-stylesheet type="text/xsl" href="%s/%s"?>\n' % \
(static_location, self.XSLT_NAME) )
output.write('<!DOCTYPE graphtool-data>\n')
gen.startElement('graphtool',{})
gen.characters("\n\t")
return gen
def test_xmlgen_encoding(self):
encodings = ('iso-8859-15', 'utf-8',
'utf-16be', 'utf-16le',
'utf-32be', 'utf-32le')
for encoding in encodings:
result = self.ioclass()
gen = XMLGenerator(result, encoding=encoding)
gen.startDocument()
gen.startElement("doc", {"a": u'\u20ac'})
gen.characters(u"\u20ac")
gen.endElement("doc")
gen.endDocument()
self.assertEqual(result.getvalue(), (
u'<?xml version="1.0" encoding="%s"?>\n'
u'<doc a="\u20ac">\u20ac</doc>' % encoding
).encode(encoding, 'xmlcharrefreplace'))