def _convert_dict_to_xml_recurse(parent, dictitem, listnames, attributenames):
"""Helper Function for XML conversion."""
# we can't convert bare lists
assert not isinstance(dictitem, list)
if isinstance(dictitem, dict):
for (tag, child) in sorted(dictitem.iteritems()):
if isinstance(child, list):
# iterate through the array and convert
listelem = Element(tag)
parent.append(listelem)
for listchild in child:
elem = Element(listnames.get(tag, 'item'))
listelem.append(elem)
_convert_dict_to_xml_recurse(elem, listchild, listnames, attributenames)
else:
if tag in attributenames:
parent.attrib[tag] = unicode(child)
else:
elem = Element(tag)
parent.append(elem)
_convert_dict_to_xml_recurse(elem, child, listnames, attributenames)
elif type(dictitem) == _Element:
for i in list(dictitem):
parent.append(i)
elif not dictitem is None:
parent.text = unicode(dictitem)
def _add_request(self, doc):
"""Constructs add request using doc dict.
"""
node = dict2element(doc)
root = Element("add")
root.append(node)
return tostring(root).encode('utf-8')
def exportXMLToFile(self):
""" NO DOCUMENTATION """
assert self.has_selected_item()
# Ask the users where they want to save the file
start_dir = ""
opus_home = os.environ.get("OPUS_HOME")
if opus_home:
start_dir_test = os.path.join(opus_home, "project_configs")
if start_dir_test:
start_dir = start_dir_test
configDialog = QFileDialog()
filter_str = QString("*.xml")
fd = configDialog.getSaveFileName(
self.manager.base_widget, QString("Save As..."), QString(start_dir), filter_str
)
# Check for cancel
if len(fd) == 0:
return
fileNameInfo = QFileInfo(QString(fd))
fileName = fileNameInfo.fileName().trimmed()
fileNamePath = fileNameInfo.absolutePath().trimmed()
saveName = os.path.join(str(fileNamePath), str(fileName))
# proper root node for XmlConfiguration
root_node = Element("opus_project")
import copy
root_node.append(copy.deepcopy(self.selected_item().node))
# Write out the file
ElementTree(root_node).write(saveName)
def _E(tag, attrib={}, children=()):
"""Make an element"""
elem = Element(tag, attrib)
x = elem
for c in children:
if c is None:
continue
if isinstance(c, basestring):
if x != elem:
if x.tail:
x.tail += c
else:
x.tail = c
else:
if x.text:
x.text += c
else:
x.text = c
else:
elem.append(c)
x = c
return elem
def analysis_section(notice, child):
# Create the section element
section_elm = Element('analysisSection')
# Add the title element
title_elm = SubElement(section_elm, 'title')
title_elm.text = child['title']
# Add paragraphs
for paragraph in child['paragraphs']:
paragraph_number = child['paragraphs'].index(paragraph)
paragraph_footnotes = [
fn for fn in child['footnote_refs']
if fn['paragraph'] == paragraph_number]
text = self.resolve_footnotes(notice, paragraph,
paragraph_footnotes)
paragraph_elm = fromstring(
'<analysisParagraph>'
+ text +
'</analysisParagraph>')
# Make sure to strip out elements that don't belong
strip_tags(paragraph_elm, 'EM')
section_elm.append(paragraph_elm)
# Construct an analysis section for any children.
try:
map(lambda c: section_elm.append(analysis_section(notice, c)),
child['children'])
except:
print("Failed to write analysis for", child['title'])
pass
return section_elm
def _getcontent(toUserName,fromUserName,iterItem):
articleElement = Element('Articles')
item_count = 0
for item in iterItem:
item_count += 1
if item_count >= 10:
break
ori_dict = {
"Title":item.title,
"Description":item.description,
"PicUrl":item.picurl,
"Url":item.url,
}
element = dict_to_xml('item',ori_dict=ori_dict)
articleElement.append(element)
ori_dict = {
"ToUserName":toUserName,
"FromUserName":fromUserName,
"CreateTime":int(time.time()),
"MsgType":"news",
"ArticleCount":item_count,
}
element = dict_to_xml(
'xml',ori_dict,["CreateTime","ArticleCount"]
)
element.append(articleElement)
return tostring(
element,
encoding = "unicode"
)
def test_etree_to_dict2(self):
root = Element('div')
root.append(Element('a', {'href': 'http://aaa.bbb/'}))
root.append(Element('a', {'href': 'http://ccc.ddd/'}))
result = util.etree_to_dict2(root)
self.assertEqual(result['a']['0']['href'], "http://aaa.bbb/")
self.assertEqual(result['a']['1']['href'], "http://ccc.ddd/")
def get_form(self, node):
ns = NS['poll']
form = Element("form", method="post", id="poll-form")
qn = 0
for n, element in enumerate(node.getiterator(ns + "section")):
section = SubElement(form, "div", {
"class": "section",
"id": str(n + 1)
})
if element.attrib.get("title"):
SubElement(section, 'h1').text = element.attrib["title"]
for question in element.getchildren():
qn += 1
try:
if question.tag != ns + "question":
continue
#func = getattr(self, "get_%s" % question.attrib.get('type'))
#div = func(question, qn)
div = Handlers.get(question, qn)
#div = self.set_validation(question, div)
section.append(div)
except AttributeError as e:
print(e) # XXX stub
print(question.attrib)
form.append(self.get_submit_section())
return form
def execute(self, args):
terms = pkppln.get_all_terms()
locale = Element('locale', attrib={
'name': "en_US",
'full_name': "U.S. English",
})
locale.append(Comment(
"""
* Localization strings.
*
* To use, change the locale name from en_US to the appropriate code
* for your language, and change the full name to the proper name
* of your language.
*
* Do not edit or change the message key attributes. Only edit the
* text content of the message tags.
"""))
for term in terms:
message = SubElement(locale, 'message')
message.set('key', term['key_code'])
message.text = term['content']
self.output(0, et.tostring(
locale,
pretty_print=True,
encoding="UTF-8",
xml_declaration=True
))
def to_xsd(self, wrap_into_schema=False, type_prefix="", annotate=False):
xsd_uri = self.nsmap["xs"]
# Create an xs:element element
attrib = {"name": self.name}
if not wrap_into_schema:
# If not at root, assign occurence indicators
attrib.update({"minOccurs": str(self.min_occurs), "maxOccurs": str(self.max_occurs)})
e = Element(QName(xsd_uri, "element"), attrib=attrib)
# Append type definition
e1, e1_tdefs = self._to_xsd_type(type_prefix)
if isinstance(e1, basestring):
e.attrib["type"] = str(e1)
else:
e.append(e1)
# Decide what to return depending on wrap_into_schema flag
if wrap_into_schema:
root = self._root_xsd_element()
for tdef in e1_tdefs.itervalues():
root.append(tdef)
root.append(e)
return root
else:
return (e, e1_tdefs)
def normaliseMap(node):
mapList = xml.getAll(node, keep=lambda e: getUiType(e) == UI_TYPE_MAP)
for map in mapList:
# Make 'Center Me' button
btnCenter = Element(
nextFreeName('Center_Me', map),
{ RESERVED_XML_TYPE : TYPE_GUI_DATA },
t=UI_TYPE_BUTTON
)
btnCenter.text = 'Center Me'
# Make 'Save Map Settings' button
btnSave = Element(
nextFreeName('Save_Map_Settings', map),
{ RESERVED_XML_TYPE : TYPE_GUI_DATA },
t=UI_TYPE_BUTTON
)
btnSave.text = 'Save Map Settings'
# Make cols
cols = Element(TAG_COLS, { RESERVED_XML_TYPE : TYPE_COLS })
cols.append(btnCenter)
cols.append(btnSave)
# Add cols below map
xml.insertAfter(map, cols)
def insert_layer_style(map_el, layer_el, style_name, rule_els):
""" Given a Map element, a Layer element, a style name and a list of Rule
elements, create a new Style element and insert it into the flow and
point to it from the Layer element.
"""
if not rule_els:
return
style_el = Element('Style', {'name': style_name})
style_el.text = '\n '
for rule_el in rule_els:
style_el.append(rule_el)
style_el.tail = '\n '
if hasattr(map_el,'getchildren'):
map_el.insert(map_el.getchildren().index(layer_el), style_el)
else:
map_el.insert(map_el._children.index(layer_el), style_el)
stylename_el = Element('StyleName')
stylename_el.text = style_name
stylename_el.tail = '\n '
if hasattr(map_el,'getchildren'):
layer_el.insert(layer_el.getchildren().index(layer_el.find('Datasource')), stylename_el)
else:
layer_el.insert(layer_el._children.index(layer_el.find('Datasource')), stylename_el)
layer_el.set('status', 'on')
def _serialize_session_block(self, session_block):
session = session_block.session
slot_id = sorted(session_block.session.blocks, key=attrgetter('start_dt')).index(session_block)
xml = Element('session', self._color_tuple_to_attributes(session.colors))
SubElement(xml, 'ID').text = str(session.friendly_id)
SubElement(xml, 'new_id').text = str(session.id)
SubElement(xml, 'parentProtection').text = self._format_bool(session.is_protected)
SubElement(xml, 'code').text = 'sess{}-{}'.format(session.friendly_id, slot_id + 1)
SubElement(xml, 'slotId').text = str(slot_id)
SubElement(xml, 'sessionTimetableLink').text = self._url_for('sessions.display_session',
session)
title = session.title
if session_block.title:
title += ': ' + session_block.title
SubElement(xml, 'title').text = title
if session_block.can_manage(self._user):
SubElement(xml, 'modifyLink').text = self._url_for('timetable.manage_session', session)
SubElement(xml, 'description').text = session.description.replace('\r\n', '\n')
xml.append(self._serialize_location(session_block))
SubElement(xml, 'startDate').text = self._format_date(session_block.start_dt)
SubElement(xml, 'endDate').text = self._format_date(session_block.end_dt)
SubElement(xml, 'duration').text = self._format_duration(session_block.duration)
for entry in session_block.timetable_entry.children:
xml.append(self._serialize_timetable_entry(entry))
return xml
def solr_update_subjects():
global subjects_to_update
print subjects_to_update
subject_add = Element("add")
for subject_type, subject_name in subjects_to_update:
key = subject_type + '/' + subject_name
count = subject_count(subject_type, subject_name)
if not subject_need_update(key, count):
print 'no updated needed:', (subject_type, subject_name, count)
continue
print 'updated needed:', (subject_type, subject_name, count)
doc = Element("doc")
add_field(doc, 'key', key)
add_field(doc, 'name', subject_name)
add_field(doc, 'type', subject_type)
add_field(doc, 'count', count)
subject_add.append(doc)
if len(subject_add):
print 'updating subjects'
add_xml = tostring(subject_add).encode('utf-8')
solr_update([add_xml], debug=False, index='subjects')
solr_update(['<commit />'], debug=True, index='subjects')
subjects_to_update = set()
def getBodyLabelled(node, name, **kwargs):
isBlank = util.schema.isFlagged(node, FLAG_NOLABEL)
attribName = util.data.getAttribName(node)
attribType = util.data.getAttribType(node)
ref = node.tag
styleClass = util.xml.getAttribVal(node, ATTRIB_C)
readOnly = util.schema.isFlagged(node, FLAG_READONLY)
hidden = util.schema.isFlagged(node, FLAG_HIDDEN)
noScroll = util.schema.isFlagged(node, FLAG_NOSCROLL)
htmlDesc = util.schema.isFlagged(node, FLAG_HTMLDESC)
noAnno = util.schema.isFlagged(node, FLAG_NOANNOTATION)
noCert = util.schema.isFlagged(node, FLAG_NOCERTAINTY)
labelled = Element(name, **kwargs)
labelled.append(getBodyLabel(node, isBlank))
if attribName: labelled.attrib['faims_attribute_name'] = attribName
if attribType: labelled.attrib['faims_attribute_type'] = attribType
if ref: labelled.attrib['ref'] = ref
if styleClass: labelled.attrib['faims_style_class'] = styleClass
if readOnly: labelled.attrib['faims_read_only'] = 'true'
if hidden: labelled.attrib['faims_hidden'] = 'true'
if noScroll: labelled.attrib['faims_scrollable'] = 'false'
if htmlDesc: labelled.attrib['faims_html_description'] = 'true'
if noAnno: labelled.attrib['faims_annotation'] = 'false'
if noCert: labelled.attrib['faims_certainty'] = 'false'
return labelled
def _create_resource_doc(self, record):
root = Element('div')
for link in record.get('links', '').split(','):
root.append(Element('a', href = link))
return root
def test_etree_to_dict3(self):
root = Element('div')
cite1 = Element('cite')
cite1.text = "123"
root.append(cite1)
result = util.etree_to_dict2(root)
self.assertEqual(result['cite'], "123")
def parse_rpc_error(self, rpc_error):
if self.check_rc:
try:
error_root = fromstring(rpc_error)
root = Element('root')
root.append(error_root)
error_list = root.findall('.//nc:rpc-error', NS_MAP)
if not error_list:
raise ConnectionError(to_text(rpc_error, errors='surrogate_then_replace'))
warnings = []
for error in error_list:
message_ele = error.find('./nc:error-message', NS_MAP)
if message_ele is None:
message_ele = error.find('./nc:error-info', NS_MAP)
message = message_ele.text if message_ele is not None else None
severity = error.find('./nc:error-severity', NS_MAP).text
if severity == 'warning' and self.ignore_warning and message is not None:
warnings.append(message)
else:
raise ConnectionError(to_text(rpc_error, errors='surrogate_then_replace'))
return warnings
except XMLSyntaxError:
raise ConnectionError(rpc_error)
def export(self, **options):
"""
Exports the data into a XML file-like stream.
Arguments:
options (dict): The exporting options
Returns:
io.BytesIO: A XML file-like stream
Raises:
ExportError: When data fails to export
"""
data = self._data.normalize(includeKey=True)
database = Element("database", name="dtb_{}".format(self._data._base.year))
for table_name, rows in iteritems(data):
if not options.get("minify"):
database.append(Comment(" Table {} ".format(table_name)))
table = SubElement(database, "table", name=table_name)
for row_data in itervalues(rows):
row = SubElement(table, "row")
for column_name, column_value in iteritems(row_data):
SubElement(row, "field", name=column_name).text = unicode(column_value)
xml_data = xml_str(database, pretty_print=not options.get("minify"), xml_declaration=True, encoding="utf-8")
return io.BytesIO(xml_data)
def update_work(w, obj_cache=None, debug=False, resolve_redirects=False):
if obj_cache is None:
obj_cache = {}
wkey = w['key']
#assert wkey.startswith('/works')
#assert '/' not in wkey[7:]
deletes = []
requests = []
q = {'type': '/type/redirect', 'location': wkey}
redirect_keys = [r['key'][7:] for r in query_iter(q)]
deletes += redirect_keys
deletes += [wkey[7:]] # strip /works/ from /works/OL1234W
# handle edition records as well
# When an edition is not belonged to a work, create a fake work and index it.
if w['type']['key'] == '/type/edition' and w.get('title'):
edition = w
w = {
# Use key as /works/OL1M.
# In case of single-core-solr, we are using full path as key. So it is required
# to be unique across all types of documents.
# The website takes care of redirecting /works/OL1M to /books/OL1M.
'key': edition['key'].replace("/books/", "/works/"),
'type': {'key': '/type/work'},
'title': edition['title'],
'editions': [edition]
}
# Hack to add subjects when indexing /books/ia:xxx
if edition.get("subjects"):
w['subjects'] = edition['subjects']
if w['type']['key'] == '/type/work' and w.get('title'):
try:
d = build_data(w, obj_cache=obj_cache, resolve_redirects=resolve_redirects)
doc = dict2element(d)
except:
logger.error("failed to update work %s", w['key'], exc_info=True)
else:
if d is not None:
# Delete all ia:foobar keys
# XXX-Anand: The works in in_library subject were getting wiped off for unknown reasons.
# I suspect that this might be a cause. Disabling temporarily.
#if d.get('ia'):
# deletes += ["ia:" + iaid for iaid in d['ia']]
# In single core solr, we use full path as key, not just the last part
if is_single_core():
deletes = ["/works/" + k for k in deletes]
requests.append(make_delete_query(deletes))
add = Element("add")
add.append(doc)
add_xml = tostring(add).encode('utf-8')
requests.append(add_xml)
return requests
def generate_context(self, cr, uid, context=None):
"""
generate xml with context header
"""
f_list = (
'context_tz', 'context_lang', 'name', 'signature', 'company_id',
)
# TODO: Use browse to add the address of the company
user = self.pool.get('res.users')
usr = user.read(cr, uid, [uid], context=context)[0]
ctx = Element('context')
for val in usr:
if val in f_list:
e = Element(val)
if usr[val]:
if isinstance(usr[val], list):
e.set('id', str(usr[val][0]))
e.text = str(usr[val][1])
else:
e.text = str(usr[val])
ctx.append(e)
return ctx
def die(msg):
import sys
root = Element('root')
node = error_node(msg)
root.append(node)
output_root(root)
sys.exit(0)
def to_etree(self, data, options=None, name=None, depth=0):
"""
Given some data, converts that data to an ``etree.Element`` suitable
for use in the XML output.
"""
if isinstance(data, (list, tuple)):
element = Element(name or 'objects')
if name:
element = Element(name)
element.set('type', 'list')
else:
element = Element('objects')
for item in data:
element.append(self.to_etree(item, options, depth=depth+1))
elif isinstance(data, dict):
if depth == 0:
element = Element(name or 'response')
else:
element = Element(name or 'object')
element.set('type', 'hash')
for (key, value) in data.iteritems():
element.append(self.to_etree(value, options, name=key, depth=depth+1))
elif isinstance(data, Bundle):
element = Element(name or 'object')
element.set('type', 'hash')
for field_name, field_object in data.data.items():
element.append(self.to_etree(field_object, options, name=field_name, depth=depth+1))
elif hasattr(data, 'dehydrated_type'):
if getattr(data, 'dehydrated_type', None) == 'related' and data.is_m2m == False:
if data.full:
return self.to_etree(data.fk_resource, options, name, depth+1)
else:
return self.to_etree(data.value, options, name, depth+1)
elif getattr(data, 'dehydrated_type', None) == 'related' and data.is_m2m == True:
if data.full:
element = Element(name or 'objects')
for bundle in data.m2m_bundles:
element.append(self.to_etree(bundle, options, bundle.resource_name, depth+1))
else:
element = Element(name or 'objects')
for value in data.value:
element.append(self.to_etree(value, options, name, depth=depth+1))
else:
return self.to_etree(data.value, options, name)
else:
element = Element(name or 'value')
simple_data = self.to_simple(data, options)
data_type = get_type_string(simple_data)
if data_type != 'string':
element.set('type', get_type_string(simple_data))
if data_type != 'null':
if isinstance(simple_data, unicode):
element.text = simple_data
else:
element.text = force_unicode(simple_data)
return element
def to_etree(self, data, options=None, name=None, depth=0):
"""
Given some data, converts that data to an ``etree.Element`` suitable
for use in the XML output.
"""
if isinstance(data, (list, tuple)):
new_name = None
if name:
element = Element(name)
new_name = self.objNames.get(name) if self.objNames else name
else:
element = Element('objects')
for item in data:
element.append(self.to_etree(item, options, name=new_name, depth=depth+1))
element[:] = sorted(element, key=lambda x: x.tag)
elif isinstance(data, dict):
if depth == 0:
element = Element(name or 'response')
else:
element = Element(name or self.objName)
for (key, value) in data.items():
element.append(self.to_etree(value, options, name=key, depth=depth+1))
element[:] = sorted(element, key=lambda x: x.tag)
elif isinstance(data, Bundle):
element = Element(name or self.objName)
for field_name, field_object in data.data.items():
element.append(self.to_etree(field_object, options, name=field_name, depth=depth+1))
element[:] = sorted(element, key=lambda x: x.tag)
elif hasattr(data, 'dehydrated_type'):
if getattr(data, 'dehydrated_type', None) == 'related' and data.is_m2m == False:
if data.full:
return self.to_etree(data.fk_resource, options, name, depth+1)
else:
return self.to_etree(data.value, options, name, depth+1)
elif getattr(data, 'dehydrated_type', None) == 'related' and data.is_m2m == True:
if data.full:
element = Element(name or 'objects')
for bundle in data.m2m_bundles:
element.append(self.to_etree(bundle, options, bundle.resource_name, depth+1))
else:
element = Element(name or 'objects')
for value in data.value:
element.append(self.to_etree(value, options, name, depth=depth+1))
else:
return self.to_etree(data.value, options, name)
else:
element = Element(name or 'value')
simple_data = self.to_simple(data, options)
if simple_data:
try:
element.text = unicode(simple_data)
except ValueError as e:
self.log.error('Not valid XML character detected in ', exc_info=True,
extra={'data': simple_data, 'original_exception': e})
cleaned_string = ''.join(c for c in simple_data if valid_xml_char_ordinal(c))
element.text = unicode(cleaned_string)
return element
def generate_branches() -> Element:
branches = Element('branches')
branch_spec = Element('hudson.plugins.git.BranchSpec')
branch_spec_name = Element('name')
branch_spec_name.text = '*/master'
branch_spec.append(branch_spec_name)
branches.append(branch_spec)
return branches
def dump_xml(inf, outf, pretty_print=True):
root = Element("wild")
game = to_xml(inf, "firered") # XXX
root.append(game)
outf.write("""<?xml version="1.0" encoding="utf-8"?>\n""")
xml = ElementTree(root)
xml.write(outf, pretty_print=pretty_print)
def clone(self):
clone = deepcopy(self.__element)
# Now the clone is its own root and lxml lost unused namespace
# prefixes.
# Re-attach it to a root with all namespaces
root = Element('ROOT', nsmap=ODF_NAMESPACES)
root.append(clone)
return self.__class__(clone)
def update(self, id, params={}):
"""Method updates record
Args:
id (int): record id
params (dict): record content, key - field name, value - field value
Returns:
bool: result
Raises:
event: track_before_update
event: track_after_update
"""
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'track_updating', 'issue', id, params), self._mh.fromhere())
if (not self._is_connected):
self._mh.demsg('htk_on_warning', self._mh._trn.msg(
'track_not_connected'), self._mh.fromhere())
return False
ev = event.Event('track_before_update', id, params)
if (self._mh.fire_event(ev) > 0):
id = ev.argv(0)
params = ev.argv(1)
if (ev.will_run_default()):
record = self.read(id, fields='all')[1]
if (record == None or len(record) == 0):
self._mh.demsg('htk_on_error', self._mh._trn.msg(
'track_unknown_record', id), self._mh.fromhere())
return None
params_old = record
for key, value in params.items():
params_old[key] = value
root = Element(config['ns'] + 'mc_issue_update')
SubElement(root, 'username').text = self._user
SubElement(root, 'password').text = self._passw
SubElement(root, 'issueId').text = str(id)
root.append(self._toxml(params_old))
res = self._client.send_request(
'mc_issue_update', body=tostring(root))
result = False
if (res != None):
result = True
self._mh.demsg('htk_on_debug_info', self._mh._trn.msg(
'track_updated', id), self._mh.fromhere())
ev = event.Event('track_after_update')
self._mh.fire_event(ev)
return result
def serialize_children(element: etree.Element, model: PyXmlModel, obj: object):
for child in model.children:
value = getattr(obj, child.name)
if hasattr(value, 'pyxml__model'):
child_element = PyXmlSerializer.serialize(value)
else:
child_element = etree.Element(child.name)
child_element.text = child.type(value)
element.append(child_element)
def generate_remote_config(url: str) -> Element:
remote_config = Element('userRemoteConfigs')
git_remote_config_tag = 'hudson.plugins.git.UserRemoteConfig'
git_remote_config = Element(git_remote_config_tag)
url_element = Element('url')
url_element.text = url
git_remote_config.append(url_element)
remote_config.append(git_remote_config)
return remote_config
def fromtree(qvmtree):
root = Element('root')
for st in qvmtree:
if not st.__class__ == ExpressionCall:
raise ValueError("Unexpected node " + str(st.__class__))
if not st.callee.value in ('Task_DeclareParameters', 'Task_New'):
raise ValueError("Unexpected callee " + str(st.callee.value))
if st.callee.value == 'Task_DeclareParameters':
root.append(strepr(st))
elif st.callee.value == 'Task_New':
root.append(strepr(st))
return tostring(root, pretty_print=True)
def create_comps_xml(packages_groups):
"""
Construct XML string representing the 'comps' element.
Args:
packages_groups ({str:[str]}): dictionary where key is the package group
name and value is the list of packages
that are member of the group
Returns:
str: string representing the XML generated
"""
root = Element('comps')
for group_name, group_pkgs in packages_groups.iteritems():
root.append(create_group_xml(group_name, group_pkgs))
return E.tostring(root, pretty_print=True, doctype=COMPS_DOCTYPE,
xml_declaration=True, encoding="UTF-8")
def tree_to_xml(tree):
"""
Convert a NLTK Tree object into xml tree using lxml.
"""
if tree.height() == 2:
xml_str = Element('morpheme', pos=tree.node)
leaf = LEAF_REGEX.search(tree[0])
if leaf is not None:
token, lemma = leaf.group(1, 2)
else:
token = lemma = tree[0]
xml_str.set('lemma', lemma)
xml_str.text = token
else:
xml_str = Element('segment', pos=tree.node)
for child in tree:
xml_str.append(tree_to_xml(child))
return xml_str
def store(self, xml_file_name=default_database_path):
output_file = open(xml_file_name, "w")
root = Element("synchrotron")
#structure the root element
for dev in self.devices.itervalues():
devElement = Element("device")
devElement.set("uuid", dev.uuid)
devElement.set("sync_dir", dev.sync_dir)
for sync_file in dev.files:
fileElement = Element("file")
fileElement.set("filename", sync_file.filename)
fileElement.set("sync_time", sync_file.sync_time)
devElement.append(fileElement)
root.append(devElement)
#add the root elment to a tree and write it to a file
etree.ElementTree(root).write(output_file)
output_file.close()
def format_contents(node, *args, **kwargs):
root = Element("ul")
root.attrib["class"] = "table-of-contents"
headings = node.xpath("//h2")
for heading in headings:
li = Element("li")
link = Element("a")
title = heading.text_content()
link.text = title
if "id" in heading.attrib:
link.attrib["href"] = "#" + heading.attrib.get('id')
else:
heading_id = slugify(title)
heading.attrib["id"] = heading_id
link.attrib["href"] = "#" + heading_id
li.append(link)
root.append(li)
return root
def get_dependencies_vt_as_xml_str(vt_id, dep_list):
""" Return an xml element with dependencies as string."""
vt_deps_xml = Element('vt_deps')
for dep in dep_list:
_vt_dep = Element('dependency')
try:
_vt_dep.set('vt_id', dep)
except TypeError:
logger.error('Not possible to add dependency %s for vt %s' %
(dep, vt_id))
continue
vt_deps_xml.append(_vt_dep)
_deps_list = vt_deps_xml.findall("dependency")
deps = ''
for _dep in _deps_list:
deps += (tostring(_dep).decode('utf-8'))
return deps
def run_solr_queue():
h1 = httplib.HTTPConnection(solr_host)
h1.connect()
while True:
(ia, body, page_count) = solr_queue.get()
add = Element("add")
doc = build_doc(ia, body, page_count)
add.append(doc)
r = tostring(add).encode('utf-8')
url = 'http://%s/solr/inside/update' % solr_host
h1.request('POST', url, r, {'Content-type': 'text/xml;charset=utf-8'})
response = h1.getresponse()
response_body = response.read()
assert response.reason == 'OK'
solr_ia_status_lock.acquire()
solr_ia_status = ia
solr_ia_status_lock.release()
solr_queue.task_done()
def _node_to_xml(treeitem):
code = Element("code")
code.append(_create_element("id", unicode(treeitem.code_id)))
code.append(_create_element("label", unicode(treeitem.label)))
children = Element("children")
for child in treeitem.children:
children.append(_node_to_xml(child))
code.append(children)
return code
def __exit__(self, type, value, traceback):
if not self.append:
# Writing dimensions
# asdasd
for name, dim in self.nc_dataset.dimensions.items():
element = Element(PREFIX + 'dimension')
element.set('name', name)
element.set('length', str(dim.size))
if dim.isunlimited:
element.set('isUnlimited', "true")
self.dataset.getroot().append(element)
# Writing attributes
for ncattr in self.nc_dataset.ncattrs():
element = Element(PREFIX + 'attribute')
element.set('name', ncattr)
element.set('value', self.nc_dataset.getncattr(ncattr))
self.dataset.getroot().append(element)
# Writing variables
for name, var in self.nc_dataset.variables.items():
element = Element(PREFIX + 'variable')
element.set('name', name)
element.set('shape', " ".join(var.dimensions))
element.set('type', var.dtype.str[1:])
# Writing variable attributes
for ncattr in var.ncattrs():
attr_elem = Element(PREFIX + 'attribute')
attr_elem.set('name', ncattr)
attr_elem.set('value', var.getncattr(ncattr))
element.append(attr_elem)
if var.chunking() != 'contiguous':
attr_elem = Element(PREFIX + 'attribute')
attr_elem.set('name', '_ChunkSizes')
attr_elem.set('type', 'int')
attr_elem.set('value', " ".join([str(s) for s in var.chunking()]))
element.append(attr_elem)
self.dataset.getroot().append(element)
return self.dataset.write(self.file_path(), xml_declaration=True, encoding="UTF-8", pretty_print=True)
def sign_full_xml(self, message, privkey, cert, uri, type='libro'):
doc = etree.fromstring(message)
string = etree.tostring(doc[0])
mess = etree.tostring(etree.fromstring(string), method="c14n")
digest = base64.b64encode(self.digest(mess))
reference_uri='#'+uri
signed_info = Element("SignedInfo")
c14n_method = SubElement(signed_info, "CanonicalizationMethod", Algorithm='http://www.w3.org/TR/2001/REC-xml-c14n-20010315')
sign_method = SubElement(signed_info, "SignatureMethod", Algorithm='http://www.w3.org/2000/09/xmldsig#rsa-sha1')
reference = SubElement(signed_info, "Reference", URI=reference_uri)
transforms = SubElement(reference, "Transforms")
SubElement(transforms, "Transform", Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315")
digest_method = SubElement(reference, "DigestMethod", Algorithm="http://www.w3.org/2000/09/xmldsig#sha1")
digest_value = SubElement(reference, "DigestValue")
digest_value.text = digest
signed_info_c14n = etree.tostring(signed_info,method="c14n",exclusive=False,with_comments=False,inclusive_ns_prefixes=None)
att = 'xmlns="http://www.w3.org/2000/09/xmldsig#" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"'
#@TODO Find better way to add xmlns:xsi attrib
signed_info_c14n = signed_info_c14n.decode().replace("<SignedInfo>", "<SignedInfo %s>" % att )
xmlns = 'http://www.w3.org/2000/09/xmldsig#'
sig_root = Element("Signature",attrib={'xmlns':xmlns})
sig_root.append(etree.fromstring(signed_info_c14n))
signature_value = SubElement(sig_root, "SignatureValue")
key = crypto.load_privatekey(type_,privkey.encode('ascii'))
signature = crypto.sign(key,signed_info_c14n,'sha1')
signature_value.text =textwrap.fill(base64.b64encode(signature).decode(),64)
key_info = SubElement(sig_root, "KeyInfo")
key_value = SubElement(key_info, "KeyValue")
rsa_key_value = SubElement(key_value, "RSAKeyValue")
modulus = SubElement(rsa_key_value, "Modulus")
key = load_pem_private_key(privkey.encode('ascii'),password=None, backend=default_backend())
longs = self.env['account.invoice'].long_to_bytes(key.public_key().public_numbers().n)
modulus.text = textwrap.fill(base64.b64encode(longs).decode(),64)
exponent = SubElement(rsa_key_value, "Exponent")
longs = self.env['account.invoice'].long_to_bytes(key.public_key().public_numbers().e)
exponent.text = self.ensure_str(base64.b64encode(longs))
x509_data = SubElement(key_info, "X509Data")
x509_certificate = SubElement(x509_data, "X509Certificate")
x509_certificate.text = '\n'+textwrap.fill(cert,64)
msg = etree.tostring(sig_root)
msg = msg if self.xml_validator(msg, 'sig') else ''
fulldoc = message.replace('</LibroGuia>','%s\n</LibroGuia>' % msg.decode())
fulldoc = fulldoc if self.xml_validator(fulldoc, type) else ''
return fulldoc
def _unpack(self, data, reference_uri):
sig_root = Element(ds_tag("Signature"), nsmap=self.namespaces)
doc_root = sig_root
if self.method == methods.enveloped:
if isinstance(data, (str, bytes)):
raise InvalidInput("When using enveloped signature, **data** must be an XML element")
c14n_input = self.get_root(data)
doc_root = self.get_root(data)
if reference_uri is not None:
# Only sign the referenced element
if not reference_uri.startswith('#'):
reference_uri = '#'+reference_uri
c14n_input = self.get_root(self._resolve_reference(doc_root, {'URI': reference_uri}))
else:
reference_uri = ""
signature_placeholders = self._findall(doc_root, "Signature[@Id='placeholder']", anywhere=True)
if len(signature_placeholders) == 0:
doc_root.append(sig_root)
elif len(signature_placeholders) == 1:
sig_root = signature_placeholders[0]
del sig_root.attrib["Id"]
_remove_sig(self._findall(c14n_input, "Signature[@Id='placeholder']", anywhere=True)[0])
else:
raise InvalidInput("Enveloped signature input contains more than one placeholder")
# get signed data id attribute value for reference uri
payload_id = c14n_input.get("Id", c14n_input.get("ID"))
if payload_id is not None:
# set default reference uri based on data id attribute value
reference_uri = "#{}".format(payload_id)
elif self.method == methods.detached:
if reference_uri is None:
reference_uri = "#{}".format(data.get("Id", data.get("ID", "object")))
c14n_input = self.get_root(data)
elif self.method == methods.enveloping:
c14n_input = Element(ds_tag("Object"), nsmap=self.namespaces, Id="object")
if isinstance(data, (str, bytes)):
c14n_input.text = data
else:
c14n_input.append(self.get_root(data))
reference_uri = "#object"
return sig_root, doc_root, c14n_input, reference_uri
def store_in_xml(data_list, filename):
movie_list_type = filename.split('/')[1]
elem_keys = list(data_list[0].keys())
root = Element(movie_list_type)
for data in data_list:
sub_elem = Element('movie')
for key in elem_keys:
elem = Element(key)
elem.text = data[key]
sub_elem.append(elem)
root.append(sub_elem)
with xmlfile(filename, encoding='utf-8') as xml_file:
xml_file.write_declaration(standalone=True)
xml_file.write(root)
def test_xml_xpath(self):
root = Element("root")
foo = Element("foo")
bar = Element("bar")
baz = Element("baz")
root.append(foo)
root.append(bar)
foo.append(baz)
assert validate(xml_xpath("./descendant-or-self::node()"),
root) == [root, foo, baz,
bar], "Returns correct node set"
assert validate(xml_xpath("./child::qux"),
root) is None, "Returns None when node set is empty"
assert validate(
xml_xpath("name(.)"),
root) == "root", "Returns function values instead of node sets"
self.assertRaises(ValueError, validate, xml_xpath("."),
"not an Element")
class XMLSerializer(ISerializer):
def __init__(self):
self._current_element = Element('elem')
def _add_subproperty(self, elem, name, value):
name = str(name)
if name[0].isdigit():
name = f'n{name}'
item = Element(name)
if isinstance(value, dict):
for key in value:
self._add_subproperty(item, key, value[key])
else:
item.text = str(value)
elem.append(item)
def add_property(self, name, value):
name = str(name)
if name[0].isdigit():
name = f'n{name}'
prop = Element(name)
if isinstance(value, dict):
for key in value:
self._add_subproperty(prop, key, value[key])
else:
prop.text = str(value)
self._current_element.append(prop)
def update_properties(self, properties_dict):
for key in properties_dict:
self.add_property(key, properties_dict[key])
def to_str(self, *, pretty=False, encoding='unicode'):
return ET.tostring(self._current_element,
pretty_print=pretty,
encoding=encoding)
def dumpf(self, fout, *, pretty=True, encoding='unicode'):
fout.write(self.to_str(pretty=pretty, encoding=encoding))
def clear_cash(self):
self._current_element = {}
def create_value_property(
key: Union[str, None],
value: Union[int, str, datetime, Decimal, Enum],
root: etree.Element,
) -> None:
if not value:
return
elif isinstance(value, Enum):
value = value.value
elif isinstance(value, datetime):
value = value.strftime("%d.%m.%Y %H:%M")
if key is None:
property_element = etree.Element("property")
else:
property_element = etree.Element("property", name=key)
value_element = etree.Element("value")
property_element.append(value_element)
value_element.text = str(value)
root.append(property_element)
def createMetadata(self, textValue):
self.svg = self.document.getroot()
# create only dc:description or metadata/RDF/dc:description ?
metadatas = self.document.xpath('//svg:metadata', namespaces=NSS)
if metadatas is None or len(metadatas) == 0:
metadata = Element(addNS('metadata', 'svg'))
metadata.set('id', 'metadatasvg2lvl')
self.svg.append(metadata)
else:
metadata = metadatas[0]
rdfs = metadata.xpath('//rdf:RDF', namespaces=NSS)
if rdfs is None or len(rdfs) == 0:
rdf = Element(addNS('RDF', 'rdf'))
metadata.append(rdf)
else:
rdf = rdfs[0]
works = rdf.xpath('//cc:Work', namespaces=NSS)
if works is None or len(works) == 0:
work = Element(addNS('Work', 'cc'))
work.set(addNS('about', 'rdf'), '')
rdf.append(work)
else:
work = works[0]
formats = work.xpath('//dc:format', namespaces=NSS)
if formats is None or len(formats) == 0:
format = Element(addNS('format', 'dc'))
format.text = 'image/svg+xml'
work.append(format)
types = work.xpath('//dc:type', namespaces=NSS)
if types is None or len(types) == 0:
typeNode = Element(addNS('type', 'dc'))
typeNode.set(addNS('resource', 'rdf'),
'http://purl.org/dc/dcmitype/StillImage')
work.append(typeNode)
description = Element(addNS('description', 'dc'))
description.text = textValue
work.append(description)
def vim_modelines_fixup(
repositories_node: etree.Element
) -> None:
"""
Find, remove and reinsert modeline comment
to the end of the file.
"""
vim_comments = []
for node in repositories_node:
if (
isinstance(node, etree._Comment)
and node.text.startswith(" vim:")
):
vim_comments.append(node)
for vim_comment in vim_comments:
repositories_node.remove(vim_comment)
repositories_node.append(vim_comment)
def get_params_vt_as_xml_str(vt_id, vt_params):
""" Return an xml element with params formatted as string."""
vt_params_xml = Element('vt_params')
for prefs in vt_params.items():
vt_param = Element('vt_param')
vt_param.set('type', prefs[1]['type'])
vt_param.set('id', prefs[0])
xml_name = SubElement(vt_param, 'name')
xml_name.text = prefs[1]['name']
if prefs[1]['default']:
xml_def = SubElement(vt_param, 'default')
xml_def.text = prefs[1]['default']
vt_params_xml.append(vt_param)
params_list = vt_params_xml.findall("vt_param")
params = ''
for param in params_list:
params += (tostring(param).decode('utf-8'))
return params
def _add_unique_gradients(
svg_defs: etree.Element,
color_glyph: ColorGlyph,
reuse_cache: ReuseCache,
):
for gradient in color_glyph.picosvg.xpath("//svg:defs/*"):
gradient = copy.deepcopy(gradient)
curr_id: str = gradient.attrib["id"]
new_id = f"{color_glyph.glyph_name}::{curr_id}"
del gradient.attrib["id"]
gradient_xml: str = etree.tostring(gradient)
if gradient_xml in reuse_cache.gradient_to_id:
reuse_cache.old_to_new_id[curr_id] = reuse_cache.gradient_to_id[
gradient_xml]
else:
gradient.attrib["id"] = new_id
reuse_cache.old_to_new_id[curr_id] = new_id
reuse_cache.gradient_to_id[gradient_xml] = new_id
svg_defs.append(gradient)
def get_response(self) -> Element:
"""Generate Root response element"""
response = Element(f"{{{NS_SAML_PROTOCOL}}}Response", nsmap=NS_MAP)
response.attrib["Version"] = "2.0"
response.attrib["IssueInstant"] = self._issue_instant
response.attrib["Destination"] = self.provider.acs_url
response.attrib["ID"] = get_random_id()
if self.auth_n_request.id:
response.attrib["InResponseTo"] = self.auth_n_request.id
response.append(self.get_issuer())
status = SubElement(response, f"{{{NS_SAML_PROTOCOL}}}Status")
status_code = SubElement(status, f"{{{NS_SAML_PROTOCOL}}}StatusCode")
status_code.attrib[
"Value"] = "urn:oasis:names:tc:SAML:2.0:status:Success"
response.append(self.get_assertion())
return response
def Node_Update(ship_macro, new_range):
# Scale range to meters.
new_range = new_range * 1000
# Unclear on how this works.
# Assuming the ship macro format should match the defaults format,
# then can try to lay out nodes in the same structure.
# For safety, add to existing nodes if found.
prop_node = ship_macro.find('./properties')
range_str = str(new_range)
radar_node = prop_node.find('./radar')
if radar_node == None:
radar_node = Element('radar', range = range_str)
prop_node.append(radar_node)
assert radar_node.tail == None
else:
radar_node.set('range', range_str)
# Also set up the max radar.
new_max = new_range * 1.2
new_max_str = f'{new_max:.0f}'
stats_node = prop_node.find('./statistics')
if stats_node == None:
stats_node = Element('statistics')
prop_node.append(stats_node)
max_node = stats_node.find('./max')
if max_node == None:
max_node = Element('max')
stats_node.append(max_node)
max_radar_node = max_node.find('./radar')
if max_radar_node == None:
max_radar_node = Element('radar', range = new_max_str)
max_node.append(max_radar_node)
else:
max_radar_node.set('range', new_max_str)
return True
def to_etree(self):
"""
Creates an eTree XML element
"""
root = Element('annotations')
root.set('textSource', self.rpt_id + '.txt')
# TODO:
annotations = []
for annotator in self.annotations:
annotations.extend(self.annotations[annotator])
for annotation in annotations:
elements_to_append = annotation.to_etree()
for element in elements_to_append:
root.append(element)
#root.append(annotation.to_etree())
#root.append(annotation.get_xml())
#root.append(annotation.get_mention_xml())
# xml for adjudication status
adjudication_status = SubElement(root, 'eHOST_Adjudication_status')
adjudication_status.set('version', '1.0')
selected_annotators = SubElement(adjudication_status,
'Adjudication_Selected_Annotators')
selected_annotators.set('version', '1.0')
selected_classes = SubElement(adjudication_status,
'Adjudication_Selected_Classes')
selected_classes.set('version', '1.0')
adjudication_others = SubElement(adjudication_status,
'Adjudication_Others')
check_spans = SubElement(adjudication_others, 'CHECK_OVERLAPPED_SPANS')
check_spans.text = 'false'
check_attributes = SubElement(adjudication_others, 'CHECK_ATTRIBUTES')
check_attributes.text = 'false'
check_relationship = SubElement(adjudication_others,
'CHECK_RELATIONSHIP')
check_relationship.text = 'false'
check_class = SubElement(adjudication_others, 'CHECK_CLASS')
check_class.text = 'false'
check_comment = SubElement(adjudication_others, 'CHECK_COMMENT')
check_comment.text = 'false'
return root
def xml(treelist, ids=False, encoding='utf-8', xml_decl=True, pp=True):
"""
Convert a list of Trees into an xml structure.
"""
if isinstance(treelist, Tree):
treelist = [treelist]
elif not isinstance(treelist, collections.Iterable):
raise ValueError('Input must be a iterator of trees.')
if not ids:
treelist = enumerate(treelist)
root = Element('lexicon')
# input must be a list of id,tree pairs
for id, tree in treelist:
word = Element('word', id=str(id))
word.append(tree_to_xml(tree))
root.append(word)
return tostring(root,
pretty_print=pp,
encoding=encoding,
xml_declaration=xml_decl)
def element(self):
childA = Element("childA", {"a": "1"})
childB = Element("childB", {"b": "2"})
childC = Element("childC")
childA.text = "childAtext"
childA.tail = "childAtail"
childB.text = "childBtext"
childB.tail = "childBtail"
childB.append(childC)
parent = Element("parent", {
"attrkey1": "attrval1",
"attrkey2": "attrval2"
})
parent.text = "parenttext"
parent.tail = "parenttail"
parent.append(childA)
parent.append(childB)
return parent
def serialize(self):
category_element = Element('category',
name=self.__home_work_category.name)
if self.__home_work_category.max_points is not None:
category_element.attrib['maxpoints'] = str(
self.__home_work_category.max_points)
for home_work in self.__home_work_category.home_works:
home_work_element = Element('homework',
id=str(home_work.id),
name=home_work.name,
moodleid=str(home_work.moodle_id))
if home_work.required_points is not None:
home_work_element.attrib['reqpoints'] = str(
home_work.required_points)
category_element.append(home_work_element)
return category_element
def get_assertion_subject(self) -> Element:
"""Generate Subject Element with NameID and SubjectConfirmation Objects"""
subject = Element(f"{{{NS_SAML_ASSERTION}}}Subject")
subject.append(self.get_name_id())
subject_confirmation = SubElement(
subject, f"{{{NS_SAML_ASSERTION}}}SubjectConfirmation")
subject_confirmation.attrib[
"Method"] = "urn:oasis:names:tc:SAML:2.0:cm:bearer"
subject_confirmation_data = SubElement(
subject_confirmation,
f"{{{NS_SAML_ASSERTION}}}SubjectConfirmationData")
if self.auth_n_request.id:
subject_confirmation_data.attrib[
"InResponseTo"] = self.auth_n_request.id
subject_confirmation_data.attrib[
"NotOnOrAfter"] = self._valid_not_on_or_after
subject_confirmation_data.attrib["Recipient"] = self.provider.acs_url
return subject
def get_dependencies_vt_as_xml_str(vt_id, dep_list):
""" Return an xml element with dependencies as string.
Arguments:
vt_id (str): VT OID. Only used for logging in error case.
dep_list (List): List with the VT dependencies.
Return:
string: xml element as string.
"""
vt_deps_xml = Element('dependencies')
for dep in dep_list:
_vt_dep = Element('dependency')
try:
_vt_dep.set('vt_id', dep)
except TypeError:
logger.error('Not possible to add dependency %s for vt %s' %
(dep, vt_id))
continue
vt_deps_xml.append(_vt_dep)
return tostring(vt_deps_xml).decode('utf-8')
def create_element(name: str,
text: Any = None,
children: List[ElementT] = None,
**kwargs) -> ElementT:
"""Creates xml node with text or children elements.
:param name: Tag name of node with namespace
:param text: Text of node
:param children: Appends elements as child nodes
"""
el = Element(name, **kwargs)
if text:
if isinstance(text, datetime):
text = text.replace(tzinfo=pytz.timezone('GMT')). \
strftime("%a, %d %b %Y %H:%M:%S %Z")
el.text = text
elif isinstance(children, (list, tuple)):
for child in children:
el.append(child)
return el
def export_post_comments(self, nid, base_url):
wp = self.nsmap['wp']
content = self.nsmap['content']
dsq = self.nsmap['dsq']
post = self.posts[nid]
item_node = Element('item', nsmap=self.nsmap)
SubElement(item_node, 'title').text = post['title']
SubElement(item_node, 'link').text = base_url + self.get_post_path(post) + '/'
SubElement(item_node, '{%s}encoded' % content).text = CDATA(post['body'])
SubElement(item_node, '{%s}thread_identifier' % dsq).text = '/' + self.get_post_path(post) + '/'
SubElement(item_node, '{%s}post_date_gmt' % wp).text = str(post['date'])
SubElement(item_node, '{%s}comment_status' % wp).text = 'open'
if nid in self.comments.keys():
for comment in self.comments[nid]:
item_node.append(self.export_comment(comment))
return item_node
def add_demands(self, source_node, demand_ts, demand_dt):
links = self.graph.es
nodes = self.graph.vs
xsubnetworks = Element('subnetworks')
xdemands = Element('demands')
self.scenario.append(xsubnetworks)
self.scenario.append(xdemands)
xsubnetwork = Element('subnetwork')
xsubnetworks.append(xsubnetwork)
xsubnetwork.set('id', str(1))
xsubnetwork.text = csv2string([e.index for e in links])
xdemand = Element('demand')
xdemands.append(xdemand)
xdemand.set('commodity_id', "0")
xdemand.set('subnetwork', str(1))
xdemand.set('start_time', "0")
xdemand.set('link_id', str(graph.incident(source_node, mode=OUT)[0]))
xdemand.set('dt', str(demand_dt))
xdemand.text = csv2string(demand_ts)
