def from_dataframe(cls, df, **kwargs):
if isinstance(df, pandas.DataFrame):
return xml.etree.ElementTree.fromstring(
df.to_html(**kwargs),
parser=XMLParser(target=TreeBuilder(element_factory=cls)))
elif isinstance(df, pandas.io.formats.style.Styler):
render = df.render()
render = re.sub(r"colspan=([1234567890]*)>", "colspan=\"\g<1>\">",
render, 0)
try:
return xml.etree.ElementTree.fromstring(
f"<div>{render}</div>",
parser=XMLParser(target=TreeBuilder(element_factory=cls)))
except Exception as parse_err:
if type(parse_err).__name__ == 'ParseError':
x = Elem('div')
x << xml.etree.ElementTree.fromstring(
df.data.to_html(**kwargs),
parser=XMLParser(target=TreeBuilder(
element_factory=cls)))
x << Elem('pre', text=render)
x << Elem('pre', text=str(parse_err))
return x
else:
raise
def __init__(self, html=0, target=None, encoding=None):
try:
from xml.parser import expat
except ImportError:
try:
import pyexpat as expat
except ImportError:
raise ImportError("No module named expat")
self.parser = expat.ParserCreate(encoding, "}")
if target is None:
target = TreeBuilder()
self.target = target
self._error = expat.error
self._names = {}
self.entity = {}
parser = self.parser
parser.DefaultHandlerExpand = self._default
for k, v in {
"start": (self._start, "StartElementHandler"),
"end": (self._end, "EndElementHandler"),
"data": (None, "CharacterDataHandler"),
"comment": (None, "CommentHandler"),
"pi": (None, "ProcessingInstructionHandler")
}.items():
if hasattr(target, k):
setattr(parser, v[1],
v[0] if v[0] is not None else getattr(target, k))
parser.buffer_text = 1
parser.ordered_attributes = 1
parser.specified_attributes = 1
self.positions = {}
def emit(output, title_string, structure):
"Write an SVG file to output representing structure."
global builder
builder = TreeBuilder()
builder.start(
"svg",
dict(xmlns="http://www.w3.org/2000/svg",
width=str(width),
height=str(height)))
title(title_string)
structure.depth(3)
for key, depth in [
(3, 3),
(1, 5),
(2, 6),
(1, 10),
(1, 11),
(2, 15),
(3, 16),
(1, 22),
(2, 25),
(1, 25),
]:
structure.key(key, depth)
builder.end("svg")
ElementTree(builder.close()).write(output,
encoding='utf-8',
xml_declaration=True)
output.write("\n")
def data2builder(data, tag_name="data", builder=None):
"""pass in a python data structure and get back a etree TreeBuilder
"""
if builder == None:
builder = TreeBuilder()
t = type(data)
if t == NoneType:
builder.start(tag_name, {})
builder.end(tag_name)
elif t in (StringType, UnicodeType, IntType, FloatType, BooleanType,
LongType):
builder.start(tag_name, {})
builder.data(unicode(data))
builder.end(tag_name)
elif t in (ListType, TupleType):
for value in data:
data2builder(value, tag_name=tag_name, builder=builder)
elif t == DictionaryType:
builder.start(tag_name, {})
for key, value in data.items():
data2builder(value, tag_name=key, builder=builder)
builder.end(tag_name)
else:
raise Exception("uhoh I can't handle type %s" % t)
return builder
def write_output(*, output_path, content):
tree_builder = TreeBuilder()
root = tree_builder.start("testsuites", {})
root_failures = 0
for (path, hunks) in content.items():
path_el = tree_builder.start("testsuite", {"name": path})
path_failures = 0
for hunk in hunks:
tree_builder.start(
"testcase",
{
"name": f"{path}.path_failures",
"classname": path
},
)
fail_el = tree_builder.start("failure", {})
fail_el.text = hunk
root_failures += 1
path_failures += 1
tree_builder.end("failure")
tree_builder.end("testcase")
path_el.set("tests", str(path_failures))
path_el.set("failures", str(path_failures))
tree_builder.end("testsuite")
root.set("tests", str(root_failures))
root.set("failures", str(root_failures))
tree_builder.end("testsuites")
xml_tree = ElementTree(tree_builder.close())
if output_path:
with open(output_path, "w+") as out:
xml_tree.write(out, encoding="unicode")
else:
xml_tree.write(sys.stdout, encoding="unicode")
def write_xml_file(f, taxes):
""" Export an XML file for the given taxonomies to the (open) file handle
specified.
"""
x = TreeBuilder()
x.start("taxonomy", {})
def f_pre(term):
x.start("category", {"id": str(term.uid)})
x.start("name", {})
x.data(term.name)
x.end("name")
for clue, positive in term.iter_clues():
attrs = {}
if not positive:
attrs["negative"] = True
x.start("clue", attrs)
x.data(clue)
x.end("clue")
def f_post(term):
x.end("category")
for term in taxes:
term.walk(f_pre, f_post)
x.end("taxonomy")
xml = ElementTree(x.close())
xml.write(f, xml_declaration=True, encoding="utf-8")
def parse(self, encoding=None, errors="strict", **kwargs):
"""
Return the contents of toolbox settings file with a nested structure.
:param encoding: encoding used by settings file
:type encoding: str
:param errors: Error handling scheme for codec. Same as ``decode()`` builtin method.
:type errors: str
:param kwargs: Keyword arguments passed to ``StandardFormat.fields()``
:type kwargs: dict
:rtype: ElementTree._ElementInterface
"""
builder = TreeBuilder()
for mkr, value in self.fields(encoding=encoding,
errors=errors,
**kwargs):
# Check whether the first char of the field marker
# indicates a block start (+) or end (-)
block = mkr[0]
if block in ("+", "-"):
mkr = mkr[1:]
else:
block = None
# Build tree on the basis of block char
if block == "+":
builder.start(mkr, {})
builder.data(value)
elif block == "-":
builder.end(mkr)
else:
builder.start(mkr, {})
builder.data(value)
builder.end(mkr)
return builder.close()
def _getModuleStepsDocAndTables(self, moduleName, pythonLibDirectories):
for pythonLibDirectory in pythonLibDirectories:
stepsDocFileName = pythonLibDirectory + os.sep + moduleName + "-steps-doc.xml"
stepsDocDict = self.allImportedModulesStepsDoc.get(stepsDocFileName)
stepsTablesDict = self.allImportedModulesStepsTables.get(stepsDocFileName)
if stepsDocDict and stepsTablesDict:
return (stepsDocDict, stepsTablesDict)
else:
if os.path.exists(stepsDocFileName):
stepsModuleDocTree = et.parse(stepsDocFileName, TreeBuilder())
stepsDocDict = {}
stepsDocTree = stepsModuleDocTree.find('steps')
if stepsDocTree is not None:
for stepElem in stepsDocTree.getiterator('step'):
stepName = stepElem.get('name')
stepsDocDict[stepName] = stepElem
stepsTablesDict = {}
stepsTablesTree = stepsModuleDocTree.find('stepsTables')
if stepsTablesTree is not None:
for stepsTableElem in stepsTablesTree.getiterator('stepsTable'):
stepsTableName = stepsTableElem.get('name')
stepsTable = []
for stepElem in stepsTableElem.getiterator('step'):
stepId = stepElem.get('id')
stepName = stepElem.get('name')
stepsTable.append((stepId, stepName))
stepsTablesDict[stepsTableName] = stepsTable
# store doc dicts to avoid parsing them again
self.allImportedModulesStepsDoc[stepsDocFileName] = stepsDocDict
self.allImportedModulesStepsTables[stepsDocFileName] = stepsTablesDict
return (stepsDocDict, stepsTablesDict)
return (None, None)
def __init__(self, *, target=None, encoding="UTF-8"):
if target is None:
target = TreeBuilder()
self._data = bytearray()
self.parser = self._parser = _CryXMLBParser(target, encoding)
self.target = self._target = target
self.target = target
self.encoding = encoding
self._error = ValueError
self._names = {} # name memo cache
# main callbacks
if hasattr(target, "start"):
self.parser.StartElementHandler = self._start
if hasattr(target, "end"):
self.parser.EndElementHandler = self._end
if hasattr(target, "start_ns"):
self.parser.StartNamespaceDeclHandler = self._start_ns
if hasattr(target, "end_ns"):
self.parser.EndNamespaceDeclHandler = self._end_ns
if hasattr(target, "data"):
self.parser.CharacterDataHandler = target.data
# miscellaneous callbacks
if hasattr(target, "comment"):
self.parser.CommentHandler = target.comment
if hasattr(target, "pi"):
self.parser.ProcessingInstructionHandler = target.pi
self.entity = {}
def build(self, root=None):
if root is None:
root = TreeBuilder()
root.start("html", {})
root.start("head", {})
if self.title:
root.start("title", {})
root.data(self.title)
root.end("title")
for meta in self._metas:
root.start("meta", meta)
root.end("meta")
for style in self._stylesheets:
root.start("link", {
"rel": "stylesheet",
"href": style,
"type": "text/css"
})
root.end("link")
for script in self._scripts:
root.start("script", {
"type": "text/javascript",
"src": script
})
root.data(" ")
root.end('script')
root.end("head")
super(Document, self).build(root=root)
root.end("html")
root = root.close()
return "<!DOCTYPE html>\n%s" % str(
tostring(root, method="html").decode('utf-8'))
def from_string(cls, xml_as_string):
if isinstance(xml_as_string, bytes):
xml_as_string = xml_as_string.decode()
try:
return xml.etree.ElementTree.fromstring(xml_as_string, parser=XMLParser(target=TreeBuilder(element_factory=cls)))
except xml.etree.ElementTree.ParseError:
return cls.from_string(xml_as_string.replace("<style scoped>","<style scoped='1'>"))
def test_xsd_sequence_callback(self):
from xml.etree.ElementTree import TreeBuilder, tostring
from c2cgeoportal_geoportal.lib.dbreflection import xsd_sequence_callback
from papyrus.xsd import tag
tb = TreeBuilder()
with tag(tb, "xsd:sequence") as tb:
xsd_sequence_callback(tb, self.cls)
e = tb.close()
self.assertIsNotNone(
re.search(
'<xsd:element name="child2">'
'<xsd:simpleType>'
'<xsd:restriction base="xsd:string">'
'<xsd:enumeration value="foo" />'
'<xsd:enumeration value="bar" />'
'</xsd:restriction>'
'</xsd:simpleType>'
'</xsd:element>',
tostring(e).decode("utf-8"),
))
self.assertIsNotNone(
re.search(
'<xsd:element minOccurs="0" name="child1" nillable="true">'
'<xsd:simpleType>'
'<xsd:restriction base="xsd:string">'
'<xsd:enumeration value="foo" />'
'<xsd:enumeration value="bar" />'
'</xsd:restriction>'
'</xsd:simpleType>'
'</xsd:element>',
tostring(e).decode("utf-8"),
))
def test_add_column_readonly(self):
from xml.etree.ElementTree import TreeBuilder, tostring
from sqlalchemy.orm.util import class_mapper
from c2cgeoportal_geoportal.lib.xsd import XSDGenerator
gen = XSDGenerator(include_foreign_keys=True)
mapper = class_mapper(self.cls)
tb = TreeBuilder()
p = mapper.attrs["readonly"]
gen.add_column_property_xsd(tb, p)
e = tb.close()
self.assertEqual(
'<xsd:element name="readonly" minOccurs="0" nillable="true" type="xsd:string">'
"<xsd:annotation>"
"<xsd:appinfo>"
'<readonly value="true" />'
"</xsd:appinfo>"
"</xsd:annotation>"
"</xsd:element>",
tostring(e).decode("utf-8"),
)
def from_string(cls, xml_as_string, _fix_step=0):
if isinstance(xml_as_string, bytes):
xml_as_string = xml_as_string.decode()
parser = XMLParser(target=TreeBuilder(element_factory=cls))
try:
return xml.etree.ElementTree.fromstring(xml_as_string,
parser=parser)
except Exception as err: # xml.etree.ElementTree.ParseError
# see: https://stackoverflow.com/questions/47917787/xml-etree-elementtree-parseerror-exception-handling-not-catching-errors
if type(err).__name__ == 'ParseError':
if _fix_step == 0:
return cls.from_string(xml_as_string.replace(
"<style scoped>", "<style scoped='1'>"),
_fix_step=1)
elif _fix_step == 1:
return cls.from_string("<div>" + xml_as_string.replace(
"<style scoped>", "<style scoped='1'>") + "</div>",
_fix_step=2)
elif _fix_step == 2:
return cls.from_string(xml_as_string.replace(
" ", " "),
_fix_step=3)
else:
import logging
lined = "\n".join(f"{n: 4d} | {line}"
for n, line in enumerate(
xml_as_string.split("\n"), start=1))
logging.getLogger("").error(f"ParseError in:\n{lined}")
raise
else:
raise
def message(self):
builder = TreeBuilder()
builder.start(self.resource_type, dict())
self.serialize(builder)
builder.end(self.resource_type)
msg = tostring(builder.close())
return msg
def build(self, root=None):
if root is None:
was_root = True
root = TreeBuilder()
else:
was_root = False
root.start(self.tagname(), self.attrs())
for i, child in enumerate(self.children):
if isinstance(child, HTMLBuilder):
child.build(root=root)
else:
if i in self._formatted:
try:
proxy = TreeProxy(root)
parser = XMLParser(html=True, target=proxy)
parser.feed(child)
proxy.cleanup()
except Exception as e:
print("Bad formatting", e)
root.data(str(child))
else:
root.data(str(child))
root.end(self.tagname())
if was_root:
root = root.close()
return str(tostring(root, method="html").decode('utf-8'))
def test_xsd_sequence_callback(self):
from xml.etree.ElementTree import TreeBuilder, tostring
from c2cgeoportal.lib.dbreflection import _xsd_sequence_callback
from papyrus.xsd import tag
tb = TreeBuilder()
with tag(tb, 'xsd:sequence') as tb:
_xsd_sequence_callback(tb, self.cls)
e = tb.close()
self.assertEqual(
tostring(e), '<xsd:sequence>'
'<xsd:element minOccurs="0" name="child1" nillable="true">'
'<xsd:simpleType>'
'<xsd:restriction base="xsd:string">'
'<xsd:enumeration value="foo" />'
'<xsd:enumeration value="bar" />'
'</xsd:restriction>'
'</xsd:simpleType>'
'</xsd:element>'
'<xsd:element minOccurs="0" name="child2" nillable="true">'
'<xsd:simpleType>'
'<xsd:restriction base="xsd:string">'
'<xsd:enumeration value="foo" />'
'<xsd:enumeration value="bar" />'
'</xsd:restriction>'
'</xsd:simpleType>'
'</xsd:element>'
'</xsd:sequence>')
def __init__(self, filePath, absUrl, xmlIf, treeWrapper):
XMLTreeBuilder.__init__(
self, target=TreeBuilder(element_factory=ElementExtension))
self._parser.StartNamespaceDeclHandler = self._start_ns
self._parser.EndNamespaceDeclHandler = self._end_ns
self.namespaces = []
XmlIfBuilderExtensionBase.__init__(self, filePath, absUrl, treeWrapper,
xmlIf.elementWrapperClass)
def _elem(parent: Element, tag: str, data: Optional[str] = None) -> Element:
b = TreeBuilder()
b.start(tag, {}) # types: ignore
if data:
b.data(data)
ret = b.end(tag)
parent.append(ret)
return ret
def __init__(self, stream, *pos, **kw):
self._stream = stream
self._pending = deque()
builder = _QueueBuilder(self._pending)
self._parser = XMLParser(*pos, target=builder, **kw)
self._builders = [TreeBuilder()]
[method, pos, kw] = self._read()
self.element = getattr(self._builders[-1], method)(*pos, **kw)
def test_add_association_proxy_xsd(self):
from xml.etree.ElementTree import TreeBuilder, tostring
from sqlalchemy.orm.util import class_mapper
from c2cgeoportal_geoportal.lib.xsd import XSDGenerator
gen = XSDGenerator(include_foreign_keys=True)
mapper = class_mapper(self.cls)
tb = TreeBuilder()
gen.add_association_proxy_xsd(tb, mapper.attrs["child1_id"])
e = tb.close()
self.assertEqual(
'<xsd:element minOccurs="0" nillable="true" name="child1">'
"<xsd:simpleType>"
'<xsd:restriction base="xsd:string">'
'<xsd:enumeration value="foo" />'
'<xsd:enumeration value="zad" />'
'<xsd:enumeration value="bar" />'
"</xsd:restriction>"
"</xsd:simpleType>"
"</xsd:element>",
tostring(e).decode("utf-8"),
)
# Test child2 enumeration is ordered by Child.custom_order
tb = TreeBuilder()
gen.add_association_proxy_xsd(tb, mapper.attrs["child2_id"])
e = tb.close()
self.assertEqual(
'<xsd:element name="child2">'
"<xsd:simpleType>"
'<xsd:restriction base="xsd:string">'
'<xsd:enumeration value="zad" />'
'<xsd:enumeration value="foo" />'
'<xsd:enumeration value="bar" />'
"</xsd:restriction>"
"</xsd:simpleType>"
"</xsd:element>",
tostring(e).decode("utf-8"),
)
def coverage_meta_xml():
builder = TreeBuilder()
dict_meta = dict(coverageview=dict(coveragebands=dict(
coverageband_1=dict(definition='ceshi',
index=1,
inputcoveragebands=dict(inputcoverageband=dict(
coverageName='x_wind_10m'))),
coverageband_2=dict(definition='ceshi', index=1))))
coverageview_meta_info(builder, dict_meta)
return builder
def __init__(self, filename: pathlib.Path, stylesheet_path: pathlib.Path) -> None:
super().__init__(filename)
self.stylesheet_path = stylesheet_path
self.builder = TreeBuilder()
self.heading_class: List[str] = [] # Heading class stack
self.heading_level: List[int] = [] # Heading level stack
self.table_cell_html_tag: Optional[str] = None
self.in_keep_together_div = False
self.in_measure = False
self.frontpage_done = False
def save(self):
'''saves action to file'''
builder = TreeBuilder()
builder.start("action", { "id" : str(self.id), "type" : str(self.type) })
builder.start("name", {})
builder.data(self.name)
builder.end("name")
self._write_type(builder)
builder.end("action")
doc = ElementTree(builder.close())
doc.write(self.get_file(self.id))
def info_xml():
builder = TreeBuilder()
builder.start('root', dict())
builder.data('ceshi')
builder.start('child', dict())
builder.data('child_1_data')
builder.end('child')
builder.end('root')
return builder
# msg= tostring(builder.close(),encoding='utf-8',method='xml')
# print(msg)
pass
def from_bytes(cls, xml_as_bytes):
xml_as_string = xml_as_bytes.decode()
try:
return xml.etree.ElementTree.fromstring(
xml_as_string,
parser=XMLParser(target=TreeBuilder(element_factory=cls)))
except Exception as err: # xml.etree.ElementTree.ParseError
if type(err).__name__ == 'ParseError':
return cls.from_string(
xml_as_string.replace("<style scoped>",
"<style scoped='1'>"))
else:
raise
def _addTestRequirement(self, testScriptFileName, testScript):
testRequirement = et.SubElement(testScript, 'testRequirement')
requirementFileName = os.path.dirname(testScriptFileName) + os.sep + 'Req.xml'
try:
requirementFile = et.parse(requirementFileName, TreeBuilder())
root = requirementFile.getroot()
for requirement in root.getiterator('REQ'):
xmlReq = et.SubElement(testRequirement, 'REQ')
et.SubElement(xmlReq, 'ID').text = requirement.get('id')
for desc in requirement.getiterator('REQ_DESCRIPTION'):
et.SubElement(xmlReq, 'DESCRIPTION').text = desc.text
except IOError:
pass
def parse(self, source=None, parser=None):
try:
if not parser:
parser = XMLParser(target=TreeBuilder())
while 1:
data = self.mergeScreenConfigs()
if not data:
break
parser.feed(data)
return parser.close()
# self._root = parser.close()
# return self._root
except:
pass
def message(self):
'''
# TODO:[-] 20-03-13 在ResourceInfo中定义的方法，最终返回的是需要提交的msg
* 由于ResourceInfo是需要由子类继承的，所以self就是继承的子类
eg: UnsavedCoverageStore
message 为 TreeBuilder 创建的 Element -> str
'''
builder = TreeBuilder()
# 创建了一个 resource_type(每个子类会声明这个类变量) 的 treebuilder
builder.start(self.resource_type, dict())
self.serialize(builder)
builder.end(self.resource_type)
# b'<coverageStore><enabled>true</enabled><name>nmefc_2016072112_opdr_02</name><url>file:nmefc/waterwind/nmefc_2016072112_opdr.nc</url><type>NetCDF</type><workspace>my_test_2</workspace></coverageStore>'
msg = tostring(builder.close())
return msg
def parse(self, list_of_docs):
builder = TreeBuilder()
builder.start('corpus')
for i, doc in enumerate(list_of_docs):
attrib = {}
attrib['id'] = str(i)
attrib['len'] = str(len(doc))
builder.start('tok', attrib)
builder.data(doc)
builder.end('tok')
builder.end('corpus')
return builder.close()
