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)