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()