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