def _convert_config_list_to_netconf_xml(self, config_list, tag, attributes): builder = etree.TreeBuilder() config_elem_name = etree.QName( 'urn:ietf:params:xml:ns:netconf:base:1.0', tag) builder.start(config_elem_name, attributes) builder.data('\n') current_xml_token_stack = [] config_line = '(start)' try: for line_number, config_line in enumerate(config_list, start=1): if not self._is_line_empty_or_comment(config_line): self._process_config_line(builder, current_xml_token_stack, config_line) builder.end(config_elem_name) builder.data('\n') root = builder.close() except Exception as e: raise ConfigParseError('Error parsing config, line ' + str(line_number) + ': "' + config_line + '" : ' + str(e)) return root
def build_wasm_request_body(xml_as_odict, builder=None, root=True, indent=0): """Takes an OrderedDict and uses it to build an XML doc suitable for sending as a request body to the Windows Azure Management Service. This makes it possible for clients to compactly specify dynamic requests. Returns the doc as a string including the expected doctype declaration.""" while len(xml_as_odict) > 0: k, v = xml_as_odict.popitem(last=False) #print ' ' * indent + '<%s>' % k if not builder: builder = etree.TreeBuilder() builder.start(k, {'xmlns': NAMESPACE_MANAGEMENT}) else: builder.start(k, {}) if isinstance(v, dict): # recurse build_wasm_request_body(v, builder, root=False, indent=indent + 2) else: #print ' ' * indent + ' ' + v builder.data(v) #print ' ' * indent + '</%s>' % k builder.end(k) if root: body = u'<?xml version="1.0" encoding="utf-8"?>' body += etree.tostring(builder.close(), encoding='utf-8') body += NEW_LINE return body
def generate(self, feeds: List[Feed]) -> None: """Create subscriptions document from list of feeds. Args: feeds: the list of feeds to include in the document """ builder = etree.TreeBuilder() builder.start("opml", {'version': '2.0'}) builder.start("head", {}) builder.start("title", {}) builder.data("castero feeds") builder.end("title") builder.end("head") builder.start("body", {}) for feed in feeds: builder.start("outline", { 'type': 'rss', 'text': str(feed), 'xmlUrl': feed.key }) builder.end("outline") builder.end("body") builder.end("opml") # .close returns an Element, so we need to cast to an ElementTree self._tree = etree.ElementTree(builder.close())
def generate(self, feeds: List[Feed]) -> None: """Create subscriptions document from list of feeds. :param feeds the list of feeds to include in the document """ builder = etree.TreeBuilder() builder.start("opml", {"version": "2.0"}) builder.start("head", {}) builder.start("title", {}) builder.data("castero feeds") builder.end("title") builder.end("head") builder.start("body", {}) for feed in feeds: builder.start("outline", { "type": "rss", "text": str(feed), "xmlUrl": feed.key }) builder.end("outline") builder.end("body") builder.end("opml") # .close returns an Element, so we need to cast to an ElementTree self._tree = etree.ElementTree(builder.close())
def __init__(self, document, builder): nodes.NodeVisitor.__init__(self, document) self.builder = builder self.tree = etree.TreeBuilder() # trace if we are inside a body element self.inBody = False # trace if we have an empty document self.hasContent = False
def create_element(self, tag='', attrs=None, data=''): tree = etree.TreeBuilder() if not attrs: attrs = {} tree.start(tag, attrs) tree.data(data) tree.end(tag) return tree.close()
def __init__(self, output_dir): if etree is None: raise Errors.NoElementTreeInstalledException() self.output_dir = os.path.join(output_dir or os.curdir, 'cython_debug') self.tb = etree.TreeBuilder() # set by Cython.Compiler.ParseTreeTransforms.DebugTransform self.module_name = None self.start('cython_debug', attrs=dict(version='1.0'))
def get_dict_from_xml(iv_path): with open(iv_path, 'r'): lv_parser = etree.XMLParser(target=etree.TreeBuilder()) lv_root = etree.XML(open(iv_path).read(), lv_parser) ll_ele = {} for lv_ele in lv_root: ll_ele[lv_ele.tag] = lv_ele.text return ll_ele raise Exception(messages.error_xml_file)
def start(self, tag, attributes, nsmap): """ Grab data from the start of tags. """ # Start up a file for content. if (tag == '{{{0}}}xmlContent'.format(FOXML_NAMESPACE) and self.dsid != 'AUDIT'): self.tree_builder = etree.TreeBuilder() elif self.tree_builder is not None: self.tree_builder.start(tag, attributes, nsmap) if tag == '{{{0}}}binaryContent'.format(FOXML_NAMESPACE): self.ds_file = utils.SpooledTemporaryFile() if tag == '{{{0}}}contentLocation'.format(FOXML_NAMESPACE): self.ds_info[self.dsid]['versions'][-1]['data_ref'] = attributes # Record current DSID. if tag == '{{{0}}}datastream'.format(FOXML_NAMESPACE): self.dsid = attributes['ID'] self.ds_info[attributes['ID']] = {'versions': []} # Store DS info. if (tag == '{{{0}}}datastream'.format(FOXML_NAMESPACE) and self.dsid != 'AUDIT'): self.ds_info[self.dsid].update(attributes) if (tag == '{{{0}}}datastreamVersion'.format(FOXML_NAMESPACE) and self.dsid != 'AUDIT'): attributes['data'] = None attributes['data_ref'] = None attributes['checksums'] = [] self.ds_info[self.dsid]['versions'].append(attributes) # Store checksum info. if tag == '{{{0}}}contentDigest'.format(FOXML_NAMESPACE): checksum = { 'type': attributes['TYPE'], 'checksum': attributes['DIGEST'], } self.ds_info[self.dsid]['versions'][-1]['checksums'].append( checksum) # Store object info. if tag == '{{{0}}}property'.format(FOXML_NAMESPACE): self.object_info[attributes['NAME']] = attributes['VALUE'] if tag == '{{{0}}}digitalObject'.format(FOXML_NAMESPACE): if self.object_info['PID'] is None: self.object_info['PID'] = attributes['PID'] logger.info('Attempting import of %s.', self.object_info['PID'])
class DemoBuilder(QObject): xml: ET.TreeBuilder = ET.TreeBuilder() def flush_xml(self) -> ET.ElementBase: res: ET.ElementBase = self.xml.close() return res def xml_to_str(self, close: bool = False) -> str: match close: case True: return ET.tostring(self.xml.close()) case False: xml: ET.ElementBase = deepcopy(self.xml).close() return ET.tostring(xml) self.xml.close()
def format_request(cls, pkt_type, req = {}, pkt_attrs = {}): """ req is a list of 2-element tuples with first element being the command, and second being a dict of parameters. E.g. ('power_on', {'value': "0"}) pkt_attrs is a dictionary containing element attributes. E.g. {'protocol': "3.0"} """ output = cls.XML_HEADER builder = etree.TreeBuilder() builder.start(pkt_type,pkt_attrs) for cmd, params in req: builder.start(cmd, params) builder.end(cmd) builder.end(pkt_type) pkt = builder.close() return output + etree.tostring(pkt)
def get_pages_at(dump, offset): decomp = bz2.BZ2Decompressor() dump.seek(offset) builder = etree.TreeBuilder() p = etree.XMLParser(target=builder) p.feed('<mediawiki>') while True: s = dump.read(1024) try: s = decomp.decompress(s) except EOFError: p.feed('</mediawiki>') p.close() break p.feed(s) return builder.close()
def parse_datatable(filename): classes = [] type = filename[:-4] def parse_classes(root): for item in root: if item.tag.lower() == 'category': parse_classes(item) elif item.tag.lower() == 'class': d = dict(item.attrib) d['__type__'] = type classes.append(d) dom = etree.parse( filename, etree.XMLParser(target=etree.TreeBuilder(), remove_comments=True)) if dom == None: return None parse_classes(dom) return classes
def visit_FunctionNode(self, node): self.treebuilder = etree.TreeBuilder() self.visit_Node(node) return self.treebuilder.close()
def __init__(self, stream): self.stream = stream self.depth = 0 self.root = None self.current = etree.TreeBuilder()
def db_xml(db, doc): handler = etree.TreeBuilder() doc_walk(db, doc, handler) return handler.close()
from lxml import etree if False and not sys.stdout.isatty(): # force stdout to write utf8 encoded text. sys.stdout = codecs.getwriter("utf8")(sys.stdout) langs = ( "pt", "es", "zh_CN", ) translations = [(lang, gettext.translation("iso_3166", "usr/share/locale", [lang])) for lang in langs] countries = etree.TreeBuilder() countries_root = countries.start("countries", {}) tree = etree.ElementTree() tree.parse("usr/share/xml/iso-codes/iso_3166.xml") for entry in tree.iter("iso_3166_entry"): if "date_withdrawn" in entry.attrib: continue country_code = entry.attrib["alpha_2_code"] countries.start("country", {"code": country_code}) for attribute_name in ("name", "official_name"): if attribute_name not in entry.attrib: continue
def parse_niml(fname): ''' Parse NIML file into Python xml.etree.Element using incremental event-driven parsing. Specification ------------- https://afni.nimh.nih.gov/pub/dist/src/niml/NIML_base.html ''' batch_size = 1024 tb = etree.TreeBuilder() generate_key = lambda: uuid.uuid4().hex[:8] data = {} with open(fname, 'rb') as fi: # TODO: Check buffering for better read_until() performance fi.read_until = lambda end_token: read_until(fi, end_token, batch_size) fmt = None while True: # Read until < to get between-tag content # --------------------------------------- if fmt is None or fmt['form'] != 'binary': # If fmt is None, there should be no data before the tag. # 1. At the beginning of the file # 2. After a closing tag (assuming no trailiing data in NIML) # If fmt is not None, there can be data whose ni_form is # text, base64, ni_group, or unspecified (no ni_form attribute). between = fi.read_until(b'<') if not between.endswith(b'<'): # Arrive at the end of the file break else: between = between[:-1] else: # Binary data in NIML require special treatment (the bytes stream may contain b'<') between = fi.read(fmt['length']) fi.read_until(b'<') # Also read the ending b'<' # Specification: After the proper ni_dimen number of data values have been read, # any data bytes before the closing "</" will be discarded. # Parse data stream from between-tag content (can be empty) value = parse_data(between, fmt) # Push data (between-tag content) into xml.etree.TreeBuilder if value is not None: key = generate_key() data[key] = value tb.data(key) # Read until > to get within-tag content # -------------------------------------- within = fi.read_until(b'>') within = within[:-1].decode(encoding) # Decode because shlex.split only works with str but not bytes # Parse tag and attributes from within-tag content empty = within.endswith('/') # Specification: Empty element's header ends with "/>" items = shlex.split(within) if not empty else shlex.split(within[:-1]) closing = items[0].startswith('/') tag = items[0] if not closing else items[0][1:] attrs = dict([parse_attr(item) for item in items[1:]]) # Push tag and attributes (within-tag content) into xml.etree.TreeBuilder if closing: # Closing tag contains no attrs, and should not have trailing data (my assumption about NIML) tb.end(tag) fmt = None else: tb.start(tag, attrs) if empty: # Self-closing tag doesn't need further processing tb.end(tag) else: # Starting tag contains data format, and may be followed by actual data stream fmt = parse_data_format(attrs) et = etree.ElementTree(tb.close()) # .close returns an Element, so we need to cast to an ElementTree return et, data
def __init__(self, builder): writers.Writer.__init__(self) self.builder = builder self.topics = etree.TreeBuilder()