def _prettywrite(self, file, node, encoding, namespaces, depth=0):
# write XML to file
tag = node.tag
if tag is Comment:
file.write("\r\n" + " " * depth)
file.write("<!-- %s -->" % _escape_cdata(node.text, encoding))
elif tag is ProcessingInstruction:
file.write("\r\n" + " " * depth)
file.write("<?%s?>" % _escape_cdata(node.text, encoding))
else:
items = node.items()
xmlns_items = [] # new namespaces in this scope
try:
if isinstance(tag, QName) or tag[:1] == "{":
tag, xmlns = myfixtag(tag, namespaces)
if xmlns:
xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(tag)
file.write("\r\n" + " " * depth)
file.write("<" + _encode(tag, encoding))
if items or xmlns_items:
items.sort() # lexical order
for k, v in items:
try:
if isinstance(k, QName) or k[:1] == "{":
k, xmlns = myfixtag(k, namespaces)
if xmlns:
xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(k)
try:
if isinstance(v, QName):
v, xmlns = myfixtag(v, namespaces)
if xmlns:
xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(v)
file.write(" %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding)))
for k, v in xmlns_items:
file.write(" %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding)))
if node.text or len(node):
file.write(">")
if node.text:
file.write(_escape_cdata(node.text, encoding))
for n in node:
self._prettywrite(file, n, encoding, namespaces, depth=depth + 1)
if not node.text or len(node):
file.write("\r\n" + " " * depth)
file.write("</" + _encode(tag, encoding) + ">")
else:
file.write(" />")
for k, v in xmlns_items:
del namespaces[v]
if node.tail:
file.write(_escape_cdata(node.tail, encoding))
def _serialize_xml(write, elem, qnames, namespaces, short_empty_elements,
**kwargs):
tag = elem.tag
text = elem.text
if tag is Comment:
write("<!--%s-->" % text)
elif tag is ProcessingInstruction:
write("<?%s?>" % text)
else:
tag = qnames[tag]
if tag is None:
if text:
write(_escape_cdata(text))
for e in elem:
_serialize_xml(write,
e,
qnames,
None,
short_empty_elements=short_empty_elements)
else:
write("<" + tag)
items = list(elem.items())
if items or namespaces:
if namespaces:
for v, k in sorted(namespaces.items(),
key=lambda x: x[1]): # sort on prefix
if k:
k = ":" + k
write(" xmlns%s=\"%s\"" % (k, _escape_attrib(v)))
# below is the changed line. assuming attrib is an OrderedDict this will preserve attribute order
for k, v in elem.attrib.items():
if isinstance(k, QName):
k = k.text
if isinstance(v, QName):
v = qnames[v.text]
else:
v = _escape_attrib(v)
write(" %s=\"%s\"" % (qnames[k], v))
if text or len(elem) or not short_empty_elements:
write(">")
if text:
write(_escape_cdata(text))
for e in elem:
_serialize_xml(write,
e,
qnames,
None,
short_empty_elements=short_empty_elements)
write("</" + tag + ">")
else:
write(" />")
if elem.tail:
write(_escape_cdata(elem.tail))
def Etree_pretty__write(self, file, node, encoding, namespaces,
level=0, identator=" "):
tag = node.tag
if tag is Comment:
file.write(level * identator + "<!-- %s -->" % _escape_cdata(node.text, encoding))
elif tag is ProcessingInstruction:
file.write("<?%s?>" % _escape_cdata(node.text, encoding))
else:
items = node.items()
xmlns_items = [] # new namespaces in this scope
try:
if isinstance(tag, QName) or tag[:1] == "{":
tag, xmlns = fixtag(tag, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
raise #_raise_serialization_error(tag)
file.write("\n" + level * identator + "<" + _encode(tag, encoding))
if items or xmlns_items:
items.sort() # lexical order
for k, v in items:
try:
if isinstance(k, QName) or k[:1] == "{":
k, xmlns = fixtag(k, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
raise #_raise_serialization_error(k)
try:
if isinstance(v, QName):
v, xmlns = fixtag(v, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
raise #_raise_serialization_error(v)
file.write(u" %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding)))
for k, v in xmlns_items:
file.write(u" %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding)))
if node.text or len(node):
file.write(">")
if node.text:
file.write(_escape_cdata(node.text.replace("\n", (level + 1) * identator + "\n"), encoding))
for n in node:
self._write(file, n, encoding, namespaces, level + 1, identator)
if node.text and len(node.text) < 125:
file.write("</" + _encode(tag, encoding) + ">")
else:
file.write("\n" + level * identator + "</" + _encode(tag, encoding) + ">")
else:
file.write(" />")
for k, v in xmlns_items:
del namespaces[v]
if node.tail:
file.write(_escape_cdata(node.tail.replace("\n", level * identator + "\n"), encoding))
def Etree_pretty__write(self, file, node, encoding, namespaces,
level=0, identator=" "):
tag = node.tag
if tag is Comment:
file.write(level * identator + "<!-- %s -->" % _escape_cdata(node.text, encoding))
elif tag is ProcessingInstruction:
file.write("<?%s?>" % _escape_cdata(node.text, encoding))
else:
items = node.items()
xmlns_items = [] # new namespaces in this scope
try:
if isinstance(tag, QName) or tag[:1] == "{":
tag, xmlns = fixtag(tag, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
raise #_raise_serialization_error(tag)
file.write("\n" + level * identator + "<" + _encode(tag, encoding))
if items or xmlns_items:
items.sort() # lexical order
for k, v in items:
try:
if isinstance(k, QName) or k[:1] == "{":
k, xmlns = fixtag(k, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
raise #_raise_serialization_error(k)
try:
if isinstance(v, QName):
v, xmlns = fixtag(v, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
raise #_raise_serialization_error(v)
file.write(u" %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding)))
for k, v in xmlns_items:
file.write(u" %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding)))
if node.text or len(node):
file.write(">")
if node.text:
file.write(_escape_cdata(node.text, encoding))
for n in node:
self._write(file, n, encoding, namespaces, level + 1, identator)
if node.text and len(node.text) < 125:
file.write("</" + _encode(tag, encoding) + ">")
else:
file.write("\n" + level * identator + "</" + _encode(tag, encoding) + ">")
else:
file.write(" />")
for k, v in xmlns_items:
del namespaces[v]
if node.tail:
file.write(_escape_cdata(node.tail.replace("\n", (level * identator )+ "\n"), encoding))
def _print_node(self, node, encoding):
tree_string = ""
tag = node.tag
if tag is Comment:
tree_string += "<!-- %s -->" % _escape_cdata(node.text, encoding)
elif tag is ProcessingInstruction:
tree_string += "<?%s?>" % _escape_cdata(node.text, encoding)
else:
items = node.items()
xmlns_items = [] # new namespaces in this scope
try:
if isinstance(tag, QName) or tag[:1] == "{":
tag, xmlns = fixtag(tag, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(tag)
tree_string += "<" + _encode(tag, encoding)
if items or xmlns_items:
items.sort() # lexical order
for k, v in items:
try:
if isinstance(k, QName) or k[:1] == "{":
k, xmlns = fixtag(k, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(k)
try:
if isinstance(v, QName):
v, xmlns = fixtag(v, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(v)
tree_string += " %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding))
for k, v in xmlns_items:
tree_string += " %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding))
tree_string += ">"
if node.text:
tree_string += _escape_cdata(node.text, encoding).replace('"', '"')
for n in node:
tree_string += self._print_node(n, encoding)
tree_string += "</" + _encode(tag, encoding) + ">"
for k, v in xmlns_items:
del namespaces[v]
if node.tail:
tree_string += _escape_cdata(node.tail, encoding)
return tree_string
def _escape(self, val):
result = None
if isinstance(val, (str, unicode)):
result = _escape_cdata(val)
else:
try:
strval = val.__str__()
except:
pass
else:
result = _escape_cdata(strval)
return result
def _escape(self, val):
result = None
if isinstance(val, (str, unicode)):
result = _escape_cdata(val)
else:
try:
strval = val.__str__()
except:
pass
else:
result = _escape_cdata(strval)
return result
def _serialize_xml(write, elem, qnames, namespaces,
short_empty_elements, **kwargs):
tag = elem.tag
text = elem.text
if tag is Comment:
write("<!--%s-->" % text)
elif tag is ProcessingInstruction:
write("<?%s?>" % text)
else:
tag = qnames[tag]
if tag is None:
if text:
write(_escape_cdata(text))
for e in elem:
_serialize_xml(write, e, qnames, None,
short_empty_elements=short_empty_elements)
else:
write("<" + tag)
items = list(elem.items())
if items or namespaces:
if namespaces:
for v, k in sorted(namespaces.items(),
key=lambda x: x[1]): # sort on prefix
if k:
k = ":" + k
write(" xmlns%s=\"%s\"" % (
k,
_escape_attrib(v)
))
# below is the changed line. assuming attrib is an OrderedDict this will preserve attribute order
for k, v in elem.attrib.items():
if isinstance(k, QName):
k = k.text
if isinstance(v, QName):
v = qnames[v.text]
else:
v = _escape_attrib(v)
write(" %s=\"%s\"" % (qnames[k], v))
if text or len(elem) or not short_empty_elements:
write(">")
if text:
write(_escape_cdata(text))
for e in elem:
_serialize_xml(write, e, qnames, None,
short_empty_elements=short_empty_elements)
write("</" + tag + ">")
else:
write(" />")
if elem.tail:
write(_escape_cdata(elem.tail))
def _serialize_xml(write, elem, qnames, namespaces, short_empty_elements,
**kwargs):
tag = elem.tag
text = elem.text
if tag is Comment:
write("<!--%s-->" % text)
elif tag is ProcessingInstruction:
write("<?%s?>" % text)
else:
tag = qnames[tag]
if tag is None:
if text:
write(_escape_cdata(text))
for e in elem:
_serialize_xml(write,
e,
qnames,
None,
short_empty_elements=short_empty_elements)
else:
write("<" + tag)
items = list(elem.items())
if items or namespaces:
if namespaces:
for v, k in namespaces.items(): # sort on prefix
if k:
k = ":" + k
write(" xmlns%s=\"%s\"" % (k, _escape_attrib(str(v))))
for k, v in items: # lexical order
if isinstance(k, QName):
k = k.text
if isinstance(v, QName):
v = qnames[v.text]
else:
v = _escape_attrib(str(v))
write(" %s=\"%s\"" % (qnames[k], v))
if text or len(elem) or not short_empty_elements:
write(">")
if text:
write(_escape_cdata(text))
for e in elem:
_serialize_xml(write,
e,
qnames,
None,
short_empty_elements=short_empty_elements)
write("</" + tag + ">")
else:
write(" />")
if elem.tail:
write(_escape_cdata(elem.tail))
def _escape(self, vals):
results = []
for val in vals:
result = None
if isinstance(val, (str, unicode)):
result = _escape_cdata(val, 'utf-8')
else:
try:
strval = val.__str__()
except:
pass
else:
result = _escape_cdata(strval, 'utf-8')
if result is not None:
results.append(result)
return results
def _escape(self, vals):
results = []
for val in vals:
result = None
if isinstance(val, (str, unicode)):
result = _escape_cdata(val, 'utf-8')
else:
try:
strval = val.__str__()
except:
pass
else:
result = _escape_cdata(strval, 'utf-8')
if result is not None:
results.append(result)
return results
def _serialize_xml(write, elem, qnames, namespaces, short_empty_elements,
**kwargs):
if elem.tag == '![CDATA[':
write("\n<{}{}]]>\n".format(elem.tag, elem.text))
if elem.tail:
write(_escape_cdata(elem.tail))
else:
return ElementTree._original_serialize_xml(write, elem, qnames,
namespaces,
short_empty_elements,
**kwargs)
def _write(self, file, node, encoding, namespaces, sortflag="default", sortcmp=None): # don't break existing code that relies on _write()s parameters, if any
# write XML to file
tag = node.tag
if tag is Comment:
file.write("<!-- %s -->" % _escape_cdata(node.text, encoding))
elif tag is ProcessingInstruction:
file.write("<?%s?>" % _escape_cdata(node.text, encoding))
else:
items = node.items()
xmlns_items = [] # new namespaces in this scope
try:
if isinstance(tag, QName) or tag[:1] == "{":
tag, xmlns = fixtag(tag, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(tag)
file.write("<" + _encode(tag, encoding))
if items or xmlns_items:
##NEW
if sortflag!="default":
if ":" not in sortflag:
sortflag = ":"+sortflag
sortitems = sortflag.split(";")
try:
sortitems = [[tagdef.split(":")[0], tagdef.split(":")[1].split(",")] for tagdef in sortitems]
temp = []
for tagdef in sortitems:
if tagdef[0] in node.tag:
for sortitem in tagdef[1]:
temp.extend([i for i in items if sortitem in i]) # add what matches pattern
break
# then sort and add what's left
items.sort(cmp=sortcmp)
temp.extend([i for i in items if i not in temp])
items = temp
except IndexError:
sys.stderr.write("sortflag not formatted correctly, order won't be applied")
try:
items.sort(cmp=sortcmp)
except:
sys.stderr.write("sortcmp not a valid comparator, sorting alphabetically instead")
items.sort()
else:
try:
items.sort(cmp=sortcmp)
except:
sys.stderr.write("sortcmp not a valid comparator, sorting alphabetically instead")
items.sort()
###
for k, v in items:
try:
if isinstance(k, QName) or k[:1] == "{":
k, xmlns = fixtag(k, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(k)
try:
if isinstance(v, QName):
v, xmlns = fixtag(v, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(v)
file.write(" %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding)))
for k, v in xmlns_items:
file.write(" %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding)))
if node.text or len(node):
file.write(">")
if node.text:
file.write(_escape_cdata(node.text, encoding))
for n in node:
self._write(file, n, encoding, namespaces, sortflag, sortcmp)
file.write("</" + _encode(tag, encoding) + ">")
else:
file.write(" />")
for k, v in xmlns_items:
del namespaces[v]
if node.tail:
file.write(_escape_cdata(node.tail, encoding))
def to_string(node, omit_attributes, omit_classes, include_classes, include_attributes):
if isinstance(node, basestring):
return _escape_cdata(node, 'ascii').rstrip()
else:
indent(node, omit_attributes, omit_classes, include_classes, include_attributes)
return etree.tostring(node, pretty_print=True).rstrip()
def _serialize_xml(write,
elem,
qnames,
namespaces,
short_empty_elements,
addintend=" ",
intend="",
newl="\n",
**kwargs):
tag = elem.tag
text = elem.text
if tag is Comment:
write(intend + "<!--%s-->" % text)
elif tag is ProcessingInstruction:
write(intend + "<?%s?>" % text)
else:
tag = qnames[tag]
if tag is None:
if text:
write(_escape_cdata(text))
for e in elem:
_serialize_xml(write,
e,
qnames,
None,
addintend=addintend,
intend=addintend + intend,
newl=newl,
short_empty_elements=short_empty_elements)
else:
write(intend + "<" + tag)
items = list(elem.items())
if items or namespaces:
if namespaces:
for v, k in sorted(namespaces.items(),
key=lambda x: x[1]): # sort on prefix
if k:
k = ":" + k
write(" xmlns%s=\"%s\"" % (k, _escape_attrib(v)))
for k, v in sorted(items): # lexical order
if isinstance(k, QName):
k = k.text
if isinstance(v, QName):
v = qnames[v.text]
else:
v = _escape_attrib(v)
write(" %s=\"%s\"" % (qnames[k], v))
if text or len(elem) or not short_empty_elements:
write(">")
if text is not None:
write(_escape_cdata(text))
else:
if len(elem.getchildren()) > 0:
write(newl)
for e in elem:
_serialize_xml(write,
e,
qnames,
None,
addintend=addintend,
intend=addintend + intend,
newl=newl,
short_empty_elements=short_empty_elements)
if len(elem.getchildren()) > 0:
write(intend)
write("</" + tag + ">" + newl)
else:
write(" />" + newl)
if elem.tail:
write(_escape_cdata(elem.tail))
def _prettywrite(self, file, node, encoding, namespaces, depth=0):
# write XML to file
tag = node.tag
if tag is Comment:
file.write("\r\n" + " " * depth)
file.write("<!-- %s -->" % _escape_cdata(node.text, encoding))
elif tag is ProcessingInstruction:
file.write("\r\n" + " " * depth)
file.write("<?%s?>" % _escape_cdata(node.text, encoding))
else:
items = node.items()
xmlns_items = [] # new namespaces in this scope
try:
if isinstance(tag, QName) or tag[:1] == "{":
tag, xmlns = myfixtag(tag, namespaces)
if xmlns:
xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(tag)
file.write("\r\n" + " " * depth)
file.write("<" + _encode(tag, encoding))
if items or xmlns_items:
items.sort() # lexical order
for k, v in items:
try:
if isinstance(k, QName) or k[:1] == "{":
k, xmlns = myfixtag(k, namespaces)
if xmlns:
xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(k)
try:
if isinstance(v, QName):
v, xmlns = myfixtag(v, namespaces)
if xmlns:
xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(v)
file.write(
" %s=\"%s\"" %
(_encode(k, encoding), _escape_attrib(v, encoding)))
for k, v in xmlns_items:
file.write(
" %s=\"%s\"" %
(_encode(k, encoding), _escape_attrib(v, encoding)))
if node.text or len(node):
file.write(">")
if node.text:
file.write(_escape_cdata(node.text, encoding))
for n in node:
self._prettywrite(file,
n,
encoding,
namespaces,
depth=depth + 1)
if not node.text or len(node):
file.write("\r\n" + " " * depth)
file.write("</" + _encode(tag, encoding) + ">")
else:
file.write(" />")
for k, v in xmlns_items:
del namespaces[v]
if node.tail:
file.write(_escape_cdata(node.tail, encoding))
