def _xml_parse(required_headers, payload): try: doc = Document() lcia = doc.createElement("lcia") doc.appendChild(lcia) headers = doc.createElement("headers") lcia.appendChild(headers) for x in required_headers: node = doc.createElement(x) info = doc.createTextNode(str(payload["header"][x])) node.appendChild(info) headers.appendChild(node) data = doc.createElement("data") lcia.appendChild(data) for x in payload["data"]: node = doc.createElement(x) info = doc.createTextNode(str(payload["data"][x])) node.appendChild(info) data.appendChild(node) xml_string = doc.toprettyxml(indent=" ") return xml_string except KeyError: raise KeyError("Missing Header")
def storeToFile(self, suffix=""): if not self.dataToStore: return doc = Document() results = doc.createElement("results") doc.appendChild(results) for a in self.dataToStore: item = doc.createElement("item") for k, d in a.items(): tag = doc.createElement(k) if k == "author": tag2 = doc.createElement("name") data = doc.createTextNode(d) tag2.appendChild(data) tag.appendChild(tag2) else: data = doc.createTextNode(" ".join(d.split())) tag.appendChild(data) item.appendChild(tag) results.appendChild(item) timestamp = time.strftime("%H%M%S_") f = open("output/" + timestamp + self.board + "_" + self.section + "_" + str(suffix) + ".xml", "w") f.write(doc.toprettyxml(indent=" ", encoding="utf-8")) f.close() self.dataToStore = []
def end_copy(self): try: self.user.put_object(self.dst_file, self.dstBucketName, self.dstObjectName) self.grant_public_permissions(self.dstBucketName, self.dstObjectName) doc = Document() cor = doc.createElement("CopyObjectResult") doc.appendChild(cor) lm = doc.createElement("LastModified") cor.appendChild(lm) lmText = doc.createTextNode(datetime(*self.src_ctm[:6]).isoformat()) lm.appendChild(lmText) lm = doc.createElement("ETag") cor.appendChild(lm) lmText = doc.createTextNode(str(self.src_md5)) lm.appendChild(lmText) x = doc.toxml(); self.setHeader(self.request, 'x-amz-copy-source-version-id', "1") self.setHeader(self.request, 'x-amz-version-id', "1") self.send_xml(x) self.request.finish() except cbException, (ex): ex.sendErrorResponse(self.request, self.requestId) traceback.print_exc(file=sys.stdout)
def xmlObjectDefinitionRepresentation(fileName, fileHash): doc = Document() dvObjectDefinition = doc.createElement('DIVAObjectDefinition') doc.appendChild(dvObjectDefinition) nextObject = doc.createElement('objectName') nextObject.appendChild(doc.createTextNode(fileName)) dvObjectDefinition.appendChild(nextObject) nextObject = doc.createElement('categoryName') nextObject.appendChild(doc.createTextNode('ARCHIVE_DR')) dvObjectDefinition.appendChild(nextObject) nextObject = doc.createElement('comments') nextObject.appendChild(doc.createTextNode('MEDIASEALED FILE {}'.format(fileHash))) dvObjectDefinition.appendChild(nextObject) fileListObject = doc.createElement('fileList') dvObjectDefinition.appendChild(fileListObject) nextObject = doc.createElement('file') nextObject.appendChild(doc.createTextNode(fileName)) nextObject.setAttribute('checksumType', 'MD5') nextObject.setAttribute('checksumValue', fileHash) fileListObject.appendChild(nextObject) return ''.join(node.toprettyxml() for node in doc.childNodes)
def questions_to_aiml(questions): punctuation = "\"`~!@#$%^&()-_=+[{]}\|;:',<.>/?" _puncStripRE = re.compile("[" + re.escape(punctuation) + "]") # Create the minidom document doc = Document() # Create the <aiml> base element aiml = doc.createElement("aiml") doc.appendChild(aiml) for question, answer in questions: patterns = (re.sub(_puncStripRE, "", question), re.sub(_puncStripRE, "*", question)) for p in patterns: category = doc.createElement("category") pattern = doc.createElement("pattern") pattern.appendChild(doc.createTextNode(p.upper())) template = doc.createElement("template") template.appendChild(doc.createTextNode(answer)) category.appendChild(pattern) category.appendChild(template) aiml.appendChild(category) # Print our newly created XML return doc.toxml()
def parse_type_of(obj): """ @return: A C{ParsedDocstring} that encodes the type of the given object. @rtype: L{ParsedDocstring} @param obj: The object whose type should be returned as DOM document. @type obj: any """ # This is a bit hackish; oh well. :) from epydoc.markup.epytext import ParsedEpytextDocstring from xml.dom.minidom import Document doc = Document() epytext = doc.createElement('epytext') para = doc.createElement('para') doc.appendChild(epytext) epytext.appendChild(para) if type(obj) is types.InstanceType: link = doc.createElement('link') name = doc.createElement('name') target = doc.createElement('target') para.appendChild(link) link.appendChild(name) link.appendChild(target) name.appendChild(doc.createTextNode(str(obj.__class__.__name__))) target.appendChild(doc.createTextNode(str(obj.__class__))) else: code = doc.createElement('code') para.appendChild(code) code.appendChild(doc.createTextNode(type(obj).__name__)) return ParsedEpytextDocstring(doc)
def list_bucket(self): dirL = self.user.list_bucket(self.bucketName, self.request.args) doc = Document() # Create the <wml> base element xList = doc.createElement("ListBucketResult") xList.setAttribute("xmlns", "http://doc.s3.amazonaws.com/2006-03-01") doc.appendChild(xList) # Create the main <card> element xName = doc.createElement("Name") xList.appendChild(xName) xNameText = doc.createTextNode(str(self.bucketName)) xName.appendChild(xNameText) xIsTruncated = doc.createElement("IsTruncated") xList.appendChild(xIsTruncated) xIsTText = doc.createTextNode('false') xIsTruncated.appendChild(xIsTText) for obj in dirL: xObj = obj.create_xml_element(doc) xList.appendChild(xObj) x = doc.toxml(); self.send_xml(x) self.finish(self.request)
def create_fake_config_file(self): doc = Document() emc = doc.createElement("EMC") doc.appendChild(emc) storagetype = doc.createElement("StorageType") storagetypetext = doc.createTextNode("gold") emc.appendChild(storagetype) storagetype.appendChild(storagetypetext) ecomserverip = doc.createElement("EcomServerIp") ecomserveriptext = doc.createTextNode("1.1.1.1") emc.appendChild(ecomserverip) ecomserverip.appendChild(ecomserveriptext) ecomserverport = doc.createElement("EcomServerPort") ecomserverporttext = doc.createTextNode("10") emc.appendChild(ecomserverport) ecomserverport.appendChild(ecomserverporttext) ecomusername = doc.createElement("EcomUserName") ecomusernametext = doc.createTextNode("user") emc.appendChild(ecomusername) ecomusername.appendChild(ecomusernametext) ecompassword = doc.createElement("EcomPassword") ecompasswordtext = doc.createTextNode("pass") emc.appendChild(ecompassword) ecompassword.appendChild(ecompasswordtext) self.config_file_path = self.tempdir + '/' + config_file_name f = open(self.config_file_path, 'w') doc.writexml(f) f.close()
def _note2musicxml(note): doc = Document() note_node = doc.createElement("note") if note==None: #note is a rest rest = doc.createElement("rest") note_node.appendChild(rest) else: #add pitch info pitch = doc.createElement("pitch") step = doc.createElement("step") step.appendChild(doc.createTextNode(note.name[:1])) pitch.appendChild(step) octave = doc.createElement("octave") octave.appendChild(doc.createTextNode(str(note.octave))) pitch.appendChild(octave) #check for alterations count = 0 for i in note.name[1:]: if i=="b": count-=1 elif i=="#": count +=1 if count != 0: alter = doc.createElement("alter") alter.appendChild(doc.createTextNode(str(count))) pitch.appendChild(alter) note_node.appendChild(pitch) return note_node
def todaysNews(): query = News.all() query.order("-createdAt") results = query.fetch(limit=1) mostRecentNews = results.pop() # Create the minidom level document doc = Document() newsElement = doc.createElement("news") doc.appendChild(newsElement) #headline headlineElement = doc.createElement("headline") headline = doc.createTextNode(mostRecentNews.headline) headlineElement.appendChild(headline) newsElement.appendChild(headlineElement) #content contentElement = doc.createElement("content") content = doc.createTextNode(mostRecentNews.content) contentElement.appendChild(content) newsElement.appendChild(contentElement) #date dateElement = doc.createElement("date") date = doc.createTextNode(str(mostRecentNews.createdAt)) dateElement.appendChild(date) newsElement.appendChild(dateElement) out = doc.toxml() return out
def make_xml_string(self, path, requestId): doc = Document() # Create the <wml> base element xError = doc.createElement("Error") doc.appendChild(xError) # Create the main <card> element xCode = doc.createElement("Code") xCodeText = doc.createTextNode(self.code) xCode.appendChild(xCodeText) xError.appendChild(xCode) xMsg = doc.createElement("Message") xMsgText = doc.createTextNode(self.eMsg) xMsg.appendChild(xMsgText) xError.appendChild(xMsg) xRsc = doc.createElement("Resource") xRscText = doc.createTextNode(path) xRsc.appendChild(xRscText) xError.appendChild(xRsc) xRId = doc.createElement("RequestId") xRIdText = doc.createTextNode(str(requestId)) xRId.appendChild(xRIdText) xError.appendChild(xRId) for k in self.custom_xml.keys(): xId = doc.createElement(k) xText = doc.createTextNode(self.custom_xml[k]) xId.appendChild(xText) xError.appendChild(xId) return doc.toxml()
def generate_ticket_body(subject_text, body_text, requester_email_text, use_configured_assignee=True): doc = Document() # Create the outer ticket element ticket = doc.createElement("ticket") doc.appendChild(ticket) # Create the other data subject = doc.createElement('subject') subject.appendChild(doc.createTextNode(subject_text)) ticket.appendChild(subject) requester = doc.createElement('requester-email') requester.appendChild(doc.createTextNode(requester_email_text)) ticket.appendChild(requester) requester = doc.createElement('group-id') requester.appendChild(doc.createTextNode('86020')) ticket.appendChild(requester) if (use_configured_assignee and getattr(settings, "ZENDESK_ASSIGN_TO_USER_ID", None)): value = getattr(settings, "ZENDESK_ASSIGN_TO_USER_ID") assignee = doc.createElement('assignee-id') assignee.appendChild(doc.createTextNode(unicode(value))) ticket.appendChild(assignee) description = doc.createElement('description') description.appendChild(doc.createTextNode(body_text)) ticket.appendChild(description) return doc.toxml()
def record_add_field(rec, tag, ind1='', ind2='', subfields=[], controlfield_value=''): doc = Document() datafield = doc.createElement('datafield') datafield.setAttribute('tag', tag) datafield.setAttribute('ind1', ind1) datafield.setAttribute('ind2', ind2) for subfield in subfields: field = doc.createElement('subfield') field.setAttribute('code', subfield[0]) ## In order to be parsed it needs to a propper XML data = "<dummy>" + escape_for_xml(subfield[1]) + "</dummy>" try: data = parseString(data).firstChild for child in data.childNodes: field.appendChild(child.cloneNode(child)) except ExpatError: field.appendChild(doc.createTextNode(str(subfield[1]))) datafield.appendChild(field) if controlfield_value: controlfield = doc.createElement('controlfield') controlfield.setAttribute('tag', tag) controlfield.appendChild(doc.createTextNode(str(controlfield_value))) rec.appendChild(controlfield) else: rec.appendChild(datafield) return rec
def rows2xml(rows): # # http://www.postneo.com/projects/pyxml/ # from xml.dom.minidom import Document doc = Document() table = doc.createElement('table') doc.appendChild(table) for i, r in enumerate(rows): if i == 0: # # Don't write column labels as a separate row. # continue row = doc.createElement('row') row.setAttribute('id', str(i)) for j, c in enumerate(r): cell = doc.createElement('cell') name = doc.createElement('name') name.appendChild(doc.createTextNode(rows[0][j])) val = doc.createElement('val') val.appendChild(doc.createTextNode(c)) cell.appendChild(name) cell.appendChild(val) row.appendChild(cell) table.appendChild(row) return doc
def parseRss(l, info): feed = Document() rss = feed.createElement("rss") channel = feed.createElement("channel") title = feed.createElement("title") title_text = feed.createTextNode(info["title"]) link = feed.createElement("link") link_text = feed.createTextNode(info["root"]) title.appendChild(title_text) link.appendChild(link_text) channel.appendChild(title) channel.appendChild(link) for p in l: item = feed.createElement('item') pair = {\ 'title':p['title'], 'description':p['content'],\ 'link':info['root']+'/'+p['rlink']} for n in pair.keys(): node = feed.createElement(n) node_text = feed.createTextNode(pair[n]) node.appendChild(node_text) item.appendChild(node) channel.appendChild(item) rss.appendChild(channel) feed.appendChild(rss) return feed.toxml()
def createXmlandWrite(self, dataToStore, filename): if not dataToStore: return doc = Document() results = doc.createElement("results") doc.appendChild(results) for a in dataToStore: item = doc.createElement("item") for k, d in a.items(): tag = doc.createElement(k) if k == "author": tag2 = doc.createElement("name") data = doc.createTextNode(d) tag2.appendChild(data) tag.appendChild(tag2) else: data = doc.createTextNode(toUnicode(d)) tag.appendChild(data) item.appendChild(tag) results.appendChild(item) qwe = doc.toprettyxml(indent=" ", encoding = "UTF-8") writeToFile(qwe, "scf_"+filename, "/mnt/minerva1/nlp/projects/spinn3r/solr_data/xjerab13", #"/mnt/minerva1/nlp/projects/blogs_download2/sail_data_out", #"e:\\tmp\\tmp\\conv", extension=".xml", timestamp=True )
def saveTextureList(self, *args, **kwargs): ''' write an xml file with a list of the scenes textures and timestamps ''' fileNodes = pm.ls(type='file') sceneName = path.getSceneName() xmlFileName = sceneName+'_textureList' doc = Document() textureList = doc.createElement('textureList') textureList.setAttribute('sceneName', sceneName) doc.appendChild(textureList) for node in fileNodes: fileTextureName = pm.getAttr(node+'.fileTextureName') if os.path.isfile(fileTextureName): time = os.path.getmtime(fileTextureName) textureNode = doc.createElement('textureNode') textureNode.setAttribute('nodeName', node) textureList.appendChild(textureNode) texturePath = doc.createElement('path') texturePath.appendChild(doc.createTextNode(fileTextureName) ) textureNode.appendChild(texturePath) textureTime = doc.createElement('time') textureTime.appendChild(doc.createTextNode(str(time) ) ) textureNode.appendChild(textureTime) f = open(self.settingsPath+xmlFileName+'.xml', 'w+') #f.write(doc.toprettyxml(indent=' ') ) #This is super slow !!!!! doc.writexml(f) f.close()
def toXML(self, includeChoice=False): doc = Document() pollNode = doc.createElement("poll") indexNode = doc.createElement("index") pollNode.appendChild(indexNode) indexText = doc.createTextNode(str(self.index)) indexNode.appendChild(indexText) backgroundNode = doc.createElement("background") pollNode.appendChild(backgroundNode) backgroundText = doc.createTextNode(self.background) backgroundNode.appendChild(backgroundText) ownerNode = doc.createElement("owner"); pollNode.appendChild(ownerNode) ownerText = doc.createTextNode(self.owner.name) ownerNode.appendChild(ownerText) keyNode = doc.createElement("key") pollNode.appendChild(keyNode) keyText = doc.createTextNode(str(self.key())) keyNode.appendChild(keyText) if includeChoice: choiceNode = doc.createElement("choices") pollNode.appendChild(choiceNode) for choice in self.choices: choiceNode.appendChild(choice.toXML()) return pollNode
def saveXML(outputList): doc = Document() taskList = doc.createElement("taskList") doc.appendChild(taskList) for elem in outputList: commandList, output = elem task = doc.createElement("task") for command in commandList: command = " ".join(updateCommand(command.strip().split(" "))) cmd = doc.createElement("command") cmd.appendChild(doc.createTextNode(command)) task.appendChild(cmd) output = output.strip().split("\n") out = doc.createElement("output") for line in output: out.appendChild(doc.createTextNode(line)) task.appendChild(out) taskList.appendChild(task) f = open("output_task.xml", "w") f.write(unescape(doc.toprettyxml())) f.close()
def _note2musicxml(note): doc = Document() note_node = doc.createElement('note') if note == None: # note is a rest rest = doc.createElement('rest') note_node.appendChild(rest) else: # add pitch info pitch = doc.createElement('pitch') step = doc.createElement('step') step.appendChild(doc.createTextNode(note.name[:1])) pitch.appendChild(step) octave = doc.createElement('octave') octave.appendChild(doc.createTextNode(str(note.octave))) pitch.appendChild(octave) # check for alterations count = 0 for i in note.name[1:]: if i == 'b': count -= 1 elif i == '#': count += 1 if count != 0: alter = doc.createElement('alter') alter.appendChild(doc.createTextNode(str(count))) pitch.appendChild(alter) note_node.appendChild(pitch) return note_node
def constructLogXml(event, comment): eventString = str(event) commentString = str(comment) doc = Document() #Create root root = doc.createElement('log_entry') doc.appendChild(root) #Add event event = doc.createElement('event') root.appendChild(event) eventText = doc.createTextNode(eventString) event.appendChild(eventText) #Add timestamp time = doc.createElement('time') root.appendChild(time) timeText = doc.createTextNode(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) time.appendChild(timeText) #Add cell ID cell = doc.createElement('cell_id') root.appendChild(cell) cellText = doc.createTextNode('4') cell.appendChild(cellText) #add comment comment = doc.createElement('comment') root.appendChild(comment) commentText = doc.createTextNode(commentString) comment.appendChild(commentText) return doc.toxml(encoding="utf-8")
def createXmlHandler(self, handler): doc = Document() xml_handler = doc.createElement(WFConstants.TAG_NAME_END_HANDLER) xml_name_handler = doc.createElement(WFConstants.TAG_NAME_NAME) xml_name_handler_content = doc.createTextNode(handler.name) xml_name_handler.appendChild(xml_name_handler_content) xml_class_name_handler = doc.createElement(WFConstants.TAG_NAME_CLASS_NAME) xml_class_name_handler_content = doc.createTextNode(handler.class_name) xml_class_name_handler.appendChild(xml_class_name_handler_content) xml_handler.appendChild(xml_name_handler) xml_handler.appendChild(xml_class_name_handler) for parameter in node.parameters: xml_param_handler = doc.createElement(WFConstants.TAG_NAME_PARAM) xml_param_handler.setAttribute(WFConstants.ATTRIBUTE_NAME_NAME, parameter.name) if not parameter.without_prefix: if parameter.is_constant: prefix = "constant:" else: prefix = "variable:" xml_param_handler.setAttribute(WFConstants.ATTRIBUTE_NAME_VALUE, prefix + parameter.value) else: xml_param_handler.setAttribute(WFConstants.ATTRIBUTE_NAME_VALUE, parameter.value) xml_handler.appendChild(xml_param_handler) return xml_handler
def save_pairs(pairs, path): doc = Document() corpus = doc.createElement('entailment-corpus') doc.appendChild(corpus) i = 0 for pair in pairs: try: text, hypothesis, entailment = pair except ValueError: print "Too many values: ", pair continue i += 1 pair = doc.createElement('pair') pair.setAttribute('id', str(i)) pair.setAttribute('value', str(entailment).upper()) corpus.appendChild(pair) t = doc.createElement('t') pair.appendChild(t) t_text = doc.createTextNode(text) t.appendChild(t_text) h = doc.createElement('h') pair.appendChild(h) h_text = doc.createTextNode(hypothesis) h.appendChild(h_text) f = open(path, 'w') doc.writexml(f, addindent=' ', newl='\n')
def build(self): doc = Document() root = doc.createElement('content') root.setAttribute('count', str(len(self.questionList))) doc.appendChild(root) index = 0 for q in self.questionList: index += 1 qnode = doc.createElement(q.qtype) qnode.setAttribute('id', str(index)) que = doc.createElement('question') queText = doc.createTextNode(q.content) que.appendChild(queText) qnode.appendChild(que) ind = 0 for item in q.items: ind += 1 itemNode = doc.createElement('item') itemNode.setAttribute('id', str(ind)) itemNode.appendChild(doc.createTextNode(item)) qnode.appendChild(itemNode) root.appendChild(qnode) return doc.toprettyxml(indent=' ')
def positionToXml(self): doc = Document() xml_position_node = doc.createElement(WFConstants.TAG_NAME_POSITION) xml_name_node = doc.createElement(WFConstants.TAG_NAME_NAME) xml_name_node_content = doc.createTextNode(self.name) xml_name_node.appendChild(xml_name_node_content) xml_x_node = doc.createElement(WFConstants.TAG_NAME_X) xml_x_node_content = doc.createTextNode(self.x) xml_x_node.appendChild(xml_x_node_content) xml_y_node = doc.createElement(WFConstants.TAG_NAME_Y) xml_y_node_content = doc.createTextNode(self.y) xml_y_node.appendChild(xml_y_node_content) xml_width_node = doc.createElement(WFConstants.TAG_NAME_WIDTH) xml_width_node_content = doc.createTextNode(self.width) xml_width_node.appendChild(xml_width_node_content) xml_height_node = doc.createElement(WFConstants.TAG_NAME_HEIGHT) xml_height_node_content = doc.createTextNode(self.height) xml_height_node.appendChild(xml_height_node_content) xml_position_node.appendChild(xml_name_node) xml_position_node.appendChild(xml_x_node) xml_position_node.appendChild(xml_y_node) xml_position_node.appendChild(xml_width_node) xml_position_node.appendChild(xml_height_node) return xml_position_node
def post(self): global current_user form = cgi.FieldStorage() category_name = (form["category"].value).strip(" ") category_user = (form[category_name].value).strip(" ") uname = User(key_name=category_user) category = Category(key_name=category_name, parent=uname) allItems = db.query_descendants(category) doc = Document() # create category element cat = doc.createElement("CATEGORY") doc.appendChild(cat) # create name element name = doc.createElement("NAME") cat.appendChild(name) # create text node inside name n = doc.createTextNode(category_name) name.appendChild(n) for i in allItems: # create item element item = doc.createElement("ITEM") cat.appendChild(item) # create name element name = doc.createElement("NAME") item.appendChild(name) # create text node inside name n = doc.createTextNode(i.name) name.appendChild(n) self.response.out.write("%s" % doc.toprettyxml()) self.response.out.write("<br><br><div>Go back to the <a href=" "/" ">welcome page</a><div>")
def make_mobile_xml(Pchtml,MobileUrl): #Pchtml = "http://sina2.com.cn" #MobileUrl="http://html5.sina2.com.cn" #Create minidom document doc = Document() #Create the <urlset> element #urlset = doc.createElement("urlset") #doc.appendChild(urlset) #Create the <url> element url = doc.createElement("url") doc.appendChild(url) #Create <loc> element paragraph1 = doc.createElement("loc") url.appendChild(paragraph1) locurl = doc.createTextNode(Pchtml) #locurl = doc.createCDATASection(Pchtml) paragraph1.appendChild(locurl) #Create data element data = doc.createElement("data") url.appendChild(data) #Create display element display = doc.createElement("display") data.appendChild(display) #Create html5_url element html5_url = doc.createElement("html5_url") display.appendChild(html5_url) #Create mobile url mobile_url = doc.createTextNode(MobileUrl) #mobile_url = doc.createCDATASection(MobileUrl) html5_url.appendChild(mobile_url) #print f.write(doc.toprettyxml(indent=" ",encoding="UTF-8"))
def wrapInMinimalHeader(self, title, text): """ Wraps the text into a minimal header and returns it as string """ doc = Document() # create elements elMwiki = doc.createElement("mediawiki") elPage = doc.createElement("page") elTitle = doc.createElement("title") elRev = doc.createElement("revision") elText = doc.createElement("text") textstr = doc.createTextNode(text) titlestr = doc.createTextNode(title) doc.appendChild(elMwiki) elMwiki.setAttribute("xmlns", "http://www.mediawiki.org/xml/export-0.4/") elMwiki.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance") elMwiki.setAttribute( "xsi:schemaLocation", "http://www.mediawiki.org/xml/export-0.4/ http://www.mediawiki.org/xml/export-0.4.xsd" ) elMwiki.setAttribute("version", "0.4") elMwiki.setAttribute("xml:lang", "de") elMwiki.appendChild(elPage) elPage.appendChild(elTitle) elPage.appendChild(elRev) elRev.appendChild(elText) elText.appendChild(textstr) elTitle.appendChild(titlestr) return doc.toxml() # don't prettify
def main(): _format, input, output = sys.argv[1:4] f = open(input) articles = json.loads(f.read()) fwrt = open(output, 'w') if _format == 'csv': wrt = csv.writer(fwrt) for url, subject in articles: wrt.writerow([url, subject]) elif _format == 'xml': doc = Document() e_articles = doc.createElement("articles") doc.appendChild(e_articles) for url, subject in articles: e_article = doc.createElement("article") e_article_name = doc.createElement("name") e_article_url = doc.createElement("url") e_article_name.appendChild(doc.createTextNode(subject)) e_article_url.appendChild(doc.createTextNode(url)) e_article.appendChild(e_article_name) e_article.appendChild(e_article_url) e_articles.appendChild(e_article) fwrt.write(doc.toprettyxml(indent=" ")) fwrt.close()
def createFeed(examples): doc = Document() feed = doc.createElementNS("http://www.w3.org/2005/Atom", "feed") feed.setAttribute("xmlns", "http://www.w3.org/2005/Atom") #ug, is this for real?? for example in examples: s = os.stat("../examples/" + example["example"]) example["modified"] = s.st_mtime examples.sort(key=lambda x:x["modified"]) for example in sorted(examples, key=lambda x:x["modified"], reverse=True): entry = doc.createElementNS("http://www.w3.org/2005/Atom", "entry") title = doc.createElementNS("http://www.w3.org/2005/Atom", "title") title.appendChild(doc.createTextNode(example["title"] or example["example"])) entry.appendChild(title) link = doc.createElementNS("http://www.w3.org/2005/Atom", "link") link.setAttribute("href", example["example"]) entry.appendChild(link) summary = doc.createElementNS("http://www.w3.org/2005/Atom", "summary") summary.appendChild(doc.createTextNode(example["shortdesc"] or example["example"])) entry.appendChild(summary) updated = doc.createElementNS("http://www.w3.org/2005/Atom", "updated") updated.appendChild(doc.createTextNode( time.strftime("%Y-%m-%dT%I:%M:%SZ",time.gmtime(example["modified"])))) entry.appendChild(updated) feed.appendChild(entry) doc.appendChild(feed) return doc
def put_stationdata(client, cfg, recv_mq): data = get_data(client, "stnstatus", cfg) if data is None: # logging.DEBUG("data=None") return doc = Document() env = doc.createElement("env:Envelope") doc.appendChild(env) env.setAttribute("xmlns:env", "http://pdps.in.audi.vwg/legacy_schema/20.7.3/envelope") herder = doc.createElement("Herder") doc.appendChild(herder) sender = doc.createElement("Sender") herder.appendChild(sender) location = doc.createElement("Location") sender.appendChild(location) sender_assembly_cycle = get_item(data, u"assembly_cycle") location.setAttribute("assembly_cycle", sender_assembly_cycle) location.setAttribute("assembly_line", "MES Battery Assembly Line") location.setAttribute("assembly_subline", "1") location.setAttribute("plant", "C4") location.setAttribute("plant_segment", "Battery") device = doc.createElement("Device") sender.appendChild(device) sender_hostname = get_item(data, u"hostname") device.setAttribute("hostname", sender_hostname) sender_manufacturer = get_item(data, u"manufacturer") device.setAttribute("manufacturer", sender_manufacturer) sender_type = get_item(data, u"type") device.setAttribute("type", sender_type) sender_opmode = get_item(data, u"opmode") device.setAttribute("opmode", sender_opmode) telegraminfo = doc.createElement("Telegraminfo") herder.appendChild(telegraminfo) sender_timestamp = get_item(data, u"opmode") telegraminfo.setAttribute("timestamp", sender_timestamp) sender_datatype = get_item(data, u"opmode") telegraminfo.setAttribute("datatype", sender_datatype) body = doc.createElement("Body") doc.appendChild(body) batterdata = doc.createElement("BatteryData") doc.appendChild(batterdata) cid = get_item(data, u"cid") batterdata.setAttribute("cid", cid) prt = get_item(data, u"teilnr.") batterdata.setAttribute("prt", prt) pt1 = get_item(data, u"gbt") batterdata.setAttribute("pt1", pt1) prc_sst = doc.createElement("PRC_SST") doc.appendChild(prc_sst) In = doc.createElement("Entry") jobnumber = get_item(data, u"in") In_info = doc.createTextNode(jobnumber) In.appendChild(In_info) prc_sst.appendChild(In) Out = doc.createElement("Leave") textdescription = get_item(data, u"out") Out_info = doc.createTextNode(textdescription) Out.appendChild(Out_info) prc_sst.appendChild(Out) Palletnumber = doc.createElement("palletnumber") palletnumber = get_item(data, u"palletnumber") Palletnumber_info = doc.createTextNode(palletnumber) Palletnumber.appendChild(Palletnumber_info) prc_sst.appendChild(Palletnumber) Palletcycletimescount = doc.createElement("palletcycletimescount") palletcycletimescount = get_item(data, u"palletcycletimesCount") Palletcycletimescount_info = doc.createTextNode(palletcycletimescount) Palletcycletimescount.appendChild(Palletcycletimescount_info) prc_sst.appendChild(Palletcycletimescount) Pallettype = doc.createElement("pallettype") pallettype = get_item(data, u"pallettype_m_or_n") Pallettype_info = doc.createTextNode(pallettype) Pallettype.appendChild(Pallettype_info) prc_sst.appendChild(Pallettype) Lastworkstation = doc.createElement("lastworkstation") lastworkstation = get_item(data, u"lastworkstation") Lastworkstation_info = doc.createTextNode(lastworkstation) Lastworkstation.appendChild(Lastworkstation_info) prc_sst.appendChild(Lastworkstation) Palletloaded = doc.createElement("palletloaded") palletloaded = get_item(data, u"palletloaded") Palletloaded_info = doc.createTextNode(palletloaded) Palletloaded.appendChild(Palletloaded_info) prc_sst.appendChild(Palletloaded) Palletworkok = doc.createElement("palletworkok") palletworkok = get_item(data, u"palletworkok") Palletworkok_info = doc.createTextNode(palletworkok) Palletworkok.appendChild(Palletworkok_info) prc_sst.appendChild(Palletworkok) Palletworknok = doc.createElement("palletworknok") palletworknok = get_item(data, u"palletworknok") Palletworknok_info = doc.createTextNode(palletworknok) Palletworknok.appendChild(Palletworknok_info) prc_sst.appendChild(Palletworknok) Palletscrapped = doc.createElement("palletscrapped") palletscrapped = get_item(data, u"palletscrapped") Palletscrapped_info = doc.createTextNode(palletscrapped) Palletscrapped.appendChild(Palletscrapped_info) prc_sst.appendChild(Palletscrapped) Palletworkposition = doc.createElement("palletworkposition") palletworkposition = get_item(data, u"palletworkposition") Palletworkposition_info = doc.createTextNode(palletworkposition) Palletworkposition.appendChild(Palletworkposition_info) prc_sst.appendChild(Palletworkposition) Repairstatus = doc.createElement("repairstatus") repairstatus = get_item(data, u"repairstatus") Repairstatus_info = doc.createTextNode(repairstatus) Repairstatus.appendChild(Repairstatus_info) prc_sst.appendChild(Repairstatus) Repairtimescount = doc.createElement("repairtimescount") repairtimescount = get_item(data, u"repairtimescount") Repairtimescount_info = doc.createTextNode(repairtimescount) Repairtimescount.appendChild(Repairtimescount_info) prc_sst.appendChild(Repairtimescount) Ilchecktimescount = doc.createElement("ilchecktimescount") ilchecktimescount = get_item(data, u"ilchecktimescount") Ilchecktimescount_info = doc.createTextNode(ilchecktimescount) Ilchecktimescount.appendChild(Ilchecktimescount_info) prc_sst.appendChild(Ilchecktimescount) Eolchecktimescount = doc.createElement("eolchecktimescount") eolchecktimescount = get_item(data, u"eolchecktimescount") Eolchecktimescount_info = doc.createTextNode(eolchecktimescount) Eolchecktimescount.appendChild(Eolchecktimescount_info) prc_sst.appendChild(Eolchecktimescount) Dateandtimeid = doc.createElement("dateandtimeid") dateandtimeid = get_item(data, u"dateandtimeid") Dateandtimeid_info = doc.createTextNode(dateandtimeid) Dateandtimeid.appendChild(Dateandtimeid_info) prc_sst.appendChild(Dateandtimeid) Batteryid = doc.createElement("batteryid") batteryid = get_item(data, u"opmode") Batteryid_info = doc.createTextNode(batteryid) Batteryid.appendChild(Batteryid_info) prc_sst.appendChild(Batteryid) Bzd_batterycase = doc.createElement("bzd_batterycase") bzd_batterycase = get_item(data, u"bzdBatteryCase") Bzd_batterycase_info = doc.createTextNode(bzd_batterycase) Bzd_batterycase.appendChild(Bzd_batterycase_info) prc_sst.appendChild(Bzd_batterycase) Bzd_batterypack = doc.createElement("bzd_batterypack") bzd_batterypack = get_item(data, u"bzdBatteryPack") Bzd_batterypack_info = doc.createTextNode(bzd_batterypack) Bzd_batterypack.appendChild(Bzd_batterypack_info) prc_sst.appendChild(Bzd_batterypack) Teilnr = doc.createElement("teilnr.") teilnr = get_item(data, u"teilnr.") Teilnr_info = doc.createTextNode(teilnr) Teilnr.appendChild(Teilnr_info) prc_sst.appendChild(Teilnr) Cid = doc.createElement("cid") cid = get_item(data, u"cid") Cid_info = doc.createTextNode(cid) Cid.appendChild(Cid_info) prc_sst.appendChild(Cid) Gbt = doc.createElement("gbt") gbt = get_item(data, u"gbt") Gbt_info = doc.createTextNode("dddd") Cid.appendChild(Gbt_info) prc_sst.appendChild(Cid) Gapfillermodule1 = doc.createElement("gapfillermodule1") gapfillermodule1 = get_item(data, u"gapfillermodule1") Gapfillermodule1_info = doc.createTextNode(gapfillermodule1) Gapfillermodule1.appendChild(Gapfillermodule1_info) prc_sst.appendChild(Gapfillermodule1) Gapfillermodule2 = doc.createElement("gapfillermodule2") gapfillermodule2 = get_item(data, u"gapfillermodule2") Gapfillermodule2_info = doc.createTextNode(gapfillermodule2) Gapfillermodule2.appendChild(Gapfillermodule2_info) prc_sst.appendChild(Gapfillermodule2) Gapfillermodule3 = doc.createElement("gapfillermodule3") gapfillermodule3 = get_item(data, u"gapfillermodule3") Gapfillermodule3_info = doc.createTextNode(gapfillermodule3) Gapfillermodule3.appendChild(Gapfillermodule3_info) prc_sst.appendChild(Gapfillermodule3) Gapfillermodule4 = doc.createElement("gapfillermodule4") gapfillermodule4 = get_item(data, u"gapfillermodule4") Gapfillermodule4_info = doc.createTextNode(gapfillermodule4) Gapfillermodule4.appendChild(Gapfillermodule4_info) prc_sst.appendChild(Gapfillermodule4) Gapfillermodule5 = doc.createElement("gapfillermodule5") gapfillermodule5 = get_item(data, u"gapfillermodule5") Gapfillermodule5_info = doc.createTextNode(gapfillermodule5) Gapfillermodule5.appendChild(Gapfillermodule5_info) prc_sst.appendChild(Gapfillermodule5) Gapfillermodule6 = doc.createElement("gapfillermodule6") gapfillermodule6 = get_item(data, u"gapfillermodule6") Gapfillermodule6_info = doc.createTextNode(gapfillermodule6) Gapfillermodule6.appendChild(Gapfillermodule6_info) prc_sst.appendChild(Gapfillermodule6) Gapfillermodule7 = doc.createElement("gapfillermodule7") gapfillermodule7 = get_item(data, u"gapfillermodule7") Gapfillermodule7_info = doc.createTextNode(gapfillermodule7) Gapfillermodule7.appendChild(Gapfillermodule7_info) prc_sst.appendChild(Gapfillermodule7) Gapfillermodule8 = doc.createElement("gapfillermodule8") gapfillermodule8 = get_item(data, u"gapfillermodule8") Gapfillermodule8_info = doc.createTextNode(gapfillermodule8) Gapfillermodule8.appendChild(Gapfillermodule8_info) prc_sst.appendChild(Gapfillermodule8) Gapfillermodule9 = doc.createElement("gapfillermodule9") gapfillermodule9 = get_item(data, u"gapfillermodule9") Gapfillermodule9_info = doc.createTextNode(gapfillermodule9) Gapfillermodule9.appendChild(Gapfillermodule9_info) prc_sst.appendChild(Gapfillermodule9) Gapfillermodule10 = doc.createElement("gapfillermodule10") gapfillermodule10 = get_item(data, u"gapfillermodule10") Gapfillermodule10_info = doc.createTextNode(gapfillermodule10) Gapfillermodule10.appendChild(Gapfillermodule10_info) prc_sst.appendChild(Gapfillermodule10) Gapfillermodule11 = doc.createElement("gapfillermodule11") gapfillermodule11 = get_item(data, u"gapfillermodule11") Gapfillermodule11_info = doc.createTextNode(gapfillermodule11) Gapfillermodule11.appendChild(Gapfillermodule11_info) prc_sst.appendChild(Gapfillermodule11) Gapfillermodule12 = doc.createElement("gapfillermodule12") gapfillermodule12 = get_item(data, u"gapfillermodule12") Gapfillermodule12_info = doc.createTextNode(gapfillermodule12) Gapfillermodule12.appendChild(Gapfillermodule12_info) prc_sst.appendChild(Gapfillermodule12) Gapfillermodule13 = doc.createElement("gapfillermodule13") gapfillermodule13 = get_item(data, u"gapfillermodule13") Gapfillermodule13_info = doc.createTextNode(gapfillermodule13) Gapfillermodule13.appendChild(Gapfillermodule13_info) prc_sst.appendChild(Gapfillermodule13) Gapfillermodule14 = doc.createElement("gapfillermodule14") gapfillermodule14 = get_item(data, u"gapfillermodule14") Gapfillermodule14_info = doc.createTextNode(gapfillermodule14) Gapfillermodule14.appendChild(Gapfillermodule14_info) prc_sst.appendChild(Gapfillermodule14) Gapfillermodule15 = doc.createElement("gapfillermodule15") gapfillermodule15 = get_item(data, u"gapfillermodule15") Gapfillermodule15_info = doc.createTextNode(gapfillermodule15) Gapfillermodule15.appendChild(Gapfillermodule15_info) prc_sst.appendChild(Gapfillermodule15) Recipeversion = doc.createElement("recipeversion") recipeversion = get_item(data, u"recipeversion") Recipeversion_info = doc.createTextNode(recipeversion) Recipeversion.appendChild(Recipeversion_info) prc_sst.appendChild(Recipeversion) Bomversion = doc.createElement("bomversion") bomversion = get_item(data, u"bomversion") Bomversion_info = doc.createTextNode(bomversion) Bomversion.appendChild(Bomversion_info) prc_sst.appendChild(Bomversion) Work_ok = doc.createElement("work_ok") work_ok = get_item(data, u"work_ok") Work_ok_info = doc.createTextNode(work_ok) Work_ok.appendChild(Work_ok_info) prc_sst.appendChild(Work_ok) Work_nok = doc.createElement("work_nok") work_nok = get_item(data, u"work_nok") Work_nok_info = doc.createTextNode(work_nok) Work_nok.appendChild(Work_nok_info) prc_sst.appendChild(Work_nok) Workerdecisionok = doc.createElement("workerdecisionok") workerdecisionok = get_item(data, u"workerdecisionok") Workerdecisionok_info = doc.createTextNode(workerdecisionok) Workerdecisionok.appendChild(Workerdecisionok_info) prc_sst.appendChild(Workerdecisionok) Workerdecisionnok = doc.createElement("workerdecisionnok") workerdecisionnok = get_item(data, u"workerdecisionnok") Workerdecisionnok_info = doc.createTextNode(workerdecisionnok) Workerdecisionnok.appendChild(Workerdecisionnok_info) prc_sst.appendChild(Workerdecisionnok) xml = open("reserve.xml", "w") doc.writexml(xml, indent='\t', newl='\n', addindent='\t', encoding='gbk') xml.close() with open("reserve.xml", "rt") as xml: line = xml.read() print(line) connect(recv_mq) queue.put(line) # logging.info(line) queue.close() print("3")
def convertimgset(img_set="train"): imgdir=rootdir+"/WIDER_"+img_set+"/images" gtfilepath=rootdir+"/wider_face_split/wider_face_"+img_set+"_bbx_gt.txt" imagesdir=rootdir+"/images" vocannotationdir=rootdir+"/Annotations" labelsdir=rootdir+"/labels" if not os.path.exists(imagesdir): os.mkdir(imagesdir) if convet2yoloformat: if not os.path.exists(labelsdir): os.mkdir(labelsdir) if convert2vocformat: if not os.path.exists(vocannotationdir): os.mkdir(vocannotationdir) index=0 with open(gtfilepath,'r') as gtfile: while(True ):#and len(faces)<10 filename=gtfile.readline()[:-1] if(filename==""): break; sys.stdout.write("\r"+str(index)+":"+filename+"\t\t\t") sys.stdout.flush() imgpath=imgdir+"/"+filename img=cv2.imread(imgpath) if not img.data: break; imgheight=img.shape[0] imgwidth=img.shape[1] maxl=max(imgheight,imgwidth) paddingleft=(maxl-imgwidth)>>1 paddingright=(maxl-imgwidth)>>1 paddingbottom=(maxl-imgheight)>>1 paddingtop=(maxl-imgheight)>>1 saveimg=cv2.copyMakeBorder(img,paddingtop,paddingbottom,paddingleft,paddingright,cv2.BORDER_CONSTANT,value=0) showimg=saveimg.copy() numbbox=int(gtfile.readline()) bboxes=[] for i in range(numbbox): line=gtfile.readline() line=line.split() line=line[0:4] if(int(line[3])<=0 or int(line[2])<=0): continue x=int(line[0])+paddingleft y=int(line[1])+paddingtop width=int(line[2]) height=int(line[3]) bbox=(x,y,width,height) x2=x+width y2=y+height #face=img[x:x2,y:y2] if width>=minsize2select and height>=minsize2select: bboxes.append(bbox) cv2.rectangle(showimg,(x,y),(x2,y2),(0,255,0)) #maxl=max(width,height) #x3=(int)(x+(width-maxl)*0.5) #y3=(int)(y+(height-maxl)*0.5) #x4=(int)(x3+maxl) #y4=(int)(y3+maxl) #cv2.rectangle(img,(x3,y3),(x4,y4),(255,0,0)) else: cv2.rectangle(showimg,(x,y),(x2,y2),(0,0,255)) filename=filename.replace("/","_") if len(bboxes)==0: print "warrning: no face" continue cv2.imwrite(imagesdir+"/"+filename,saveimg) if convet2yoloformat: height=saveimg.shape[0] width=saveimg.shape[1] txtpath=labelsdir+"/"+filename txtpath=txtpath[:-3]+"txt" ftxt=open(txtpath,'w') for i in range(len(bboxes)): bbox=bboxes[i] xcenter=(bbox[0]+bbox[2]*0.5)/width ycenter=(bbox[1]+bbox[3]*0.5)/height wr=bbox[2]*1.0/width hr=bbox[3]*1.0/height txtline="0 "+str(xcenter)+" "+str(ycenter)+" "+str(wr)+" "+str(hr)+"\n" ftxt.write(txtline) ftxt.close() if convert2vocformat: xmlpath=vocannotationdir+"/"+filename xmlpath=xmlpath[:-3]+"xml" doc = Document() annotation = doc.createElement('annotation') doc.appendChild(annotation) folder = doc.createElement('folder') folder_name = doc.createTextNode('widerface') folder.appendChild(folder_name) annotation.appendChild(folder) filenamenode = doc.createElement('filename') filename_name = doc.createTextNode(filename) filenamenode.appendChild(filename_name) annotation.appendChild(filenamenode) source = doc.createElement('source') annotation.appendChild(source) database = doc.createElement('database') database.appendChild(doc.createTextNode('wider face Database')) source.appendChild(database) annotation_s = doc.createElement('annotation') annotation_s.appendChild(doc.createTextNode('PASCAL VOC2007')) source.appendChild(annotation_s) image = doc.createElement('image') image.appendChild(doc.createTextNode('flickr')) source.appendChild(image) flickrid = doc.createElement('flickrid') flickrid.appendChild(doc.createTextNode('-1')) source.appendChild(flickrid) owner = doc.createElement('owner') annotation.appendChild(owner) flickrid_o = doc.createElement('flickrid') flickrid_o.appendChild(doc.createTextNode('yanyu')) owner.appendChild(flickrid_o) name_o = doc.createElement('name') name_o.appendChild(doc.createTextNode('yanyu')) owner.appendChild(name_o) size = doc.createElement('size') annotation.appendChild(size) width = doc.createElement('width') width.appendChild(doc.createTextNode(str(saveimg.shape[1]))) height = doc.createElement('height') height.appendChild(doc.createTextNode(str(saveimg.shape[0]))) depth = doc.createElement('depth') depth.appendChild(doc.createTextNode(str(saveimg.shape[2]))) size.appendChild(width) size.appendChild(height) size.appendChild(depth) segmented = doc.createElement('segmented') segmented.appendChild(doc.createTextNode('0')) annotation.appendChild(segmented) for i in range(len(bboxes)): bbox=bboxes[i] objects = doc.createElement('object') annotation.appendChild(objects) object_name = doc.createElement('name') object_name.appendChild(doc.createTextNode('face')) objects.appendChild(object_name) pose = doc.createElement('pose') pose.appendChild(doc.createTextNode('Unspecified')) objects.appendChild(pose) truncated = doc.createElement('truncated') truncated.appendChild(doc.createTextNode('1')) objects.appendChild(truncated) difficult = doc.createElement('difficult') difficult.appendChild(doc.createTextNode('0')) objects.appendChild(difficult) bndbox = doc.createElement('bndbox') objects.appendChild(bndbox) xmin = doc.createElement('xmin') xmin.appendChild(doc.createTextNode(str(bbox[0]))) bndbox.appendChild(xmin) ymin = doc.createElement('ymin') ymin.appendChild(doc.createTextNode(str(bbox[1]))) bndbox.appendChild(ymin) xmax = doc.createElement('xmax') xmax.appendChild(doc.createTextNode(str(bbox[0]+bbox[2]))) bndbox.appendChild(xmax) ymax = doc.createElement('ymax') ymax.appendChild(doc.createTextNode(str(bbox[1]+bbox[3]))) bndbox.appendChild(ymax) f=open(xmlpath,"w") f.write(doc.toprettyxml(indent = '')) f.close() #cv2.imshow("img",showimg) #cv2.waitKey() index=index+1
def visualize(y, ori, name, test_folder, mode=1, text=None): if not os.path.exists(test_folder): os.mkdir(test_folder) # create svg document #mode = 1 if y is None: mode = 0 width = float(ori["width"]) height = float(ori["height"]) doc = Document() svg = doc.createElement('svg') svg.setAttribute('xmlns', "http://www.w3.org/2000/svg") svg.setAttribute('width', str(width)) svg.setAttribute('height', str(height)) svg.setAttribute('xmlns:xlink', "http://www.w3.org/1999/xlink") doc.appendChild(svg) style = doc.createElement('style') svg.appendChild(style) style.setAttribute('xmlns', "http://www.w3.org/1999/xhtml") style.setAttribute('type', "text/css") style_text = doc.createTextNode(''' .links line { stroke: #999; stroke-opacity: 0.6; } .nodes circle { stroke: #fff; stroke-width: 1.5px; }''') #create node style.appendChild(style_text) background = doc.createElement('rect') svg.appendChild(background) background.setAttribute('width', '100%') background.setAttribute('height', '100%') background.setAttribute('style', "fill:rgb(255,255,255);") if not text is None: for i in range(len(text)): g_text = doc.createElement('g') g_text.setAttribute('class', "text") svg.appendChild(g_text) real_text = doc.createElement('text') real_text.setAttribute('x', str(50)) real_text.setAttribute('y', str(20 + i * 15)) real_content = doc.createTextNode(text[i]) real_text.appendChild(real_content) g_text.appendChild(real_text) g_nodes = doc.createElement('g') g_nodes.setAttribute('class', "nodes") def getx(id): if mode == 1: x = y[id][0] * float(width) else: x = y[id][0] if x < 0: x = 0 if x > width: x = width return x def gety(id): if mode == 1: y_value = y[id][1] * float(height) else: y_value = y[id][1] if y_value < 0: y_value = 0 if y_value > height: y_value = height return y_value node_mapping = {} for node in ori['nodelist']: id = node[0] if mode == 0: cx = node[2] cy = node[3] else: cx = getx(id) cy = gety(id) if id in node_mapping: print("node mapping error" + str(id)) else: node_mapping[id] = [cx, cy] node_group = node[1] r = node[4] fill = node[5] circle = doc.createElement('circle') circle.setAttribute('stroke', "#fff") circle.setAttribute('stroke-width', "1.5px") circle.setAttribute('r', str(r)) circle.setAttribute('fill', fill) circle.setAttribute('node_id', str(id)) circle.setAttribute('node_group', str(node_group)) circle.setAttribute('cx', str(cx)) circle.setAttribute('cy', str(cy)) title = doc.createElement('title') title_text = doc.createTextNode(str(id)) title.appendChild(title_text) circle.appendChild(title) g_nodes.appendChild(circle) g_links = doc.createElement('g') g_links.setAttribute('class', "links") for line in ori['linelist']: node1 = line[0] node2 = line[1] if not mode == 0: x1 = getx(node1) y1 = gety(node1) x2 = getx(node2) y2 = gety(node2) else: if node1 in node_mapping: if node2 in node_mapping: x1 = node_mapping[node1][0] y1 = node_mapping[node1][1] x2 = node_mapping[node2][0] y2 = node_mapping[node2][1] else: print("link mapping error : " + str(node2)) else: print("link mapping error : " + str(node1)) link_ids = str(node1) + "_" + str(node2) line = doc.createElement('line') line.setAttribute('stroke', "#999") line.setAttribute("stroke-opacity", "0.6") line.setAttribute('stroke-width', "2") line.setAttribute('link_ids', link_ids) line.setAttribute('x1', str(x1)) line.setAttribute('y1', str(y1)) line.setAttribute('x2', str(x2)) line.setAttribute('y2', str(y2)) g_links.appendChild(line) svg.appendChild(g_links) svg.appendChild(g_nodes) #write to file f = open(test_folder + name + '.xml', 'w') doc.writexml(f, indent='\t', newl='\n', addindent='\t', encoding='utf-8') f.close() url = test_folder + name + '.xml' write_to = test_folder + name + '.png' cairosvg.svg2png(url=url, write_to=write_to)
def save_to_xml(save_path, im_height, im_width, objects_axis, label_name): im_depth = 0 object_num = len(objects_axis) doc = Document() annotation = doc.createElement('annotation') doc.appendChild(annotation) folder = doc.createElement('folder') folder_name = doc.createTextNode('VOC2007') folder.appendChild(folder_name) annotation.appendChild(folder) filename = doc.createElement('filename') filename_name = doc.createTextNode('000024.jpg') filename.appendChild(filename_name) annotation.appendChild(filename) source = doc.createElement('source') annotation.appendChild(source) database = doc.createElement('database') database.appendChild(doc.createTextNode('The VOC2007 Database')) source.appendChild(database) annotation_s = doc.createElement('annotation') annotation_s.appendChild(doc.createTextNode('PASCAL VOC2007')) source.appendChild(annotation_s) image = doc.createElement('image') image.appendChild(doc.createTextNode('flickr')) source.appendChild(image) flickrid = doc.createElement('flickrid') flickrid.appendChild(doc.createTextNode('322409915')) source.appendChild(flickrid) owner = doc.createElement('owner') annotation.appendChild(owner) flickrid_o = doc.createElement('flickrid') flickrid_o.appendChild(doc.createTextNode('knautia')) owner.appendChild(flickrid_o) name_o = doc.createElement('name') name_o.appendChild(doc.createTextNode('yang')) owner.appendChild(name_o) size = doc.createElement('size') annotation.appendChild(size) width = doc.createElement('width') width.appendChild(doc.createTextNode(str(im_width))) height = doc.createElement('height') height.appendChild(doc.createTextNode(str(im_height))) depth = doc.createElement('depth') depth.appendChild(doc.createTextNode(str(im_depth))) size.appendChild(width) size.appendChild(height) size.appendChild(depth) segmented = doc.createElement('segmented') segmented.appendChild(doc.createTextNode('0')) annotation.appendChild(segmented) for i in range(object_num): objects = doc.createElement('object') annotation.appendChild(objects) object_name = doc.createElement('name') object_name.appendChild(doc.createTextNode(label_name[int(objects_axis[i][-1])])) objects.appendChild(object_name) pose = doc.createElement('pose') pose.appendChild(doc.createTextNode('Unspecified')) objects.appendChild(pose) truncated = doc.createElement('truncated') truncated.appendChild(doc.createTextNode('1')) objects.appendChild(truncated) difficult = doc.createElement('difficult') difficult.appendChild(doc.createTextNode('0')) objects.appendChild(difficult) bndbox = doc.createElement('bndbox') objects.appendChild(bndbox) x0 = doc.createElement('x0') x0.appendChild(doc.createTextNode(str((objects_axis[i][0])))) bndbox.appendChild(x0) y0 = doc.createElement('y0') y0.appendChild(doc.createTextNode(str((objects_axis[i][1])))) bndbox.appendChild(y0) x1 = doc.createElement('x1') x1.appendChild(doc.createTextNode(str((objects_axis[i][2])))) bndbox.appendChild(x1) y1 = doc.createElement('y1') y1.appendChild(doc.createTextNode(str((objects_axis[i][3])))) bndbox.appendChild(y1) x2 = doc.createElement('x2') x2.appendChild(doc.createTextNode(str((objects_axis[i][4])))) bndbox.appendChild(x2) y2 = doc.createElement('y2') y2.appendChild(doc.createTextNode(str((objects_axis[i][5])))) bndbox.appendChild(y2) x3 = doc.createElement('x3') x3.appendChild(doc.createTextNode(str((objects_axis[i][6])))) bndbox.appendChild(x3) y3 = doc.createElement('y3') y3.appendChild(doc.createTextNode(str((objects_axis[i][7])))) bndbox.appendChild(y3) f = open(save_path,'w') f.write(doc.toprettyxml(indent = '')) f.close()
class XMLReportGenerator(ReportGenerator): """ This class generates a report with the method printToFile(fileName) which contains the information of all the vulnerabilities notified to this object through the method logVulnerability(vulnerabilityTypeName,level,url,parameter,info). The format of the file is XML and it has the following structure: <report type="security"> <generatedBy id="Wapiti 2.3.0"/> <vulnerabilityTypeList> <vulnerabilityType name="SQL Injection"> <vulnerabilityTypeList> <vulnerabilityType name="SQL Injection"> <vulnerabilityList> <vulnerability level="3"> <url>http://www.a.com</url> <parameters>id=23</parameters> <info>SQL Injection</info> </vulnerability> </vulnerabilityList> </vulnerablityType> </vulnerabilityTypeList> </report> """ __xmlDoc = None __infos = {} __flawTypes = {} __vulns = {} __anomalies = {} __infos = {} def __init__(self): self.__xmlDoc = Document() def setReportInfo(self, target, scope=None, date_string="", version=""): self.__infos["target"] = target self.__infos["date"] = date_string self.__infos["version"] = version if scope: self.__infos["scope"] = scope # Vulnerabilities def addVulnerabilityType(self, name, description="", solution="", references={}): if name not in self.__flawTypes: self.__flawTypes[name] = {'desc': description, 'sol': solution, 'ref': references} if name not in self.__vulns: self.__vulns[name] = [] def logVulnerability(self, category=None, level=0, request=None, parameter="", info=""): """ Store the information about the vulnerability to be printed later. The method printToFile(fileName) can be used to save in a file the vulnerabilities notified through the current method. """ vuln_dict = {"method": request.method, "path": request.file_path, "info": info, "level": level, "parameter": parameter, "http_request": request.http_repr, "curl_command": request.curl_repr, } if category not in self.__vulns: self.__vulns[category] = [] self.__vulns[category].append(vuln_dict) # Anomalies def addAnomalyType(self, name, description="", solution="", references={}): if name not in self.__flawTypes: self.__flawTypes[name] = {'desc': description, 'sol': solution, 'ref': references} if name not in self.__anomalies: self.__anomalies[name] = [] def logAnomaly(self, category=None, level=0, request=None, parameter="", info=""): """ Store the information about the vulnerability to be printed later. The method printToFile(fileName) can be used to save in a file the vulnerabilities notified through the current method. """ anom_dict = {"method": request.method, "path": request.file_path, "info": info, "level": level, "parameter": parameter, "http_request": request.http_repr, "curl_command": request.curl_repr, } if category not in self.__anomalies: self.__anomalies[category] = [] self.__anomalies[category].append(anom_dict) def generateReport(self, fileName): """ Create a xml file with a report of the vulnerabilities which have been logged with the method logVulnerability(vulnerabilityTypeName,level,url,parameter,info) """ report = self.__xmlDoc.createElement("report") report.setAttribute("type", "security") self.__xmlDoc.appendChild(report) # Add report infos report_infos = self.__xmlDoc.createElement("report_infos") generatorName = self.__xmlDoc.createElement("info") generatorName.setAttribute("name", "generatorName") generatorName.appendChild(self.__xmlDoc.createTextNode("wapiti")) report_infos.appendChild(generatorName) generatorVersion = self.__xmlDoc.createElement("info") generatorVersion.setAttribute("name", "generatorVersion") generatorVersion.appendChild(self.__xmlDoc.createTextNode(self.__infos["version"])) report_infos.appendChild(generatorVersion) scope = self.__xmlDoc.createElement("info") scope.setAttribute("name", "scope") scope.appendChild(self.__xmlDoc.createTextNode(self.__infos["scope"])) report_infos.appendChild(scope) dateOfScan = self.__xmlDoc.createElement("info") dateOfScan.setAttribute("name", "dateOfScan") dateOfScan.appendChild(self.__xmlDoc.createTextNode(self.__infos["date"])) report_infos.appendChild(dateOfScan) report.appendChild(report_infos) vulnerabilities = self.__xmlDoc.createElement("vulnerabilities") anomalies = self.__xmlDoc.createElement("anomalies") # Loop on each flaw classification for flawType in self.__flawTypes: container = None classification = "" flaw_dict = {} if flawType in self.__vulns: container = vulnerabilities classification = "vulnerability" flaw_dict = self.__vulns elif flawType in self.__anomalies: container = anomalies classification = "anomaly" flaw_dict = self.__anomalies # Child nodes with a description of the flaw type flawTypeNode = self.__xmlDoc.createElement(classification) flawTypeNode.setAttribute("name", flawType) flawTypeDesc = self.__xmlDoc.createElement("description") flawTypeDesc.appendChild(self.__xmlDoc.createCDATASection(self.__flawTypes[flawType]['desc'])) flawTypeNode.appendChild(flawTypeDesc) flawTypeSolution = self.__xmlDoc.createElement("solution") flawTypeSolution.appendChild(self.__xmlDoc.createCDATASection(self.__flawTypes[flawType]['sol'])) flawTypeNode.appendChild(flawTypeSolution) flawTypeReferences = self.__xmlDoc.createElement("references") for ref in self.__flawTypes[flawType]['ref']: referenceNode = self.__xmlDoc.createElement("reference") titleNode = self.__xmlDoc.createElement("title") urlNode = self.__xmlDoc.createElement("url") titleNode.appendChild(self.__xmlDoc.createTextNode(ref)) url = self.__flawTypes[flawType]['ref'][ref] urlNode.appendChild(self.__xmlDoc.createTextNode(url)) referenceNode.appendChild(titleNode) referenceNode.appendChild(urlNode) flawTypeReferences.appendChild(referenceNode) flawTypeNode.appendChild(flawTypeReferences) # And child nodes with each flaw of the current type entriesNode = self.__xmlDoc.createElement("entries") for flaw in flaw_dict[flawType]: entryNode = self.__xmlDoc.createElement("entry") methodNode = self.__xmlDoc.createElement("method") methodNode.appendChild(self.__xmlDoc.createTextNode(flaw["method"])) entryNode.appendChild(methodNode) pathNode = self.__xmlDoc.createElement("path") pathNode.appendChild(self.__xmlDoc.createTextNode(flaw["path"])) entryNode.appendChild(pathNode) levelNode = self.__xmlDoc.createElement("level") levelNode.appendChild(self.__xmlDoc.createTextNode(str(flaw["level"]))) entryNode.appendChild(levelNode) parameterNode = self.__xmlDoc.createElement("parameter") parameterNode.appendChild(self.__xmlDoc.createTextNode(flaw["parameter"])) entryNode.appendChild(parameterNode) infoNode = self.__xmlDoc.createElement("info") infoNode.appendChild(self.__xmlDoc.createTextNode(flaw["info"])) entryNode.appendChild(infoNode) httpRequestNode = self.__xmlDoc.createElement("http_request") httpRequestNode.appendChild(self.__xmlDoc.createCDATASection(flaw["http_request"])) entryNode.appendChild(httpRequestNode) curlCommandNode = self.__xmlDoc.createElement("curl_command") curlCommandNode.appendChild(self.__xmlDoc.createCDATASection(flaw["curl_command"])) entryNode.appendChild(curlCommandNode) entriesNode.appendChild(entryNode) flawTypeNode.appendChild(entriesNode) container.appendChild(flawTypeNode) report.appendChild(vulnerabilities) report.appendChild(anomalies) f = open(fileName, "w") try: f.write(self.__xmlDoc.toprettyxml(indent=" ", encoding="UTF-8")) finally: f.close()
def writeXml(tmp, imgname, w, h, objs, wxml): doc = Document() #owner annotation = doc.createElement('annotation') doc.appendChild(annotation) #owner folder = doc.createElement('folder') annotation.appendChild(folder) foldename = os.path.dirname(imgname).split("/")[-1] folder_txt = doc.createTextNode(foldename) folder.appendChild(folder_txt) filename = doc.createElement('filename') annotation.appendChild(filename) imgInfor = os.path.basename(imgname).split(".") filename_txt = doc.createTextNode(imgInfor[0]) filename.appendChild(filename_txt) pathname = doc.createElement('path') annotation.appendChild(pathname) pathname_txt = doc.createTextNode(imgname) pathname.appendChild(pathname_txt) #ones# source = doc.createElement('source') annotation.appendChild(source) database = doc.createElement('database') source.appendChild(database) database_txt = doc.createTextNode("VOC2007 Database") database.appendChild(database_txt) # annotation_new = doc.createElement('annotation') # source.appendChild(annotation_new) # annotation_new_txt = doc.createTextNode("PASCAL VOC2007") # annotation_new.appendChild(annotation_new_txt) image = doc.createElement('image') source.appendChild(image) image_txt = doc.createTextNode(os.path.basename(imgname).split(".")[0]) image.appendChild(image_txt) #onee# #twos# size = doc.createElement('size') annotation.appendChild(size) width = doc.createElement('width') size.appendChild(width) width_txt = doc.createTextNode(str(w)) width.appendChild(width_txt) height = doc.createElement('height') size.appendChild(height) height_txt = doc.createTextNode(str(h)) height.appendChild(height_txt) depth = doc.createElement('depth') size.appendChild(depth) depth_txt = doc.createTextNode("3") depth.appendChild(depth_txt) #twoe# segmented = doc.createElement('segmented') annotation.appendChild(segmented) segmented_txt = doc.createTextNode("0") segmented.appendChild(segmented_txt) size = [w, h] for obj in objs: #threes# object_new = doc.createElement("object") annotation.appendChild(object_new) name = doc.createElement('name') object_new.appendChild(name) name_txt = doc.createTextNode(obj[0]) name.appendChild(name_txt) pose = doc.createElement('pose') object_new.appendChild(pose) pose_txt = doc.createTextNode("Unspecified") pose.appendChild(pose_txt) truncated = doc.createElement('truncated') object_new.appendChild(truncated) truncated_txt = doc.createTextNode("0") truncated.appendChild(truncated_txt) difficult = doc.createElement( 'Difficult' ) # difficult = doc.createElement('difficult') in VOC2007 object_new.appendChild(difficult) difficult_txt = doc.createTextNode("0") difficult.appendChild(difficult_txt) #threes-1# bndbox = doc.createElement('bndbox') object_new.appendChild(bndbox) box = convert(size, float(obj[1]), float(obj[2]), float(obj[3]), float(obj[4])) xmin = doc.createElement('xmin') bndbox.appendChild(xmin) xmin_txt = doc.createTextNode(str(box[0])) xmin.appendChild(xmin_txt) ymin = doc.createElement('ymin') bndbox.appendChild(ymin) ymin_txt = doc.createTextNode(str(box[1])) ymin.appendChild(ymin_txt) xmax = doc.createElement('xmax') bndbox.appendChild(xmax) xmax_txt = doc.createTextNode(str(box[2])) xmax.appendChild(xmax_txt) ymax = doc.createElement('ymax') bndbox.appendChild(ymax) ymax_txt = doc.createTextNode(str(box[3])) ymax.appendChild(ymax_txt) #threee-1# #threee# tempfile = tmp + "/" + "temp.xml" with open(tempfile, "w") as f: # print(doc.toprettyxml()) f.write(doc.toprettyxml(indent='\t')) rewrite = open(tempfile, "r") lines = rewrite.read().split('\n') newlines = lines[ 1:len(lines) - 1] # ['<?xml version="1.0" ?>', '<annotation>', '</annotation>', ''] fw = open(wxml, "w") for i in range(0, len(newlines)): fw.write(newlines[i] + '\n') fw.close() rewrite.close() os.remove(tempfile) return
def make_v0(apps, apks, repodir, repodict, requestsdict, fdroid_signing_key_fingerprints): """ aka index.jar aka index.xml """ doc = Document() def addElement(name, value, doc, parent): el = doc.createElement(name) el.appendChild(doc.createTextNode(value)) parent.appendChild(el) def addElementNonEmpty(name, value, doc, parent): if not value: return addElement(name, value, doc, parent) def addElementIfInApk(name, apk, key, doc, parent): if key not in apk: return value = str(apk[key]) addElement(name, value, doc, parent) def addElementCDATA(name, value, doc, parent): el = doc.createElement(name) el.appendChild(doc.createCDATASection(value)) parent.appendChild(el) def addElementCheckLocalized(name, app, key, doc, parent, default=''): '''Fill in field from metadata or localized block For name/summary/description, they can come only from the app source, or from a dir in fdroiddata. They can be entirely missing from the metadata file if there is localized versions. This will fetch those from the localized version if its not available in the metadata file. ''' el = doc.createElement(name) value = app.get(key) lkey = key[:1].lower() + key[1:] localized = app.get('localized') if not value and localized: for lang in ['en-US'] + [x for x in localized.keys()]: if not lang.startswith('en'): continue if lang in localized: value = localized[lang].get(lkey) if value: break if not value and localized and len(localized) > 1: lang = list(localized.keys())[0] value = localized[lang].get(lkey) if not value: value = default el.appendChild(doc.createTextNode(value)) parent.appendChild(el) root = doc.createElement("fdroid") doc.appendChild(root) repoel = doc.createElement("repo") repoel.setAttribute("name", repodict['name']) if 'maxage' in repodict: repoel.setAttribute("maxage", str(repodict['maxage'])) repoel.setAttribute("icon", os.path.basename(repodict['icon'])) repoel.setAttribute("url", repodict['address']) addElement('description', repodict['description'], doc, repoel) for mirror in repodict.get('mirrors', []): addElement('mirror', mirror, doc, repoel) repoel.setAttribute("version", str(repodict['version'])) repoel.setAttribute("timestamp", '%d' % repodict['timestamp'].timestamp()) pubkey, repo_pubkey_fingerprint = extract_pubkey() repoel.setAttribute("pubkey", pubkey.decode('utf-8')) root.appendChild(repoel) for command in ('install', 'uninstall'): for packageName in requestsdict[command]: element = doc.createElement(command) root.appendChild(element) element.setAttribute('packageName', packageName) for appid, appdict in apps.items(): app = metadata.App(appdict) if app.Disabled is not None: continue # Get a list of the apks for this app... apklist = [] apksbyversion = collections.defaultdict(lambda: []) for apk in apks: if apk.get('versionCode') and apk.get('packageName') == appid: apksbyversion[apk['versionCode']].append(apk) for versionCode, apksforver in apksbyversion.items(): fdroidsig = fdroid_signing_key_fingerprints.get(appid, {}).get('signer') fdroid_signed_apk = None name_match_apk = None for x in apksforver: if fdroidsig and x.get('signer', None) == fdroidsig: fdroid_signed_apk = x if common.apk_release_filename.match(x.get('apkName', '')): name_match_apk = x # choose which of the available versions is most # suiteable for index v0 if fdroid_signed_apk: apklist.append(fdroid_signed_apk) elif name_match_apk: apklist.append(name_match_apk) else: apklist.append(apksforver[0]) if len(apklist) == 0: continue apel = doc.createElement("application") apel.setAttribute("id", app.id) root.appendChild(apel) addElement('id', app.id, doc, apel) if app.added: addElement('added', app.added.strftime('%Y-%m-%d'), doc, apel) if app.lastUpdated: addElement('lastupdated', app.lastUpdated.strftime('%Y-%m-%d'), doc, apel) addElementCheckLocalized('name', app, 'Name', doc, apel) addElementCheckLocalized('summary', app, 'Summary', doc, apel) if app.icon: addElement('icon', app.icon, doc, apel) addElementCheckLocalized('desc', app, 'Description', doc, apel, '<p>No description available</p>') addElement('license', app.License, doc, apel) if app.Categories: addElement('categories', ','.join(app.Categories), doc, apel) # We put the first (primary) category in LAST, which will have # the desired effect of making clients that only understand one # category see that one. addElement('category', app.Categories[0], doc, apel) addElement('web', app.WebSite, doc, apel) addElement('source', app.SourceCode, doc, apel) addElement('tracker', app.IssueTracker, doc, apel) addElementNonEmpty('changelog', app.Changelog, doc, apel) addElementNonEmpty('author', app.AuthorName, doc, apel) addElementNonEmpty('email', app.AuthorEmail, doc, apel) addElementNonEmpty('donate', app.Donate, doc, apel) addElementNonEmpty('bitcoin', app.Bitcoin, doc, apel) addElementNonEmpty('litecoin', app.Litecoin, doc, apel) addElementNonEmpty('flattr', app.FlattrID, doc, apel) # These elements actually refer to the current version (i.e. which # one is recommended. They are historically mis-named, and need # changing, but stay like this for now to support existing clients. addElement('marketversion', app.CurrentVersion, doc, apel) addElement('marketvercode', app.CurrentVersionCode, doc, apel) if app.Provides: pv = app.Provides.split(',') addElementNonEmpty('provides', ','.join(pv), doc, apel) if app.RequiresRoot: addElement('requirements', 'root', doc, apel) # Sort the apk list into version order, just so the web site # doesn't have to do any work by default... apklist = sorted(apklist, key=lambda apk: apk['versionCode'], reverse=True) if 'antiFeatures' in apklist[0]: app.AntiFeatures.extend(apklist[0]['antiFeatures']) if app.AntiFeatures: addElementNonEmpty('antifeatures', ','.join(app.AntiFeatures), doc, apel) # Check for duplicates - they will make the client unhappy... for i in range(len(apklist) - 1): first = apklist[i] second = apklist[i + 1] if first['versionCode'] == second['versionCode'] \ and first['sig'] == second['sig']: if first['hash'] == second['hash']: raise FDroidException( '"{0}/{1}" and "{0}/{2}" are exact duplicates!'.format( repodir, first['apkName'], second['apkName'])) else: raise FDroidException( 'duplicates: "{0}/{1}" - "{0}/{2}"'.format( repodir, first['apkName'], second['apkName'])) current_version_code = 0 current_version_file = None for apk in apklist: file_extension = common.get_file_extension(apk['apkName']) # find the APK for the "Current Version" if current_version_code < apk['versionCode']: current_version_code = apk['versionCode'] if current_version_code < int(app.CurrentVersionCode): current_version_file = apk['apkName'] apkel = doc.createElement("package") apel.appendChild(apkel) addElement('version', apk['versionName'], doc, apkel) addElement('versioncode', str(apk['versionCode']), doc, apkel) addElement('apkname', apk['apkName'], doc, apkel) addElementIfInApk('srcname', apk, 'srcname', doc, apkel) hashel = doc.createElement("hash") hashel.setAttribute('type', 'sha256') hashel.appendChild(doc.createTextNode(apk['hash'])) apkel.appendChild(hashel) addElement('size', str(apk['size']), doc, apkel) addElementIfInApk('sdkver', apk, 'minSdkVersion', doc, apkel) addElementIfInApk('targetSdkVersion', apk, 'targetSdkVersion', doc, apkel) addElementIfInApk('maxsdkver', apk, 'maxSdkVersion', doc, apkel) addElementIfInApk('obbMainFile', apk, 'obbMainFile', doc, apkel) addElementIfInApk('obbMainFileSha256', apk, 'obbMainFileSha256', doc, apkel) addElementIfInApk('obbPatchFile', apk, 'obbPatchFile', doc, apkel) addElementIfInApk('obbPatchFileSha256', apk, 'obbPatchFileSha256', doc, apkel) if 'added' in apk: addElement('added', apk['added'].strftime('%Y-%m-%d'), doc, apkel) if file_extension == 'apk': # sig is required for APKs, but only APKs addElement('sig', apk['sig'], doc, apkel) old_permissions = set() sorted_permissions = sorted(apk['uses-permission']) for perm in sorted_permissions: perm_name = perm.name if perm_name.startswith("android.permission."): perm_name = perm_name[19:] old_permissions.add(perm_name) addElementNonEmpty('permissions', ','.join(sorted(old_permissions)), doc, apkel) for permission in sorted_permissions: permel = doc.createElement('uses-permission') permel.setAttribute('name', permission.name) if permission.maxSdkVersion is not None: permel.setAttribute('maxSdkVersion', '%d' % permission.maxSdkVersion) apkel.appendChild(permel) for permission_sdk_23 in sorted(apk['uses-permission-sdk-23']): permel = doc.createElement('uses-permission-sdk-23') permel.setAttribute('name', permission_sdk_23.name) if permission_sdk_23.maxSdkVersion is not None: permel.setAttribute( 'maxSdkVersion', '%d' % permission_sdk_23.maxSdkVersion) apkel.appendChild(permel) if 'nativecode' in apk: addElement('nativecode', ','.join(sorted(apk['nativecode'])), doc, apkel) addElementNonEmpty('features', ','.join(sorted(apk['features'])), doc, apkel) if current_version_file is not None \ and common.config['make_current_version_link'] \ and repodir == 'repo': # only create these namefield = common.config['current_version_name_source'] sanitized_name = re.sub(b'''[ '"&%?+=/]''', b'', app.get(namefield).encode('utf-8')) apklinkname = sanitized_name + os.path.splitext( current_version_file)[1].encode('utf-8') current_version_path = os.path.join(repodir, current_version_file).encode( 'utf-8', 'surrogateescape') if os.path.islink(apklinkname): os.remove(apklinkname) os.symlink(current_version_path, apklinkname) # also symlink gpg signature, if it exists for extension in (b'.asc', b'.sig'): sigfile_path = current_version_path + extension if os.path.exists(sigfile_path): siglinkname = apklinkname + extension if os.path.islink(siglinkname): os.remove(siglinkname) os.symlink(sigfile_path, siglinkname) if common.options.pretty: output = doc.toprettyxml(encoding='utf-8') else: output = doc.toxml(encoding='utf-8') with open(os.path.join(repodir, 'index.xml'), 'wb') as f: f.write(output) if 'repo_keyalias' in common.config: if common.options.nosign: logging.info( _("Creating unsigned index in preparation for signing")) else: logging.info(_("Creating signed index with this key (SHA256):")) logging.info("%s" % repo_pubkey_fingerprint) # Create a jar of the index... jar_output = 'index_unsigned.jar' if common.options.nosign else 'index.jar' p = FDroidPopen(['jar', 'cf', jar_output, 'index.xml'], cwd=repodir) if p.returncode != 0: raise FDroidException("Failed to create {0}".format(jar_output)) # Sign the index... signed = os.path.join(repodir, 'index.jar') if common.options.nosign: # Remove old signed index if not signing if os.path.exists(signed): os.remove(signed) else: signindex.config = common.config signindex.sign_jar(signed) # Copy the repo icon into the repo directory... icon_dir = os.path.join(repodir, 'icons') iconfilename = os.path.join(icon_dir, os.path.basename(common.config['repo_icon'])) shutil.copyfile(common.config['repo_icon'], iconfilename)
def showgt(): landmarkfile = open(landmarkpath) bboxfile = open(bboxpath) numofimgs = int(landmarkfile.readline()) _ = landmarkfile.readline() _ = bboxfile.readline() _ = bboxfile.readline() index = 0 pbar = progress.start() if convet2yoloformat: if not os.path.exists(labelsdir): os.mkdir(labelsdir) if convert2vocformat: if not os.path.exists(vocannotationdir): os.mkdir(vocannotationdir) # while(index<numofimgs): for i in pbar(range(numofimgs)): #pbar.update(int((index/(numofimgs-1))*10000)) landmarkline = landmarkfile.readline().split() filename = landmarkline[0] #sys.stdout.write("\r"+str(index)+":"+filename) #sys.stdout.flush() imgpath = imgdir + "/" + filename img = cv2.imread(imgpath) landmarkline = landmarkline[1:] landmark = [int(pt) for pt in landmarkline] bboxline = bboxfile.readline().split() imgpath2 = imgdir + "/" + bboxline[0] bboxline = bboxline[1:] bbox = [int(bb) for bb in bboxline] drawbboxandlandmarks(img, bbox, landmark) if convet2yoloformat: height = img.shape[0] width = img.shape[1] txtpath = labelsdir + "/" + filename txtpath = txtpath[:-3] + "txt" ftxt = open(txtpath, 'w') xcenter = (bbox[0] + bbox[2] * 0.5) / width ycenter = (bbox[1] + bbox[3] * 0.5) / height wr = bbox[2] * 1.0 / width hr = bbox[3] * 1.0 / height line = "0 " + str(xcenter) + " " + str(ycenter) + " " + str( wr) + " " + str(hr) + "\n" ftxt.write(line) ftxt.close() if convert2vocformat: xmlpath = vocannotationdir + "/" + filename xmlpath = xmlpath[:-3] + "xml" doc = Document() annotation = doc.createElement('annotation') doc.appendChild(annotation) folder = doc.createElement('folder') folder_name = doc.createTextNode('CelebA') folder.appendChild(folder_name) annotation.appendChild(folder) filenamenode = doc.createElement('filename') filename_name = doc.createTextNode(filename) filenamenode.appendChild(filename_name) annotation.appendChild(filenamenode) source = doc.createElement('source') annotation.appendChild(source) database = doc.createElement('database') database.appendChild(doc.createTextNode('CelebA Database')) source.appendChild(database) annotation_s = doc.createElement('annotation') annotation_s.appendChild(doc.createTextNode('PASCAL VOC2007')) source.appendChild(annotation_s) image = doc.createElement('image') image.appendChild(doc.createTextNode('flickr')) source.appendChild(image) flickrid = doc.createElement('flickrid') flickrid.appendChild(doc.createTextNode('-1')) source.appendChild(flickrid) owner = doc.createElement('owner') annotation.appendChild(owner) flickrid_o = doc.createElement('flickrid') flickrid_o.appendChild(doc.createTextNode('tdr')) owner.appendChild(flickrid_o) name_o = doc.createElement('name') name_o.appendChild(doc.createTextNode('yanyu')) owner.appendChild(name_o) size = doc.createElement('size') annotation.appendChild(size) width = doc.createElement('width') width.appendChild(doc.createTextNode(str(img.shape[1]))) height = doc.createElement('height') height.appendChild(doc.createTextNode(str(img.shape[0]))) depth = doc.createElement('depth') depth.appendChild(doc.createTextNode(str(img.shape[2]))) size.appendChild(width) size.appendChild(height) size.appendChild(depth) segmented = doc.createElement('segmented') segmented.appendChild(doc.createTextNode('0')) annotation.appendChild(segmented) for i in range(1): objects = doc.createElement('object') annotation.appendChild(objects) object_name = doc.createElement('name') object_name.appendChild(doc.createTextNode('face')) objects.appendChild(object_name) pose = doc.createElement('pose') pose.appendChild(doc.createTextNode('Unspecified')) objects.appendChild(pose) truncated = doc.createElement('truncated') truncated.appendChild(doc.createTextNode('1')) objects.appendChild(truncated) difficult = doc.createElement('difficult') difficult.appendChild(doc.createTextNode('0')) objects.appendChild(difficult) bndbox = doc.createElement('bndbox') objects.appendChild(bndbox) xmin = doc.createElement('xmin') xmin.appendChild(doc.createTextNode(str(bbox[0]))) bndbox.appendChild(xmin) ymin = doc.createElement('ymin') ymin.appendChild(doc.createTextNode(str(bbox[1]))) bndbox.appendChild(ymin) xmax = doc.createElement('xmax') xmax.appendChild(doc.createTextNode(str(bbox[0] + bbox[2]))) bndbox.appendChild(xmax) ymax = doc.createElement('ymax') ymax.appendChild(doc.createTextNode(str(bbox[1] + bbox[3]))) bndbox.appendChild(ymax) f = open(xmlpath, "w") f.write(doc.toprettyxml(indent='')) f.close() cv2.imshow("img", img) cv2.waitKey(1) index = index + 1 pbar.finish()
def create(): indexNum = 0 #数字下标 #print (os.getcwd()) E:\JAVA\NewWorkSpace\ApplePests\DataSetPretreat #if path exist return true else false ,function join merge dir path and file path #os.getcwd()return current path if os.path.exists(os.path.join(os.getcwd(), imgpath)): #JPEGImages shutil.rmtree(imgpath) #delete dir and file if os.path.exists(os.path.join(os.getcwd(), xmlpath_new)): #Annotation shutil.rmtree(xmlpath_new) os.mkdir(os.path.join(os.getcwd(), imgpath)) #make new dir os.mkdir(os.path.join(os.getcwd(), xmlpath_new)) for category in os.listdir(labels): #return all file names labelCategoryPath = os.path.join(labels, category) pretreatCategoryPath = os.path.join(pretreat, category) for label in os.listdir(labelCategoryPath): pictureName = label.replace('.txt', '.jpg') #预处理的图片名 indexName = "%06d" % indexNum #新文件名称 picturePathIndexName = os.path.join(imgpath, indexName + ".jpg") #新图片路径 pretreatPicturePath = os.path.join(pretreatCategoryPath, pictureName) #预处理的图片路径 #拷贝文件并命名为pictureIndexName.jpg shutil.copy(pretreatPicturePath, picturePathIndexName) #open(picturePathIndexName, "wb").write(open(pretreatPicturePath, "rb").read()) fidin = open(labelCategoryPath + '/' + label, 'r') objIndex = 0 L = [] for data in islice(fidin, 1, None): objIndex += 1 data = data.strip('\n') datas = data.split(' ') if 5 != len(datas): print('bounding box information error') continue L.append(datas) #imageFile = imgpath + pictureName #img = cv2.imread(imageFile) img = Image.open(picturePathIndexName) imgSize = img.size imgSize = imgSize + (3, ) #xmlName = each.replace('.txt', '.xml') #f = open(xmlpath_new + indexName + ".xml", "w") f = open(os.path.join(xmlpath_new, indexName + ".xml"), "w") doc = Document() annotation = doc.createElement('annotation') doc.appendChild(annotation) folder = doc.createElement('folder') folder.appendChild(doc.createTextNode(foldername)) annotation.appendChild(folder) filename = doc.createElement('filename') filename.appendChild(doc.createTextNode(indexName + ".jpg")) annotation.appendChild(filename) source = doc.createElement('source') database = doc.createElement('database') database.appendChild(doc.createTextNode('My Database')) source.appendChild(database) source_annotation = doc.createElement('annotation') source_annotation.appendChild(doc.createTextNode(foldername)) source.appendChild(source_annotation) image = doc.createElement('image') image.appendChild(doc.createTextNode('flickr')) source.appendChild(image) flickrid = doc.createElement('flickrid') flickrid.appendChild(doc.createTextNode('NULL')) source.appendChild(flickrid) annotation.appendChild(source) owner = doc.createElement('owner') flickrid = doc.createElement('flickrid') flickrid.appendChild(doc.createTextNode('NULL')) owner.appendChild(flickrid) name = doc.createElement('name') name.appendChild(doc.createTextNode('idaneel')) owner.appendChild(name) annotation.appendChild(owner) size = doc.createElement('size') width = doc.createElement('width') width.appendChild(doc.createTextNode(str(imgSize[0]))) size.appendChild(width) height = doc.createElement('height') height.appendChild(doc.createTextNode(str(imgSize[1]))) size.appendChild(height) depth = doc.createElement('depth') depth.appendChild(doc.createTextNode(str(imgSize[2]))) size.appendChild(depth) annotation.appendChild(size) segmented = doc.createElement('segmented') segmented.appendChild(doc.createTextNode(str(0))) annotation.appendChild(segmented) for i in range(len(L)): annotation.appendChild(insertObject(doc, L, i)) try: f.write(doc.toprettyxml(indent=' ')) f.close() fidin.close() except: pass indexNum += 1
def create(): for walk in os.walk(labels): for each in walk[2]: fidin = open(walk[0] + '/' + each, 'r') objIndex = 0 for data in islice(fidin, 1, None): objIndex += 1 data = data.strip('\n') datas = data.split(' ') if 5 != len(datas): print 'bounding box information error' continue # changed by dejian,li #pictureName = each.replace('.txt', '.jpg') # changed by dejian,li pictureName = each.replace('.txt', '.jpg') print pictureName # imgpath = '/home/lord/programs/BBox-Label-Tool-master/Images/2/' imageFile = imgpath + pictureName img = cv2.imread(imageFile) if img == None: pictureName = each.replace('.txt', '.JPG') #print pictureName # imgpath = '/home/lord/programs/BBox-Label-Tool-master/Images/2/' imageFile = imgpath + pictureName #print imageFile img = cv2.imread(imageFile) imgSize = img.shape if 1 == objIndex: xmlName = each.replace('.txt', '.xml') f = open(xmlpath_new + xmlName, "w") doc = Document() annotation = doc.createElement('annotation') doc.appendChild(annotation) folder = doc.createElement('folder') folder.appendChild(doc.createTextNode(foldername)) annotation.appendChild(folder) filename = doc.createElement('filename') filename.appendChild(doc.createTextNode(pictureName)) annotation.appendChild(filename) source = doc.createElement('source') database = doc.createElement('database') database.appendChild(doc.createTextNode('My Database')) source.appendChild(database) source_annotation = doc.createElement('annotation') source_annotation.appendChild( doc.createTextNode(foldername)) source.appendChild(source_annotation) image = doc.createElement('image') image.appendChild(doc.createTextNode('flickr')) source.appendChild(image) flickrid = doc.createElement('flickrid') flickrid.appendChild(doc.createTextNode('NULL')) source.appendChild(flickrid) annotation.appendChild(source) owner = doc.createElement('owner') flickrid = doc.createElement('flickrid') flickrid.appendChild(doc.createTextNode('NULL')) owner.appendChild(flickrid) name = doc.createElement('name') name.appendChild(doc.createTextNode('idaneel')) owner.appendChild(name) annotation.appendChild(owner) size = doc.createElement('size') width = doc.createElement('width') width.appendChild(doc.createTextNode(str(imgSize[1]))) size.appendChild(width) height = doc.createElement('height') height.appendChild(doc.createTextNode(str(imgSize[0]))) size.appendChild(height) depth = doc.createElement('depth') depth.appendChild(doc.createTextNode(str(imgSize[2]))) size.appendChild(depth) annotation.appendChild(size) segmented = doc.createElement('segmented') segmented.appendChild(doc.createTextNode(str(0))) annotation.appendChild(segmented) annotation.appendChild(insertObject(doc, datas)) else: annotation.appendChild(insertObject(doc, datas)) try: f.write(doc.toprettyxml(indent=' ')) f.close() fidin.close() except: pass
def vendors(request): vens = [] #pull vendors, filter by entity newdoc = Document(); request = newdoc.createElement('request') newdoc.appendChild(request) control = newdoc.createElement('control') request.appendChild(control) senderid = newdoc.createElement('senderid') control.appendChild(senderid).appendChild(newdoc.createTextNode(acc_keys.int_sender_id())) senderpassword = newdoc.createElement('password') control.appendChild(senderpassword).appendChild(newdoc.createTextNode(acc_keys.int_sender_pass())) controlid = newdoc.createElement('controlid') control.appendChild(controlid).appendChild(newdoc.createTextNode(str(int(time.time())))) uniqueid = newdoc.createElement('uniqueid') control.appendChild(uniqueid).appendChild(newdoc.createTextNode("false")) dtdversion = newdoc.createElement('dtdversion') control.appendChild(dtdversion).appendChild(newdoc.createTextNode("3.0")) includewhitespace = newdoc.createElement('includewhitespace') control.appendChild(includewhitespace).appendChild(newdoc.createTextNode("false")) operation = newdoc.createElement('operation') request.appendChild(operation) authentication = newdoc.createElement('authentication') operation.appendChild(operation) s = Session.objects.order_by('-session_time') ses = s[0].sessionid sessionid = newdoc.createElement('sessionid') authentication.appendChild(sessionid).appendChild(newdoc.createTextNode(ses)) content = newdoc.createElement('content') operation.appendChild(content) function = newdoc.createElement('function') content.appendChild(function).setAttributeNode(newdoc.createAttribute('controlid')) function.attributes["controlid"].value = "1" read = newdoc.createElement('readByQuery') function.appendChild(read) objectt = newdoc.createElement('object') read.appendChild(objectt).appendChild(newdoc.createTextNode('VENDOR')) fields = newdoc.createElement('fields') read.appendChild(objectt).appendChild(newdoc.createTextNode('*')) query = newdoc.createElement('query') read.appendChild(query) pagesize = newdoc.createElement('pagesize') read.appendChild(pagesize).appendChild(newdoc.createTextNode('3')) print(request.toprettyxml()) #print(request) # Post the request #result = XMLRequestClient.post(request) ''' for vendor in result.getElementsByTagName('vendor'): for tag in vendor.getElementsByTagName('DISPLAYCONTACT.PRINTAS'): ven = tag[0].firstChild.nodeValue vens.append(ven) ''' #paginate #finish pagination #send list context = {vens} return render(request, 'intacct/vendors.html', context)
def show_annotations(): if not os.path.exists(Annotationsdir): os.mkdir(Annotationsdir) if not os.path.exists(labelsdir): os.mkdir(labelsdir) for i in range(10): annotationfilepath = annotationdir + "/FDDB-fold-%0*d-ellipseList.txt" % ( 2, i + 1) annotationfile = open(annotationfilepath) while (True): filename = annotationfile.readline()[:-1] + ".jpg" if not filename: break line = annotationfile.readline() if not line: break print(filename) facenum = (int)(line) img = cv2.imread(origimagedir + "/" + filename) filename = filename.replace('/', '_') cv2.imwrite(imagesdir + "/" + filename, img) w = img.shape[1] h = img.shape[0] if bsavetxtanno: labelpath = labelsdir + "/" + filename.replace( '/', '_')[:-3] + "txt" labelfile = open(labelpath, 'w') if bsavexmlanno: xmlpath = Annotationsdir + "/" + filename.replace( '/', '_')[:-3] + "txt" xmlpath = xmlpath[:-3] + "xml" doc = Document() annotation = doc.createElement('annotation') doc.appendChild(annotation) folder = doc.createElement('folder') folder_name = doc.createTextNode('fddb') folder.appendChild(folder_name) annotation.appendChild(folder) filenamenode = doc.createElement('filename') filename_name = doc.createTextNode(filename) filenamenode.appendChild(filename_name) annotation.appendChild(filenamenode) source = doc.createElement('source') annotation.appendChild(source) database = doc.createElement('database') database.appendChild(doc.createTextNode('fddb Database')) source.appendChild(database) annotation_s = doc.createElement('annotation') annotation_s.appendChild(doc.createTextNode('PASCAL VOC2007')) source.appendChild(annotation_s) image = doc.createElement('image') image.appendChild(doc.createTextNode('flickr')) source.appendChild(image) flickrid = doc.createElement('flickrid') flickrid.appendChild(doc.createTextNode('-1')) source.appendChild(flickrid) owner = doc.createElement('owner') annotation.appendChild(owner) flickrid_o = doc.createElement('flickrid') flickrid_o.appendChild(doc.createTextNode('yanyu')) owner.appendChild(flickrid_o) name_o = doc.createElement('name') name_o.appendChild(doc.createTextNode('yanyu')) owner.appendChild(name_o) size = doc.createElement('size') annotation.appendChild(size) width = doc.createElement('width') width.appendChild(doc.createTextNode(str(img.shape[1]))) height = doc.createElement('height') height.appendChild(doc.createTextNode(str(img.shape[0]))) depth = doc.createElement('depth') depth.appendChild(doc.createTextNode(str(img.shape[2]))) size.appendChild(width) size.appendChild(height) size.appendChild(depth) segmented = doc.createElement('segmented') segmented.appendChild(doc.createTextNode('0')) annotation.appendChild(segmented) for j in range(facenum): line = annotationfile.readline().strip().split() major_axis_radius = (float)(line[0]) minor_axis_radius = (float)(line[1]) angle = (float)(line[2]) center_x = (float)(line[3]) center_y = (float)(line[4]) score = (float)(line[5]) angle = angle / 3.1415926 * 180 cv2.ellipse(img, ((int)(center_x), (int)(center_y)), ((int)(major_axis_radius), (int)(minor_axis_radius)), angle, 0., 360., (255, 0, 0)) if convert2rects: mask = np.zeros((img.shape[0], img.shape[1]), dtype=np.uint8) cv2.ellipse(mask, ((int)(center_x), (int)(center_y)), ((int)(major_axis_radius), (int)(minor_axis_radius)), angle, 0., 360., (255, 255, 255)) #cv2.imshow("mask",mask) contours, hierarchy = cv2.findContours( mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) for k in range(len(contours)): r = cv2.boundingRect(contours[k]) x_min = r[0] y_min = r[1] x_max = r[0] + r[2] y_max = r[1] + r[3] xcenter = r[0] + r[2] / 2 ycenter = r[1] + r[3] / 2 if bsavetxtanno: labelline = "0" + "\t" + str( xcenter * 1.0 / w) + '\t' + str( ycenter * 1.0 / h) + '\t' + str( r[2] * 1.0 / w) + '\t' + str( r[3] * 1.0 / h) + '\n' labelfile.write(labelline) if bsavexmlanno: object = doc.createElement('object') annotation.appendChild(object) object_name = doc.createElement('name') object_name.appendChild(doc.createTextNode('face')) object.appendChild(object_name) pose = doc.createElement('pose') pose.appendChild(doc.createTextNode('Unspecified')) object.appendChild(pose) truncated = doc.createElement('truncated') truncated.appendChild(doc.createTextNode('1')) object.appendChild(truncated) difficult = doc.createElement('difficult') difficult.appendChild(doc.createTextNode('0')) object.appendChild(difficult) bndbox = doc.createElement('bndbox') object.appendChild(bndbox) xmin = doc.createElement('xmin') xmin.appendChild(doc.createTextNode(str(x_min))) bndbox.appendChild(xmin) ymin = doc.createElement('ymin') ymin.appendChild(doc.createTextNode(str(y_min))) bndbox.appendChild(ymin) xmax = doc.createElement('xmax') xmax.appendChild(doc.createTextNode(str(x_max))) bndbox.appendChild(xmax) ymax = doc.createElement('ymax') ymax.appendChild(doc.createTextNode(str(y_max))) bndbox.appendChild(ymax) cv2.rectangle(img, (int(x_min), int(y_min)), (int(x_max), int(y_max)), (0, 0, 255)) if bsavetxtanno: labelfile.close() if bsavexmlanno: f = open(xmlpath, "w") f.write(doc.toprettyxml(indent='')) f.close() cv2.imshow("img", img) cv2.waitKey(1)
def generate_xml(name, split_lines, img_size, class_ind): doc = Document() # 创建DOM文档对象 annotation = doc.createElement('annotation') doc.appendChild(annotation) title = doc.createElement('folder') title_text = doc.createTextNode('KITTI') title.appendChild(title_text) annotation.appendChild(title) img_name = name + '.png' title = doc.createElement('filename') title_text = doc.createTextNode(img_name) title.appendChild(title_text) annotation.appendChild(title) source = doc.createElement('source') annotation.appendChild(source) title = doc.createElement('database') title_text = doc.createTextNode('The KITTI Database') title.appendChild(title_text) source.appendChild(title) title = doc.createElement('annotation') title_text = doc.createTextNode('KITTI') title.appendChild(title_text) source.appendChild(title) size = doc.createElement('size') annotation.appendChild(size) title = doc.createElement('width') title_text = doc.createTextNode(str(img_size[1])) title.appendChild(title_text) size.appendChild(title) title = doc.createElement('height') title_text = doc.createTextNode(str(img_size[0])) title.appendChild(title_text) size.appendChild(title) title = doc.createElement('depth') title_text = doc.createTextNode(str(img_size[2])) title.appendChild(title_text) size.appendChild(title) for split_line in split_lines: line = split_line.strip().split() if line[0] in class_ind: object = doc.createElement('object') annotation.appendChild(object) title = doc.createElement('name') title_text = doc.createTextNode(line[0]) title.appendChild(title_text) object.appendChild(title) bndbox = doc.createElement('bndbox') object.appendChild(bndbox) title = doc.createElement('xmin') title_text = doc.createTextNode(str(int(float(line[4])))) title.appendChild(title_text) bndbox.appendChild(title) title = doc.createElement('ymin') title_text = doc.createTextNode(str(int(float(line[5])))) title.appendChild(title_text) bndbox.appendChild(title) title = doc.createElement('xmax') title_text = doc.createTextNode(str(int(float(line[6])))) title.appendChild(title_text) bndbox.appendChild(title) title = doc.createElement('ymax') title_text = doc.createTextNode(str(int(float(line[7])))) title.appendChild(title_text) bndbox.appendChild(title) # 将DOM对象doc写入文件 f = open('Annotations/' + name + '.xml', 'w') f.write(doc.toprettyxml(indent='')) f.close()
def generate_name_id(value, sp_nq, sp_format=None, cert=None, debug=False, nq=None): """ Generates a nameID. :param value: fingerprint :type: string :param sp_nq: SP Name Qualifier :type: string :param sp_format: SP Format :type: string :param cert: IdP Public Cert to encrypt the nameID :type: string :param debug: Activate the xmlsec debug :type: bool :param nq: IDP Name Qualifier :type: string :returns: DOMElement | XMLSec nameID :rtype: string """ doc = Document() name_id_container = doc.createElementNS( OneLogin_Saml2_Constants.NS_SAML, 'container') name_id_container.setAttribute("xmlns:saml", OneLogin_Saml2_Constants.NS_SAML) name_id = doc.createElement('saml:NameID') if sp_nq is not None: name_id.setAttribute('SPNameQualifier', sp_nq) if nq is not None: name_id.setAttribute('NameQualifier', nq) if sp_format is not None: name_id.setAttribute('Format', sp_format) name_id.appendChild(doc.createTextNode(value)) name_id_container.appendChild(name_id) if cert is not None: xml = name_id_container.toxml() elem = fromstring(xml) error_callback_method = None if debug: error_callback_method = print_xmlsec_errors xmlsec.set_error_callback(error_callback_method) # Load the public cert mngr = xmlsec.KeysMngr() file_cert = OneLogin_Saml2_Utils.write_temp_file(cert) key_data = xmlsec.Key.load(file_cert.name, xmlsec.KeyDataFormatCertPem, None) key_data.name = basename(file_cert.name) mngr.addKey(key_data) file_cert.close() # Prepare for encryption enc_data = EncData(xmlsec.TransformAes128Cbc, type=xmlsec.TypeEncElement) enc_data.ensureCipherValue() key_info = enc_data.ensureKeyInfo() # enc_key = key_info.addEncryptedKey(xmlsec.TransformRsaPkcs1) enc_key = key_info.addEncryptedKey(xmlsec.TransformRsaOaep) enc_key.ensureCipherValue() # Encrypt! enc_ctx = xmlsec.EncCtx(mngr) enc_ctx.encKey = xmlsec.Key.generate(xmlsec.KeyDataAes, 128, xmlsec.KeyDataTypeSession) edata = enc_ctx.encryptXml(enc_data, elem[0]) newdoc = parseString( tostring(edata, encoding='unicode').encode('utf-8')) if newdoc.hasChildNodes(): child = newdoc.firstChild child.removeAttribute('xmlns') child.removeAttribute('xmlns:saml') child.setAttribute('xmlns:xenc', OneLogin_Saml2_Constants.NS_XENC) child.setAttribute('xmlns:dsig', OneLogin_Saml2_Constants.NS_DS) nodes = newdoc.getElementsByTagName("*") for node in nodes: if node.tagName == 'ns0:KeyInfo': node.tagName = 'dsig:KeyInfo' node.removeAttribute('xmlns:ns0') node.setAttribute('xmlns:dsig', OneLogin_Saml2_Constants.NS_DS) else: node.tagName = 'xenc:' + node.tagName encrypted_id = newdoc.createElement('saml:EncryptedID') encrypted_data = newdoc.replaceChild(encrypted_id, newdoc.firstChild) encrypted_id.appendChild(encrypted_data) return newdoc.saveXML(encrypted_id) else: return doc.saveXML(name_id)
doc = Document() wordbook = doc.createElement('wordbook') match = re.compile(u'(\d+)\.(.*?)([\u4e00-\u9fa5].*)') with open('d:\\a.txt', 'r') as myfile: content = myfile.readlines() for line in content: # print line item = doc.createElement('item') word = doc.createElement('word') trans = doc.createElement('trans') phonetic = doc.createElement('phonetic') tags = doc.createElement('tags') progress = doc.createElement('progress') matches = match.findall(line.decode()) word.appendChild(doc.createCDATASection(matches[0][1])) trans.appendChild(doc.createCDATASection(matches[0][2])) progress.appendChild(doc.createTextNode('0')) phonetic.appendChild(doc.createTextNode('')) tags.appendChild(doc.createTextNode('')) item.appendChild(word) item.appendChild(trans) item.appendChild(phonetic) item.appendChild(tags) item.appendChild(progress) wordbook.appendChild(item) doc.appendChild(wordbook) objxml = open('d:\\word.xml', 'w') objxml.write(doc.toprettyxml(indent=" ")) objxml.close()
def makexml(txtPath, xmlPath, picPath): #读取txt路径,xml保存路径,数据集图片所在路径 dict = { '1': "apple", #字典对类型进行转换 '2': "egg", '3': "mihoutao", '4': "qingmang", '5': "xihulu", '6': "xihongshi", '7': "bocai", '8': "shengcai", '9': "youcai", '10': "hongyuanjiao" } files = os.listdir(txtPath) for i, name in enumerate(files): xmlBuilder = Document() annotation = xmlBuilder.createElement("annotation") # 创建annotation标签 xmlBuilder.appendChild(annotation) txtFile = open(txtPath + name) txtList = txtFile.readlines() img = cv2.imread(picPath + name[0:-4] + ".jpg") Pheight, Pwidth, Pdepth = img.shape for i in txtList: oneline = i.strip().split(" ") folder = xmlBuilder.createElement("folder") #folder标签 folderContent = xmlBuilder.createTextNode("VOC2007") folder.appendChild(folderContent) annotation.appendChild(folder) filename = xmlBuilder.createElement("filename") #filename标签 filenameContent = xmlBuilder.createTextNode(name[0:-4] + ".jpg") filename.appendChild(filenameContent) annotation.appendChild(filename) size = xmlBuilder.createElement("size") # size标签 width = xmlBuilder.createElement("width") # size子标签width widthContent = xmlBuilder.createTextNode(str(Pwidth)) width.appendChild(widthContent) size.appendChild(width) height = xmlBuilder.createElement("height") # size子标签height heightContent = xmlBuilder.createTextNode(str(Pheight)) height.appendChild(heightContent) size.appendChild(height) depth = xmlBuilder.createElement("depth") # size子标签depth depthContent = xmlBuilder.createTextNode(str(Pdepth)) depth.appendChild(depthContent) size.appendChild(depth) annotation.appendChild(size) object = xmlBuilder.createElement("object") picname = xmlBuilder.createElement("name") nameContent = xmlBuilder.createTextNode(dict[oneline[0]]) picname.appendChild(nameContent) object.appendChild(picname) pose = xmlBuilder.createElement("pose") poseContent = xmlBuilder.createTextNode("Unspecified") pose.appendChild(poseContent) object.appendChild(pose) truncated = xmlBuilder.createElement("truncated") truncatedContent = xmlBuilder.createTextNode("0") truncated.appendChild(truncatedContent) object.appendChild(truncated) difficult = xmlBuilder.createElement("difficult") difficultContent = xmlBuilder.createTextNode("0") difficult.appendChild(difficultContent) object.appendChild(difficult) bndbox = xmlBuilder.createElement("bndbox") xmin = xmlBuilder.createElement("xmin") mathData = int(((float(oneline[1])) * Pwidth + 1) - (float(oneline[3])) * 0.5 * Pwidth) xminContent = xmlBuilder.createTextNode(str(mathData)) xmin.appendChild(xminContent) bndbox.appendChild(xmin) ymin = xmlBuilder.createElement("ymin") mathData = int(((float(oneline[2])) * Pheight + 1) - (float(oneline[4])) * 0.5 * Pheight) yminContent = xmlBuilder.createTextNode(str(mathData)) ymin.appendChild(yminContent) bndbox.appendChild(ymin) xmax = xmlBuilder.createElement("xmax") mathData = int(((float(oneline[1])) * Pwidth + 1) + (float(oneline[3])) * 0.5 * Pwidth) xmaxContent = xmlBuilder.createTextNode(str(mathData)) xmax.appendChild(xmaxContent) bndbox.appendChild(xmax) ymax = xmlBuilder.createElement("ymax") mathData = int(((float(oneline[2])) * Pheight + 1) + (float(oneline[4])) * 0.5 * Pheight) ymaxContent = xmlBuilder.createTextNode(str(mathData)) ymax.appendChild(ymaxContent) bndbox.appendChild(ymax) object.appendChild(bndbox) annotation.appendChild(object) f = open(xmlPath + name[0:-4] + ".xml", 'w') xmlBuilder.writexml(f, indent='\t', newl='\n', addindent='\t', encoding='utf-8') f.close()
def ConvertVOCXml(file_path="",file_name=""): tree = ET.parse(file_name) root = tree.getroot() # print(root.tag) num=0 #计数 #读xml操作 frame_lists=[] output_file_name="" for child in root: if(child.tag=="frame"): # 创建dom文档 doc = Document() # 创建根节点 annotation = doc.createElement('annotation') # 根节点插入dom树 doc.appendChild(annotation) #print(child.tag, child.attrib["num"]) pic_id= child.attrib["num"].zfill(5) #print(pic_id) output_file_name=root.attrib["name"]+"__img"+pic_id+".xml" # print(output_file_name) folder = doc.createElement("folder") folder.appendChild(doc.createTextNode("VOC2007")) annotation.appendChild(folder) filename = doc.createElement("filename") pic_name=root.attrib["name"]+"__img"+pic_id+".jpg" filename.appendChild(doc.createTextNode(pic_name)) annotation.appendChild(filename) sizeimage = doc.createElement("size") imagewidth = doc.createElement("width") imageheight = doc.createElement("height") imagedepth = doc.createElement("depth") imagewidth.appendChild(doc.createTextNode("960")) imageheight.appendChild(doc.createTextNode("540")) imagedepth.appendChild(doc.createTextNode("3")) sizeimage.appendChild(imagedepth) sizeimage.appendChild(imagewidth) sizeimage.appendChild(imageheight) annotation.appendChild(sizeimage) target_list=child.getchildren()[0] #获取target_list #print(target_list.tag) object=None for target in target_list: if(target.tag=="target"): #print(target.tag) object = doc.createElement('object') bndbox = doc.createElement("bndbox") for target_child in target: if(target_child.tag=="box"): xmin = doc.createElement("xmin") ymin = doc.createElement("ymin") xmax = doc.createElement("xmax") ymax = doc.createElement("ymax") xmin_value=int(float(target_child.attrib["left"])) ymin_value=int(float(target_child.attrib["top"])) box_width_value=int(float(target_child.attrib["width"])) box_height_value=int(float(target_child.attrib["height"])) xmin.appendChild(doc.createTextNode(str(xmin_value))) ymin.appendChild(doc.createTextNode(str(ymin_value))) if(xmin_value+box_width_value>960): xmax.appendChild(doc.createTextNode(str(960))) else: xmax.appendChild(doc.createTextNode(str(xmin_value+box_width_value))) if(ymin_value+box_height_value>540): ymax.appendChild(doc.createTextNode(str(540))) else: ymax.appendChild(doc.createTextNode(str(ymin_value+box_height_value))) if(target_child.tag=="attribute"): name = doc.createElement('name') pose=doc.createElement('pose') truncated=doc.createElement('truncated') difficult=doc.createElement('difficult') name.appendChild(doc.createTextNode("car")) pose.appendChild(doc.createTextNode("Left")) #随意指定 truncated.appendChild(doc.createTextNode("0")) #随意指定 difficult.appendChild(doc.createTextNode("0")) #随意指定 object.appendChild(name) object.appendChild(pose) object.appendChild(truncated) object.appendChild(difficult) bndbox.appendChild(xmin) bndbox.appendChild(ymin) bndbox.appendChild(xmax) bndbox.appendChild(ymax) object.appendChild(bndbox) annotation.appendChild(object) file_path_out=os.path.join(file_path,output_file_name) f = open(file_path_out, 'w') f.write(doc.toprettyxml(indent=' ' * 4)) f.close() num=num+1 return num
class RSS2Feed(object): """An RSS 2.0 feed.""" class FeedError(Exception): """Error encountered while producing a feed.""" def __init__(self, title, link, description): """Initialize the feed with the specified attributes. :param title: brief title for the feed :param link: URL for the page containing the syndicated content :param description: longer description for the feed """ self._document = Document() rss_element = self._document.createElement('rss') rss_element.setAttribute('version', '2.0') self._document.appendChild(rss_element) self._channel = self._document.createElement('channel') rss_element.appendChild(self._channel) self._channel.appendChild(self._create_text_element('title', title)) self._channel.appendChild(self._create_text_element('link', link)) self._channel.appendChild(self._create_text_element('description', description)) def _create_text_element(self, type_, text): """Create a text element and return it.""" element = self._document.createElement(type_) element.appendChild(self._document.createTextNode(text)) return element def append_item(self, title=None, link=None, description=None, pub_date=None): """Append the specified item to the feed. :param title: brief title for the item :param link: URL for the page for the item :param description: longer drescription for the item :param pub_date: UTC timestamp or datetime instance of the item's publication date """ # Either title or description *must* be present if title is None and description is None: raise self.FeedError("Either title or description must be provided.") element = self._document.createElement('item') if not title is None: element.appendChild(self._create_text_element('title', title)) if not link is None: element.appendChild(self._create_text_element('link', link)) if not description is None: element.appendChild(self._create_text_element('description', description)) if not pub_date is None: try: timestamp = int(pub_date) except TypeError: timestamp = timegm(pub_date.utctimetuple()) element.appendChild(self._create_text_element('pubDate', formatdate(timestamp))) self._channel.appendChild(element) def get_xml(self): """Return the XML for the feed. :returns: XML representation of the RSS feed """ return self._document.toxml()
def _composition2musicxml(comp): doc = Document() score = doc.createElement("score-partwise") score.setAttribute("version", "2.0") # set title information if comp.title: title = doc.createElement("movement-title") title.appendChild(doc.createTextNode(str(comp.title))) score.appendChild(title) identification = doc.createElement("identification") # set author information if comp.author: author = doc.createElement("creator") author.setAttribute("type", "composer") author.appendChild(doc.createTextNode(str(comp.author))) identification.appendChild(author) # set additional info encoding = doc.createElement("encoding") software = doc.createElement("software") software.appendChild(doc.createTextNode("mingus")) encoding.appendChild(software) enc_date = doc.createElement("encoding-date") enc_date.appendChild(doc.createTextNode(str(datetime.date.today()))) encoding.appendChild(enc_date) identification.appendChild(encoding) score.appendChild(identification) # add tracks part_list = doc.createElement("part-list") score.appendChild(part_list) for t in comp: track = _track2musicxml(t) score_part = doc.createElement("score-part") track.setAttribute("id", str(id(t))) score_part.setAttribute("id", str(id(t))) part_name = doc.createElement("part-name") part_name.appendChild(doc.createTextNode(t.name)) score_part.appendChild(part_name) if t.instrument: # add instrument info score_inst = doc.createElement("score-instrument") score_inst.setAttribute("id", str(id(t.instrument))) name = doc.createElement("instrument-name") name.appendChild(doc.createTextNode(str(t.instrument.name))) score_inst.appendChild(name) score_part.appendChild(score_inst) # add midi instruments if isinstance(t.instrument, MidiInstrument): midi = doc.createElement("midi-instrument") midi.setAttribute("id", str(id(t.instrument))) channel = doc.createElement("midi-channel") channel.appendChild(doc.createTextNode(str(1))) # what about # the MIDI # channels? program = doc.createElement("midi-program") program.appendChild( doc.createTextNode(str(t.instrument.instrument_nr))) midi.appendChild(channel) midi.appendChild(program) score_part.appendChild(midi) part_list.appendChild(score_part) track.setAttribute("id", str(id(t))) score.appendChild(track) return score
def mask2xml(boxes, img_name, img_dir, img_size): #创建dom文档 doc = Document() #创建根节点 annotation = doc.createElement('annotation') #根节点插入dom树 doc.appendChild(annotation) #插入folder folder = doc.createElement('folder') folder_text = doc.createTextNode('imgs') folder.appendChild(folder_text) annotation.appendChild(folder) #插入filename filename = doc.createElement('filename') filename_text = doc.createTextNode(img_name) filename.appendChild(filename_text) annotation.appendChild(filename) #插入文件路径 path = doc.createElement('path') path_text = doc.createTextNode(img_dir + "\\" + img_name) path.appendChild(path_text) annotation.appendChild(path) #插入sorce source = doc.createElement('source') database = doc.createElement('database') database_text = doc.createTextNode('Unknown') database.appendChild(database_text) source.appendChild(database) annotation.appendChild(source) #插入图片大小 size = doc.createElement('size') width = doc.createElement('width') width_text = doc.createTextNode(str(img_size[1])) width.appendChild(width_text) size.appendChild(width) height = doc.createElement('height') height_text = doc.createTextNode(str(img_size[0])) height.appendChild(height_text) size.appendChild(height) depth = doc.createElement('depth') depth_text = doc.createTextNode(str(img_size[2])) depth.appendChild(depth_text) size.appendChild(depth) annotation.appendChild(size) #插入segmented segmented = doc.createElement('segmented') segmented_text = doc.createTextNode('0') segmented.appendChild(segmented_text) annotation.appendChild(segmented) #插入object for box in boxes: object = doc.createElement('object') name = doc.createElement('name') name_text = doc.createTextNode('G0') name.appendChild(name_text) object.appendChild(name) pose = doc.createElement('pose') pose_text = doc.createTextNode('Unspecified') pose.appendChild(pose_text) object.appendChild(pose) truncated = doc.createElement('truncated') truncated_text = doc.createTextNode('0') truncated.appendChild(truncated_text) object.appendChild(truncated) difficult = doc.createElement('difficult') difficult_text = doc.createTextNode('0') difficult.appendChild(difficult_text) object.appendChild(difficult) bndbox = doc.createElement('bndbox') x, y, w, h = box xmin = doc.createElement('xmin') xmin_text = doc.createTextNode(str(x)) xmin.appendChild(xmin_text) bndbox.appendChild(xmin) ymin = doc.createElement('ymin') ymin_text = doc.createTextNode(str(y)) ymin.appendChild(ymin_text) bndbox.appendChild(ymin) xmax = doc.createElement('xmax') xmax_text = doc.createTextNode(str(x+w)) xmax.appendChild(xmax_text) bndbox.appendChild(xmax) ymax = doc.createElement('ymax') ymax_text = doc.createTextNode(str(y+h)) ymax.appendChild(ymax_text) bndbox.appendChild(ymax) object.appendChild(bndbox) annotation.appendChild(object) with open(img_dir+"\\"+img_name.replace('jpg','xml'), "wb+") as f: #print(img_dir+"\\"+img_name.replace('jpg','xml')) f.write(doc.toprettyxml(indent='\t', encoding='utf-8'))
def create_session(): try: # Write the XML request with the minidom module newdoc = Document() request = newdoc.createElement('request') newdoc.appendChild(request) control = newdoc.createElement('control') request.appendChild(control) senderid = newdoc.createElement('senderid') control.appendChild(senderid).appendChild( newdoc.createTextNode(acc_keys.int_sender_id())) senderpassword = newdoc.createElement('password') control.appendChild(senderpassword).appendChild( newdoc.createTextNode(acc_keys.int_sender_pass())) controlid = newdoc.createElement('controlid') control.appendChild(controlid).appendChild( newdoc.createTextNode(str(int(time.time())))) uniqueid = newdoc.createElement('uniqueid') control.appendChild(uniqueid).appendChild( newdoc.createTextNode("false")) dtdversion = newdoc.createElement('dtdversion') control.appendChild(dtdversion).appendChild( newdoc.createTextNode("3.0")) includewhitespace = newdoc.createElement('includewhitespace') control.appendChild(includewhitespace).appendChild( newdoc.createTextNode("false")) operation = newdoc.createElement('operation') request.appendChild(operation) authentication = newdoc.createElement('authentication') operation.appendChild(authentication) login = newdoc.createElement('login') authentication.appendChild(login) userid = newdoc.createElement('userid') login.appendChild(userid).appendChild( newdoc.createTextNode(acc_keys.int_user())) companyid = newdoc.createElement('companyid') login.appendChild(companyid).appendChild( newdoc.createTextNode(acc_keys.int_company_id())) password = newdoc.createElement('password') login.appendChild(password).appendChild( newdoc.createTextNode(acc_keys.int_user_pass())) content = newdoc.createElement('content') operation.appendChild(content) function = newdoc.createElement('function') content.appendChild(function).setAttributeNode( newdoc.createAttribute('controlid')) function.attributes["controlid"].value = "1" create = newdoc.createElement('getAPISession') function.appendChild(create) #print(request.toprettyxml()) # Post the request result = XMLRequestClient.post(request) # Print the XML response to the console #print(result.toprettyxml()) find = result.getElementsByTagName('sessionid') sessionid = find[0].firstChild.nodeValue return sessionid except Exception as inst: print("Uh oh, something is wrong") print(type(inst)) print(inst.args)
def _bar2musicxml(bar): doc = Document() bar_node = doc.createElement("measure") # bar attributes attributes = doc.createElement("attributes") # calculate divisions by using the LCM l = [] for nc in bar: l.append(int(value.determine(nc[1])[0])) lcm = _lcm(terms=l) * 4 divisions = doc.createElement("divisions") divisions.appendChild(doc.createTextNode(str(lcm))) attributes.appendChild(divisions) if bar.key.key in major_keys or bar.key.key in minor_keys: key = doc.createElement("key") fifths = doc.createElement("fifths") # now we are going to guess which is the key of the bar fifths.appendChild(doc.createTextNode(str(bar.key.signature))) mode = doc.createElement("mode") mode.appendChild(doc.createTextNode(bar.key.mode)) key.appendChild(fifths) key.appendChild(mode) attributes.appendChild(key) time = doc.createElement("time") beats = doc.createElement("beats") beattype = doc.createElement("beat-type") beats.appendChild(doc.createTextNode(str(bar.meter[0]))) beattype.appendChild(doc.createTextNode(str(bar.meter[1]))) time.appendChild(beats) time.appendChild(beattype) attributes.appendChild(time) bar_node.appendChild(attributes) chord = doc.createElement("chord") for nc in bar: time = value.determine(nc[1]) beat = time[0] note_cont = nc[2] is_chord = False if note_cont: # is a note_container with 2 or more notes a chord? if len(note_cont) > 1: is_chord = True else: note_cont = [None] for n in note_cont: note = _note2musicxml(n) if is_chord: note.appendChild(chord) # convert the duration of the note duration = doc.createElement("duration") duration.appendChild( doc.createTextNode(str(int(lcm * (4.0 / beat))))) note.appendChild(duration) # check for dots dot = doc.createElement("dot") for i in range(0, time[1]): note.appendChild(dot) if beat in value.musicxml: type_node = doc.createElement("type") type_node.appendChild(doc.createTextNode(value.musicxml[beat])) note.appendChild(type_node) # check for non-standard ratio if time[2] != 1 and time[3] != 1: modification = doc.createElement("time-modification") actual = doc.createElement("actual-notes") actual.appendChild(doc.createTextNode(str(time[2]))) normal = doc.createElement("normal-notes") normal.appendChild(doc.createTextNode(str(time[3]))) modification.appendChild(actual) modification.appendChild(normal) note.appendChild(modification) bar_node.appendChild(note) return bar_node
def serializeProjects(projectList): """ Method to serialize a list of projects to the appropriate format """ doc = Document() # Create the base element packageConfiguration = doc.createElement("projectConfiguration") doc.appendChild(packageConfiguration) # Iterate on the list of packages for p in projectList: # Project element pack = doc.createElement("project") packageConfiguration.appendChild(pack) pack.setAttribute("name", p.Name()) try: short_name = p.AFSVolumeShortName() if short_name != None: pack.setAttribute("shortName", short_name) except: None # Just ignore short name in this case # Release area if p.ReleaseArea() != None and p.ReleaseArea( ) != os.environ["LHCBRELEASES"]: e = doc.createElement("releaseArea") ptext = doc.createTextNode(p.ReleaseArea()) e.appendChild(ptext) pack.appendChild(e) # DistLocation if p.DistLocation() != None and p.DistLocation( ) != os.environ["LHCBTAR"]: e = doc.createElement("distLocation") ptext = doc.createTextNode(p.DistLocation()) e.appendChild(ptext) pack.appendChild(e) # BaseName if p.BaseName() != None and p.BaseName() != "": e = doc.createElement("baseName") ptext = doc.createTextNode(p.BaseName()) e.appendChild(ptext) pack.appendChild(e) # LCGTarballName if p._lcgtarballname != None: e = doc.createElement("LCGTarballName") ptext = doc.createTextNode(p._lcgtarballname) e.appendChild(ptext) pack.appendChild(e) # AFS Volume Name if p._afsvolumename != p.NAME(): e = doc.createElement("afsVolumeName") ptext = doc.createTextNode(p._afsvolumename) e.appendChild(ptext) pack.appendChild(e) # AFS Volume Root if p._afsvolumeroot != "lhcb": e = doc.createElement("afsVolumeRoot") ptext = doc.createTextNode(p._afsvolumeroot) e.appendChild(ptext) pack.appendChild(e) # AFS Librarian Group if p._afslibgroup != "z5": e = doc.createElement("afsLibrarianGroup") ptext = doc.createTextNode(p._afslibgroup) e.appendChild(ptext) pack.appendChild(e) # Has binary if p._hasbinary != True: e = doc.createElement("hasBinary") ptext = doc.createTextNode("false") e.appendChild(ptext) pack.appendChild(e) # setenvAlias if p._setenvalias != True: e = doc.createElement("setenvAlias") ptext = doc.createTextNode("false") e.appendChild(ptext) pack.appendChild(e) # setenvAlias if p._setupalias != True: e = doc.createElement("setupAlias") ptext = doc.createTextNode("false") e.appendChild(ptext) pack.appendChild(e) # steeringPackage if p._steeringpackage != p._name + "Sys": e = doc.createElement("steeringPackage") ptext = doc.createTextNode(p._steeringpackage) e.appendChild(ptext) pack.appendChild(e) # steeringPackage if p._fullsize != 5000000: e = doc.createElement("fullSize") ptext = doc.createTextNode(str(p._fullsize)) e.appendChild(ptext) pack.appendChild(e) # steeringPackage if p._extraexe != {}: for it in sorted(p._extraexe.iteritems()): e = doc.createElement("extraexe") e.setAttribute("name", it[0]) ptext = doc.createTextNode(it[1][0]) e.appendChild(ptext) pack.appendChild(e) return doc
def Serialize(self): if not self._message: raise ICException( "iC message not sent, cannot serialize", '%s::%s' % (self.__class__.__name__, current_function())) # Create an XML document object doc = Document() # Root node cacheFidx = '%d' % self._message.GetFidx() root = doc.createElement(ICMESSAGE_ROOTNODE) root.setAttribute(ICMESSAGE_VERSIONNODE, ICMESSAGE_VERSION) root.setAttribute(ICMESSAGE_FRAMENODE, cacheFidx) doc.appendChild(root) # Classifiers for cname in self._message.classifiers.map: classifier = self._message.classifiers.Get(cname) cnode = doc.createElement(ICMESSAGE_CLASSISIFERNODE) cnode.setAttribute(ICMESSAGE_NAMENODE, classifier.GetChName()) cnode.setAttribute(ICMESSAGE_DESCNODE, classifier.GetChDescription()) root.appendChild(cnode) # Attribute: Value Type vtype = classifier.GetValueType() pvtype = ICTYPES_ENTRY_UNDEF if vtype == ICClassifier.ValueUndef: pvtype = ICTYPES_ENTRY_UNDEF elif vtype == ICClassifier.ValueProb: pvtype = ICTYPES_ENTRY_PROB elif vtype == ICClassifier.ValueDist: pvtype = ICTYPES_ENTRY_DIST elif vtype == ICClassifier.ValueCLbl: pvtype = ICTYPES_ENTRY_CLBL elif vtype == ICClassifier.ValueRCoe: pvtype = ICTYPES_ENTRY_RCOE cnode.setAttribute(ICMESSAGE_VTYPENODE, pvtype) # Attribute: Label Type ltype = classifier.GetLabelType() pltype = ICTYPES_LABEL_UNDEF if ltype == ICClassifier.LabelClass: pltype = ICTYPES_LABEL_CLASS elif ltype == ICClassifier.LabelUndef: pltype = ICTYPES_LABEL_UNDEF elif ltype == ICClassifier.LabelBiosig: pltype = ICTYPES_LABEL_BIOSIG elif ltype == ICClassifier.LabelCustom: pltype = ICTYPES_LABEL_CUSTOM cnode.setAttribute(ICMESSAGE_LTYPENODE, pltype) # Loop over classes for theclassname in classifier.classes.map: theclass = classifier.classes.Get(theclassname) knode = doc.createElement(ICMESSAGE_CLASSNODE) textnode = doc.createTextNode(theclass.GetChValue()) knode.appendChild(textnode) knode.setAttribute(ICMESSAGE_LABELNODE, theclass.GetChLabel()) cnode.appendChild(knode) return doc.toxml()
class WriteXML(object): def __init__(self, root): self.xmlroot = root self.doc = Document() def get_xmlroot(self): return self.xmlroot def set_xmlroot(self, root): self.xmlroot = root # Layout 填充 def CreateLayout(self, layout, layoutObject): name = self.doc.createElement("name") name_text = self.doc.createTextNode(layoutObject.name) name.appendChild(name_text) area = self.doc.createElement("area") area_text = self.doc.createTextNode("%d,%d,%d,%d" % layoutObject.area) area.appendChild(area_text) layout.appendChild(name) layout.appendChild(area) # Screen 填充 def CreateScreen(self, screen, screenObject): name = self.doc.createElement("name") name_text = self.doc.createTextNode(screenObject.name) name.appendChild(name_text) area = self.doc.createElement("area") area_text = self.doc.createTextNode("%d,%d,%d,%d" % screenObject.area) area.appendChild(area_text) screen.appendChild(name) screen.appendChild(area) # Widget 填充 def CreateWidget(self, widget, widgetObject): name = self.doc.createElement("name") name_text = self.doc.createTextNode(widgetObject.name) name.appendChild(name_text) area = self.doc.createElement("area") area_text = self.doc.createTextNode("%d,%d,%d,%d" % widgetObject.area) area.appendChild(area_text) params = self.doc.createElement("params") params_text = self.doc.createTextNode( "%s,%s,%s" % (widgetObject.params[0], widgetObject.params[1], widgetObject.params[2])) params.appendChild(params_text) texture = self.doc.createElement("texture") texture_text = self.doc.createTextNode(widgetObject.texture) texture.appendChild(texture_text) widget.appendChild(name) widget.appendChild(area) widget.appendChild(params) widget.appendChild(texture) # each i_layout contains name area and screen_list def WriteXML(self, layoutObject_list): for xml in layoutObject_list: self.doc = Document() GUILayout = self.doc.createElement("GUILayout") self.doc.appendChild(GUILayout) for layoutObject in xml.layout_list: Layout = self.doc.createElement("Layout") Layout.setAttribute('type', layoutObject.type) GUILayout.appendChild(Layout) self.CreateLayout(Layout, layoutObject) # each i_screen contains name area and sidget_list for screenObject in layoutObject.screen_list: Screen = self.doc.createElement("Screen") Layout.appendChild(Screen) self.CreateScreen(Screen, screenObject) # each i_widget contains name area params and textureID for widgetObject in screenObject.widget_list: textureName = xml.name + '_' + layoutObject.name + '_' + widgetObject.name widgetObject.texture = textureName Widget = self.doc.createElement("Widget") Screen.appendChild(Widget) Widget.setAttribute('type', widgetObject.type) self.CreateWidget(Widget, widgetObject) filename = self.xmlroot + xml.name + ".layout" print filename f = open(filename, 'w') self.doc.writexml(f, indent='\t', newl='\n', addindent='\t', encoding='utf-8') f.close()
def generate_file(self): # DECLARO VARIABLES Y DOC PARA FORMAR EL XML mensaje = "" doc = Document() doc1 = Document() cod_num = '12345678' serie = '001001' ids = self._context['active_ids'] print "ID DOCUMENTO 1:", ids for record in self: id_m = record.id id_ambiente = record.ambiente if id_ambiente == 'pruebas': if (not os.environ.get('PYTHONHTTPSVERIFY', '') and getattr(ssl, '_create_unverified_context', None)): ssl._create_default_https_context = ssl._create_unverified_context ambiente = '1' #CSV:28-12-2017: WS ON-LINE PRUEBAS #url = 'https://celcer.sri.gob.ec/comprobantes-electronicos-ws/RecepcionComprobantes?wsdl' #url1 = 'https://celcer.sri.gob.ec/comprobantes-electronicos-ws/AutorizacionComprobantes?wsdl' url = 'https://celcer.sri.gob.ec/comprobantes-electronicos-ws/RecepcionComprobantesOffline?wsdl' url1 = 'https://celcer.sri.gob.ec/comprobantes-electronicos-ws/AutorizacionComprobantesOffline?wsdl' if url: client = Client(url, timeout=10) else: raise Warning(('Atencion !'), ('No responde SRI intente mas tarde!')) if url1: client1 = Client(url1, timeout=10) else: raise Warning(('Atencion !'), ('No responde SRI intente mas tarde!')) elif id_ambiente == 'produccion': if (not os.environ.get('PYTHONHTTPSVERIFY', '') and getattr(ssl, '_create_unverified_context', None)): ssl._create_default_https_context = ssl._create_unverified_context ambiente = '2' #CSV:28-12-2017: WS ON-LINE PRODUCCION #url = 'https://cel.sri.gob.ec/comprobantes-electronicos-ws/RecepcionComprobantes?wsdl' #url1 = 'https://cel.sri.gob.ec/comprobantes-electronicos-ws/AutorizacionComprobantes?wsdl' url = 'https://cel.sri.gob.ec/comprobantes-electronicos-ws/RecepcionComprobantesOffline?wsdl' url1 = 'https://cel.sri.gob.ec/comprobantes-electronicos-ws/AutorizacionComprobantesOffline?wsdl' client = Client(url, timeout=10) client1 = Client(url1, timeout=10) if client and client1: print "OK SRI" else: raise Warning(('Atencion !'), ('No responde SRI intente mas tarde!')) #CARGO ARCHIVO FIRMA DIGITAL if self._uid: arcfd = self.env.user.company_id print "OBJETO USER", arcfd firmadig = arcfd.name print "TIPO", type(firmadig) if firmadig: print "FIRMA DIGITAL", firmadig else: raise Warning( 'Atencion !, Suba el archivo de Firma Digital en su Usuario!' ) id_formulario = record.formulario if id_formulario == 'normal': temision = '1' elif id_formulario == 'contingencia': temision = '2' # # OBTENER DATOS DE LA FACTURA id_header = self._context['active_id'] print "ID DOCUMENTO:", id_header #CSV:28-12-2017:ONLINE #factura = self.env['account.invoice'].browse([id_header]) for factura in self.env['account.invoice'].browse(ids): doc = Document() doc1 = Document() res_sri = False vals_accinvws1 = {} print "Factura", factura.id t_comp = factura.type print "TIPO COMPROBANTE", t_comp if factura.state_factelectro == 'autorizado' or factura.type not in ( 'in_invoice'): continue if factura.state_factelectro not in ('autorizado', 'firmado'): # PARA INSTANCIAR OBJETO AUTORIZACION auth = self.env['account.authorization'].browse( [factura.deduction_id.authorization_id.id]) print "Autorizacion", auth secuencia = factura.deduction_id.number print "secuencia", secuencia #FECHA EMISION DE COMPROBANTE ELECTRONICO fechasf = factura.date_emision lfecha = fechasf.split('-') print "list fecha", lfecha fecha = lfecha[2] + "/" + lfecha[1] + "/" + lfecha[0] print "FECHA EMISION ELECTRONICA", fecha #FECHA EMISION FACTURA fechasfe = factura.date_invoice lfechae = fechasfe.split('-') print "list fecha factura", lfechae fechafact = lfechae[2] + "/" + lfechae[1] + "/" + lfechae[0] print "FECHA FACTURA", fechafact #DIRECCION CLIENTE/PROVEEDOR COMPROBANTE dfactu = factura.partner_id.street if dfactu: dfactu = self.delete_ascii(factura.partner_id.street) dfactu2 = factura.partner_id.street2 if dfactu2: dfactu2 = self.delete_ascii(factura.partner_id.street2) cmail = factura.partner_id.email if cmail: cliemail = cmail else: raise Warning( ('Atencion !'), ('Ingrese el Email del cliente en la ficha!')) if dfactu and dfactu2: dfactuf = str(dfactu) + " " + str(dfactu2) elif dfactu and not dfactu2: dfactuf = str(dfactu) elif dfactu2 and not dfactu: dfactuf = str(dfactu2) else: dfactuf = '' print "DIR FACTU", dfactuf t_comp = factura.type print "TIPO COMPROBANTE", t_comp cod_ident = factura.partner_id.cod_type_ident print "COD IDENT", cod_ident name_rzc = factura.partner_id.name id_rzc = factura.partner_id.part_number tot_simp = factura.amount_untaxed print "TOTAL SI", tot_simp invdet_des = self.env['account.invoice.line'].search([ ('invoice_id', '=', factura.id) ]) print "LISTA DETALLE DE LA FACTURA", invdet_des descuentt = 0 for det_fact in invdet_des: id_line = det_fact.id print "ID LINE", id_line if det_fact.discount > 0: descuentt += round( ((det_fact.price_unit * det_fact.quantity) * det_fact.discount) / 100, 2) else: descuentt = det_fact.discount #tot_desc = factura.amount_discount tot_desc = descuentt print "TOTAL DES", tot_desc #DIRECCION SUCURSAL EMITE COMPROBANTE id_pars = self.env['res.partner'].search([ ('ref', '=', 'COEBIT'), ('company_id', '=', self.env.user.company_id.id) ]) print "ID PART", id_pars.id id_pars_add = self.env['res.partner'].search([('id', '=', id_pars.id)]) if id_pars_add: d_suc1 = id_pars_add.street d_suc2 = id_pars_add.street2 if d_suc1 and d_suc2: dsucuf = str(d_suc1.encode('UTF-8')) + " " + str( d_suc2.encode('UTF-8')) elif d_suc1 and not d_suc2: dsucuf = str(d_suc1.encode('UTF-8')) elif d_suc2 and not d_suc1: dsucuf = str(d_suc2.encode('UTF-8')) else: dsucuf = '' else: raise Warning( ('Atencion !'), ('Ingrese Informacion de la sucursal CALLE1/CALLE2')) print "DIRECCION SUCUR", dsucuf if factura.partner_id.obli_contab: obli_contab = factura.partner_id.obli_contab if obli_contab == 'SI': cod_posfis = factura.partner_id.cod_posfis else: cod_posfis = '000' else: raise Warning(('Atencion !'), ( 'Ingrese Informacion Fiscal en la ficha del cliente/proveedor!' )) if factura.is_inv_elect: fent = factura.emission_point femi = factura.emission_series else: if factura.authorization_id.serie_entity: fent = str( factura.authorization_id.serie_entity).strip() print "ENTIDAD", fent else: raise Warning(('Atencion !'), ('Ingrese Serie entidad de la factura!')) if factura.authorization_id.serie_emission: femi = str( factura.authorization_id.serie_emission).strip() print "EMISION", femi else: raise Warning(('Atencion !'), ('Ingrese Serie emision de la factura!')) #******************************************************************************************************** if factura.deduction_id.authorization_id.serie_entity: fentp = str(factura.deduction_id.authorization_id. serie_entity).strip() else: raise Warning(('Atencion !'), ( 'Ingrese Serie entidad proveedor para emitir su comprobante!' )) if factura.deduction_id.authorization_id.serie_emission: femip = str(factura.deduction_id.authorization_id. serie_emission).strip() else: raise Warning(('Atencion !'), ( 'Ingrese Serie emision proveedor para emitir su comprobante!' )) if factura.number_seq: comprobante_n = str(factura.number_seq).strip() else: raise Warning(('Atencion !'), ( 'Ingrese Numero de comprobante sustento de esta retencion!' )) cod_ds = factura.document_type.code # OBTENER DATOS DE LOS IMPUESTOS tax_id = self.env['account.invoice.tax'].search([ ('invoice_id', '=', factura.id), ('deduction_id', '=', False) ]) print "LISTA IMPUESTOS", tax_id for imp in tax_id: print "LISTA IMPUESTOS 1", imp.tax_code_id print "LISTA IMPUESTOS 2", imp.tax_code_id.cod_imp_fe # OBTENER DATOS DE LAS RETENCIONES ret_id = self.env['account.invoice.tax'].search([ ('invoice_id', '=', factura.id), ('deduction_id', '!=', False) ]) print "LISTA RETENCIONES", ret_id for rett in ret_id: print "LISTA IMPUESTOS 1", rett.tax_code_id print "LISTA IMPUESTOS 2", rett.tax_code_id.cod_imp_fe ret_det = self.env['account.invoice.tax'].browse(ret_id) # OBTENER DATOS DETALLE DE LA FACTURA invdet_id = self.env['account.invoice.line'].search([ ('invoice_id', '=', factura.id) ]) print "LISTA DETALLE DE LA FACTURA", invdet_id invdet_det = self.env['account.invoice.line'].browse(invdet_id) print "OBJETO LINE DETALLADO", invdet_det cod_comp = '07' # OBTENGO DATOS DEL FORM version = record.version print "version: ", version compania = record.company print "compania: ", compania # Obtener Informacion de la compania lineas = self.env['res.company'].browse([compania.id])[0] empresa = lineas.partner_id.name ruc_empresa = lineas.partner_id.part_number user = self.env.user print "USER**", user direccion = '' if user.company_id.partner_id.street and user.company_id.partner_id.street2: direccion = str( user.company_id.partner_id.street) + ' Y ' + str( user.company_id.partner_id.street2) elif user.company_id.partner_id.street and not user.company_id.partner_id.street2: direccion = str(user.company_id.partner_id.street) elif user.company_id.partner_id.street2 and not user.company_id.partner_id.street: direccion = str(user.company_id.partner_id.street2) print "direccion", direccion if id_formulario == 'normal': temision = '1' # FORMAR CLAVE ACCESO COMPROBANTE NORMAL clav = str(lfecha[2] + lfecha[1] + lfecha[0] + cod_comp + ruc_empresa.strip() + ambiente + fentp + femip + secuencia.strip() + cod_num + temision) clavea = self.modulo11(clav) print "CLAVE MOD 11", clavea clavef = clav.strip() + clavea.strip() print "CLAVE FINAL N", clavef ids_accfacel = self.env['account.factura.electronica'] vals_r = { 'name': 'Comprobante Retencion', 'clave_acceso': clavef, 'cod_comprobante': cod_comp, 'factelect_id': factura.id } # accfactelect_id = ids_accfacel.create(cr,uid,vals_r) elif id_formulario == 'contingencia': temision = '2' cconti = record.contingencia if len(cconti) < 37: raise Warning(('Atencion !'), ( 'Clave de contingencia debe tener 37 caracteres numericos!' )) else: # FORMAR CLAVE ACCESO COMPROBANTE CONTINGENCIA clav = str(lfecha[2] + lfecha[1] + lfecha[0] + cod_comp + cconti.strip() + temision) clavea = self.modulo11(clav) print "CLAVE MOD 11", clavea clavef = clav.strip() + clavea.strip() print "CLAVE FINAL C", clavef ids_accfacel = self.env['account.factura.electronica'] vals_r = { 'name': 'Comprobante Retencion', 'clave_contingencia': cconti, 'contingencia': True, 'cod_comprobante': cod_comp, 'factelect_id': factura.id } # accfactelect_id = ids_accfacel.create(cr,uid,vals_r) # TAG CONTENEDOR COMPROBANTE mainform = doc.createElement('comprobanteRetencion') doc.appendChild(mainform) mainform.setAttribute('id', 'comprobante') mainform.setAttribute('version', version) # TAGS HIJOS DEL CONTENEDOR COMPROBANTE infoTributaria = doc.createElement("infoTributaria") mainform.appendChild(infoTributaria) infoFactura = doc.createElement("infoCompRetencion") mainform.appendChild(infoFactura) impuestos = doc.createElement("impuestos") mainform.appendChild(impuestos) infoAdicional = doc.createElement("infoAdicional") mainform.appendChild(infoAdicional) # TAGS HIJOS DEL TAG INFOTRIBUTARIA ambiente_id = doc.createElement("ambiente") infoTributaria.appendChild(ambiente_id) nambiente_id = doc.createTextNode(ambiente.strip()) ambiente_id.appendChild(nambiente_id) tipoemi_id = doc.createElement("tipoEmision") infoTributaria.appendChild(tipoemi_id) ntipoemi_id = doc.createTextNode(temision.strip()) tipoemi_id.appendChild(ntipoemi_id) social = doc.createElement("razonSocial") infoTributaria.appendChild(social) psocial = doc.createTextNode(empresa.rstrip()) social.appendChild(psocial) comercial = doc.createElement("nombreComercial") infoTributaria.appendChild(comercial) pcomercial = doc.createTextNode(empresa.rstrip()) comercial.appendChild(pcomercial) ruc = doc.createElement("ruc") infoTributaria.appendChild(ruc) pruc = doc.createTextNode(ruc_empresa.rstrip()) ruc.appendChild(pruc) clave = doc.createElement("claveAcceso") infoTributaria.appendChild(clave) nclave_id = doc.createTextNode(clavef.strip()) clave.appendChild(nclave_id) codoc = doc.createElement("codDoc") infoTributaria.appendChild(codoc) ncodoc_id = doc.createTextNode(cod_comp.strip()) codoc.appendChild(ncodoc_id) estab = doc.createElement("estab") infoTributaria.appendChild(estab) nestab_id = doc.createTextNode(fentp.strip()) estab.appendChild(nestab_id) ptoemi = doc.createElement("ptoEmi") infoTributaria.appendChild(ptoemi) nptoemi_id = doc.createTextNode(femip.strip()) ptoemi.appendChild(nptoemi_id) secuencial = doc.createElement("secuencial") infoTributaria.appendChild(secuencial) nsecuencial_id = doc.createTextNode(secuencia.strip()) secuencial.appendChild(nsecuencial_id) dirmatr = doc.createElement("dirMatriz") infoTributaria.appendChild(dirmatr) ndirmatr_id = doc.createTextNode(direccion.strip()) dirmatr.appendChild(ndirmatr_id) # TAGS HIJOS DEL TAG INFOFACTURA femision = doc.createElement("fechaEmision") infoFactura.appendChild(femision) nfemision_id = doc.createTextNode(fecha.strip()) femision.appendChild(nfemision_id) destable = doc.createElement("dirEstablecimiento") infoFactura.appendChild(destable) ndestable_id = doc.createTextNode(dsucuf.strip()) destable.appendChild(ndestable_id) contesp = doc.createElement("contribuyenteEspecial") infoFactura.appendChild(contesp) ncontesp_id = doc.createTextNode(cod_posfis.strip()) contesp.appendChild(ncontesp_id) oblicont = doc.createElement("obligadoContabilidad") infoFactura.appendChild(oblicont) noblicont_id = doc.createTextNode(obli_contab.strip()) oblicont.appendChild(noblicont_id) tidencomp = doc.createElement( "tipoIdentificacionSujetoRetenido") infoFactura.appendChild(tidencomp) ntidencomp_id = doc.createTextNode(cod_ident.strip()) tidencomp.appendChild(ntidencomp_id) rasocomp = doc.createElement("razonSocialSujetoRetenido") infoFactura.appendChild(rasocomp) nrasocomp_id = doc.createTextNode(name_rzc.strip()) rasocomp.appendChild(nrasocomp_id) identcomp = doc.createElement("identificacionSujetoRetenido") infoFactura.appendChild(identcomp) nidentcomp_id = doc.createTextNode(id_rzc.strip()) identcomp.appendChild(nidentcomp_id) pfiscal = doc.createElement("periodoFiscal") infoFactura.appendChild(pfiscal) npfiscal_id = doc.createTextNode(str(factura.period_id.code)) pfiscal.appendChild(npfiscal_id) for impuesto in ret_id: print "RET COD1", impuesto print "RET COD2", impuesto.tax_code_id print "RET COD3", impuesto.tax_code_id.cod_imp_fe if impuesto.tax_code_id.cod_imp_fe == '1': cod_retfe = impuesto.base_code_id.code if cod_retfe: print "ok retencion" else: raise Warning(('Atencion !'), ( 'No hay configurado codigo base de la retencion de esta factura!' )) else: cod_retfe = impuesto.tax_code_id.cod_tarifa if cod_retfe: print "ok retencion" else: raise Warning(('Atencion !'), ( "No hay configurado codigo tarifa en impuestos codigos '%s' !" ) % str(impuesto.tax_code_id.name)) totalimp = doc.createElement("impuesto") impuestos.appendChild(totalimp) # TAG SE REPITE CODIGO IMPUESTOS SEGUN LA FACTURA fcodigo = doc.createElement("codigo") totalimp.appendChild(fcodigo) nfcodigo_id = doc.createTextNode( impuesto.tax_code_id.cod_imp_fe) fcodigo.appendChild(nfcodigo_id) codpor = doc.createElement("codigoRetencion") totalimp.appendChild(codpor) ncodpor_id = doc.createTextNode(cod_retfe) codpor.appendChild(ncodpor_id) basimp = doc.createElement("baseImponible") totalimp.appendChild(basimp) vbaseimp = Decimal(abs(impuesto.base_amount)).quantize( Decimal('0.00')) nbasimp_id = doc.createTextNode(str(vbaseimp)) basimp.appendChild(nbasimp_id) dtarifa = doc.createElement("porcentajeRetener") totalimp.appendChild(dtarifa) v_tar_imp = Decimal(impuesto.tax_code_id.tarifa).quantize( Decimal('0.00')) ndtarifa_id = doc.createTextNode(str(v_tar_imp)) dtarifa.appendChild(ndtarifa_id) fvalor = doc.createElement("valorRetenido") totalimp.appendChild(fvalor) vamount = Decimal(abs(impuesto.amount)).quantize( Decimal('0.00')) nfvalor_id = doc.createTextNode(str(vamount)) fvalor.appendChild(nfvalor_id) cdm = doc.createElement("codDocSustento") totalimp.appendChild(cdm) ncdm_id = doc.createTextNode(cod_ds.strip()) cdm.appendChild(ncdm_id) ndm = doc.createElement("numDocSustento") totalimp.appendChild(ndm) nndm_id = doc.createTextNode( str(femi + fent + comprobante_n).strip()) ndm.appendChild(nndm_id) feds = doc.createElement("fechaEmisionDocSustento") totalimp.appendChild(feds) nfeds_id = doc.createTextNode(fecha.strip()) feds.appendChild(nfeds_id) cadicional = doc.createElement('campoAdicional') infoAdicional.appendChild(cadicional) cadicional.setAttribute('nombre', 'mail') cadicional_id = doc.createTextNode(cliemail) cadicional.appendChild(cadicional_id) cadicional1 = doc.createElement('campoAdicional') infoAdicional.appendChild(cadicional1) cadicional1.setAttribute('nombre', 'Direccion') cadicional_id1 = doc.createTextNode(dfactuf) cadicional1.appendChild(cadicional_id1) print "DOC**", doc out = base64.encodestring(doc.toxml()) name = "%s.xml" % (clavef) record.name = name print "NOMBRE COMPROBANTE GUARDAR", name record.data = out f = open( '/home/oddo/' + firmadig + '/' + 'FACTURA_ELECTRONICA/FACTURASF/' + name, 'w') f.write(doc.toxml()) f.close() #********************************************************************************************************** if firmadig == 'MISSION PETROLEUM S.A.': print "ENTRO MISSION PETROLEUM S.A." res = jarWrapper( '/opt/addons_mission/o2s_felectronica/wizard/XadesBes.jar', '/opt/addons_mission/o2s_felectronica/wizard/' + firmadig + '/' + 'firmaMissionPetroleum2018.p12', 'mission2020', '/home/oddo/' + firmadig + '/' + 'FACTURA_ELECTRONICA/FACTURASF/' + name, '/home/oddo/' + firmadig + '/' + 'FACTURA_ELECTRONICA/FACTURAF', name) print "RES", res w = open( '/home/oddo/' + firmadig + '/' + 'FACTURA_ELECTRONICA/FACTURAF/' + name, 'rb') q = w.read() #*********************************************************************************************************** res_sri = client.service.validarComprobante( base64.encodestring(q)) # print "RESPUESTA*****", res_sri # print "ESTADO*****", res_sri[0] #CSV: AUMENTO PARA EL CASO DE SOLO CONSULTAR if factura.state_factelectro == 'firmado': clavef = factura.num_autoreten print "factura.num_autoreten", factura.num_autoreten print "factura.state_factelectro", factura.state_factelectro autorizada = 0 while autorizada != 1: res_autcomp = client1.service.autorizacionComprobante( clavef) # print "OBJETO AUTORIZA1***", res_autcomp # print "TIPO RESPUESTA", type(res_autcomp) # print "TAMAÑO RESPUESTA", len(res_autcomp) # print "OBJETO autorizaciones***", res_autcomp.autorizaciones # print "TIPO autorizaciones", type(res_autcomp.autorizaciones) # print "TAMAÑO autorizaciones", len(res_autcomp.autorizaciones) if len(res_autcomp.autorizaciones) > 0: if len(res_autcomp.autorizaciones.autorizacion[0]) > 0: estado_ws = res_autcomp.autorizaciones.autorizacion[ 0]['estado'] print "estado_ws", estado_ws autorizada = 1 if str(estado_ws).strip() == 'AUTORIZADO': #******************************XML ENVIO POR MAIL CLIENTE************************* numaut_ws = res_autcomp.autorizaciones.autorizacion[ 0]['numeroAutorizacion'] print "numaut_ws", numaut_ws fechaut_ws = res_autcomp.autorizaciones.autorizacion[ 0]['fechaAutorizacion'] print "fechaut_ws", fechaut_ws if ambiente == '2': ambiente_ws = 'PRODUCCION' elif ambiente == '1': ambiente_ws = 'PRUEBAS' print "ambiente_ws", ambiente_ws comprobante_ws = res_autcomp.autorizaciones.autorizacion[ 0]['comprobante'] #print "comprobante", comprobante # TAGS XML ENVIO POR MAIL AL CLIENTE autorizacion = doc1.createElement( 'autorizacion') doc1.appendChild(autorizacion) # TAGS HIJOS DEL TAG AUTORIZACION estado = doc1.createElement("estado") autorizacion.appendChild(estado) naestado_id = doc.createTextNode( str(estado_ws).strip()) estado.appendChild(naestado_id) numaut = doc1.createElement( "numeroAutorizacion") autorizacion.appendChild(numaut) nanumaut_id = doc.createTextNode( str(numaut_ws).strip()) numaut.appendChild(nanumaut_id) fechaut = doc1.createElement( "fechaAutorizacion") autorizacion.appendChild(fechaut) nafechaut_id = doc.createTextNode( str(fechaut_ws).strip()) fechaut.appendChild(nafechaut_id) ambienteaut = doc1.createElement("ambiente") autorizacion.appendChild(ambienteaut) naambienteaut_id = doc.createTextNode( str(ambiente_ws).strip()) ambienteaut.appendChild(naambienteaut_id) comprobanteaut = doc1.createElement( "comprobante") autorizacion.appendChild(comprobanteaut) nacomprobanteaut_id = doc.createTextNode( str(comprobante_ws).strip()) comprobanteaut.appendChild(nacomprobanteaut_id) out1 = base64.encodestring(doc1.toxml()) data_fname = "%s.xml" % (clavef) f1 = open( '/home/oddo/' + firmadig + '/' + 'FACTURA_ELECTRONICA/AUTORIZADO/' + data_fname, 'w') f1.write(doc1.toxml()) f1.close() #CSV 07-06-2017 PARA ADJUNTARLO************************ archivo = '/home/oddo/' + firmadig + '/' + 'FACTURA_ELECTRONICA/AUTORIZADO/' + data_fname res_model = 'account.invoice' id = ids and type(ids) == type( []) and ids[0] or ids self.load_doc(out1, factura.id, data_fname, archivo, res_model) #************************************************************************************** num_aut = res_autcomp.autorizaciones.autorizacion[ 0]['numeroAutorizacion'] #ids_atracci = self.env['account.invoice'] vals_accinv = { 'num_autoreten': num_aut, 'state_factelectro': 'autorizado', 'date_aut': time.strftime('%Y-%m-%d %H:%M:%S'), 'inf_electronica': 'autorizado' } factura.write(vals_accinv) #accfactelect_id = ids_accfacel.create(vals_r) mensaje = str(estado_ws) record.mensaje = mensaje else: if res_autcomp.autorizaciones.autorizacion[-1][ 'estado'] == 'AUTORIZADO': num_aut = res_autcomp.autorizaciones.autorizacion[ -1]['numeroAutorizacion'] #ids_atracci = self.env['account.invoice'] vals_accinv = { 'num_autoreten': num_aut, 'state_factelectro': 'autorizado', 'date_aut': time.strftime('%Y-%m-%d %H:%M:%S'), 'inf_electronica': 'autorizado' } factura.write(vals_accinv) #accfactelect_id = ids_accfacel.create(vals_r) mensaje = str(res_autcomp.autorizaciones. autorizacion[-1]['estado']) record.mensaje = mensaje else: mensaje = str(res_autcomp) record.mensaje = mensaje vals_inf_elect = { 'inf_electronica': mensaje } factura.write(vals_inf_elect) #print "MENSAJE", mensaje if res_sri and res_sri['estado'] == 'RECIBIDA': #CSV:29-12-2017: AUMENTO PARA ENVIAR ARCHIVO FIRMADO CLIENTE Y SRI PRIMER WEB SERVICES #CSV: PARA ADJUNTARLO************************ w = open( '/home/oddo/' + firmadig + '/' + 'FACTURA_ELECTRONICA/FACTURAF/' + name, 'rb') q = w.read() out2 = base64.encodestring(q) data_fname = name archivo = '/home/oddo/' + firmadig + '/' + 'FACTURA_ELECTRONICA/FACTURAF/' + name res_model = 'account.invoice' id = ids and type(ids) == type([]) and ids[0] or ids self.load_doc(out2, factura.id, data_fname, archivo, res_model) #Escribo en la factura* num_autws1 = clavef #ids_atracci = self.env['account.invoice'] val_aut = {'name': num_autws1} auth.write(val_aut) vals_accinvws1 = { 'num_autoreten': num_autws1, 'state_factelectro': 'firmado', 'date_aut': time.strftime('%Y-%m-%d %H:%M:%S'), 'inf_electronica': 'firmado' } factura.write(vals_accinvws1) accfactelect_id = ids_accfacel.create(vals_r) mensaje = str('firmado') record.mensaje = mensaje elif res_sri and res_sri['estado'] == 'DEVUELTA': mensaje = str(res_sri) record.mensaje = mensaje vals_inf_elect = {'inf_electronica': mensaje} factura.write(vals_inf_elect) print "NO SE ENVIO" return True
# Group messages by rule_type for rule_type, messages_by_ruletype in groupby(messages, lambda msg: msg['rule_type']): for rule, messages_by_rule in groupby(messages_by_ruletype, lambda msg: msg['alias'] if msg['alias'] else msg['rule']): testcase = doc.createElement("testcase") testcase.setAttribute("name", rule) testcase.setAttribute("classname", rule_type) failure = doc.createElement("failure") # Generate an ASCII table from the collected messages header = "{: <10s} {: <17s} {: <37s}".format("Severity", "File", "Message").rstrip() body = [] for msg in messages_by_rule: severity = msg['severity'] for severity, file, message in zip_longest(wrap(msg['severity'], 10), wrap(msg['file']+", line "+msg['line'], 17), wrap(msg['message'], 37), fillvalue=""): body.append("{: <10s} {: <17s} {: <37s}".format(severity, file, message).rstrip()) body.append("") content_text ="\n".join([header, "-"*70, *body]) content = doc.createTextNode(content_text) failure.appendChild(content) testcase.appendChild(failure) testsuite.appendChild(testcase) doc.appendChild(testsuite) print(doc.toprettyxml()) sys.exit(1 if nr_of_failures and args.fail_on_error else 0) except Exception as e: # parser.error("Failed to parse the report. Error: {}".format(e)) raise e
if (value != None): if (isinstance(value, Bag)): if (key == "Authors"): authors = "" if (isinstance(value.Author, list)): for author in value.Author: authors += author + "; " else: authors += value.Author fieldElement = doc.createElement("field") fieldElement.setAttribute("name", "authors") textElement = doc.createTextNode(authors) fieldElement.appendChild(textElement) bookElement.appendChild(fieldElement) elif (key == "Reviews"): fieldElement = doc.createElement("field") fieldElement.setAttribute("name", "hasreviews") textElement = doc.createTextNode("true") fieldElement.appendChild(textElement) bookElement.appendChild(fieldElement) if (isinstance(value.CustomerReview, list)): for review in value.CustomerReview: fieldElement = doc.createElement("field") fieldElement.setAttribute("name", "Review")
def saveXML(self): if self.rawdata: root = self.rawdata.getElementsByTagName('ComicInfo')[0] for row in (['Series', self.data['Series']], ['Volume', self.data['Volume']], ['Number', self.data['Number'] ], ['Writer', ', '.join(self.data['Writers'])], ['Penciller', ', '.join(self.data['Pencillers']) ], ['Inker', ', '.join(self.data['Inkers'])], ['Colorist', ', '.join(self.data['Colorists']) ], ['Summary', self.data['Summary']], [ 'ScanInformation', 'MCD(' + self.data['MUid'] + ')' if self.data['MUid'] else '' ]): if self.rawdata.getElementsByTagName(row[0]): node = self.rawdata.getElementsByTagName(row[0])[0] if row[1]: node.firstChild.replaceWholeText(row[1]) else: root.removeChild(node) elif row[1]: main = self.rawdata.createElement(row[0]) root.appendChild(main) text = self.rawdata.createTextNode(row[1]) main.appendChild(text) else: doc = Document() root = doc.createElement('ComicInfo') root.setAttribute('xmlns:xsd', 'http://www.w3.org/2001/XMLSchema') root.setAttribute('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance') doc.appendChild(root) for row in (['Series', self.data['Series']], ['Volume', self.data['Volume']], ['Number', self.data['Number'] ], ['Writer', ', '.join(self.data['Writers'])], ['Penciller', ', '.join(self.data['Pencillers']) ], ['Inker', ', '.join(self.data['Inkers'])], ['Colorist', ', '.join(self.data['Colorists']) ], ['Summary', self.data['Summary']], [ 'ScanInformation', 'MCD(' + self.data['MUid'] + ')' if self.data['MUid'] else '' ]): if row[1]: main = doc.createElement(row[0]) root.appendChild(main) text = doc.createTextNode(row[1]) main.appendChild(text) self.rawdata = doc if self.source.endswith('.xml'): with open(self.source, 'w', encoding='utf-8') as f: self.rawdata.writexml(f, encoding='utf-8') else: workdir = mkdtemp('', 'KCC-') tmpXML = os.path.join(workdir, 'ComicInfo.xml') with open(tmpXML, 'w', encoding='utf-8') as f: self.rawdata.writexml(f, encoding='utf-8') if is_zipfile(self.source): removeFromZIP(self.source, 'ComicInfo.xml') with ZipFile(self.source, mode='a', compression=ZIP_DEFLATED) as zip_file: zip_file.write(tmpXML, arcname=tmpXML.split(os.sep)[-1]) elif rarfile.is_rarfile(self.source): raise NotImplementedError elif is_7zfile(self.source): output = Popen('7za a "' + self.source + '" "' + tmpXML + '"', stdout=PIPE, stderr=STDOUT, stdin=PIPE, shell=True) extracted = False for line in output.stdout: if b"Everything is Ok" in line: extracted = True if not extracted: rmtree(workdir) raise OSError('Failed to modify 7ZIP file.') rmtree(workdir)
class MathMLPrinter(Printer): """Prints an expression to the MathML markup language Whenever possible tries to use Content markup and not Presentation markup. References: https://www.w3.org/TR/MathML3/ """ printmethod = "_mathml" _default_settings = {"order": None, "encoding": "utf-8"} def __init__(self, settings=None): Printer.__init__(self, settings) from xml.dom.minidom import Document self.dom = Document() def doprint(self, expr): """ Prints the expression as MathML. """ mathML = Printer._print(self, expr) unistr = mathML.toxml() xmlbstr = unistr.encode('ascii', 'xmlcharrefreplace') res = xmlbstr.decode() return res def mathml_tag(self, e): """Returns the MathML tag for an expression.""" translate = { 'Add': 'plus', 'Mul': 'times', 'Derivative': 'diff', 'Number': 'cn', 'int': 'cn', 'Pow': 'power', 'Symbol': 'ci', 'Integral': 'int', 'Sum': 'sum', 'sin': 'sin', 'cos': 'cos', 'tan': 'tan', 'cot': 'cot', 'asin': 'arcsin', 'asinh': 'arcsinh', 'acos': 'arccos', 'acosh': 'arccosh', 'atan': 'arctan', 'atanh': 'arctanh', 'acot': 'arccot', 'atan2': 'arctan', 'log': 'ln', 'Equality': 'eq', 'Unequality': 'neq', 'GreaterThan': 'geq', 'LessThan': 'leq', 'StrictGreaterThan': 'gt', 'StrictLessThan': 'lt', } for cls in e.__class__.__mro__: n = cls.__name__ if n in translate: return translate[n] # Not found in the MRO set n = e.__class__.__name__ return n.lower() def _print_Mul(self, expr): if _coeff_isneg(expr): x = self.dom.createElement('apply') x.appendChild(self.dom.createElement('minus')) x.appendChild(self._print_Mul(-expr)) return x from sympy.simplify import fraction numer, denom = fraction(expr) if denom is not S.One: x = self.dom.createElement('apply') x.appendChild(self.dom.createElement('divide')) x.appendChild(self._print(numer)) x.appendChild(self._print(denom)) return x coeff, terms = expr.as_coeff_mul() if coeff is S.One and len(terms) == 1: # XXX since the negative coefficient has been handled, I don't # think a coeff of 1 can remain return self._print(terms[0]) if self.order != 'old': terms = Mul._from_args(terms).as_ordered_factors() x = self.dom.createElement('apply') x.appendChild(self.dom.createElement('times')) if (coeff != 1): x.appendChild(self._print(coeff)) for term in terms: x.appendChild(self._print(term)) return x def _print_Add(self, expr, order=None): args = self._as_ordered_terms(expr, order=order) lastProcessed = self._print(args[0]) plusNodes = [] for arg in args[1:]: if _coeff_isneg(arg): # use minus x = self.dom.createElement('apply') x.appendChild(self.dom.createElement('minus')) x.appendChild(lastProcessed) x.appendChild(self._print(-arg)) # invert expression since this is now minused lastProcessed = x if (arg == args[-1]): plusNodes.append(lastProcessed) else: plusNodes.append(lastProcessed) lastProcessed = self._print(arg) if (arg == args[-1]): plusNodes.append(self._print(arg)) if len(plusNodes) == 1: return lastProcessed x = self.dom.createElement('apply') x.appendChild(self.dom.createElement('plus')) while len(plusNodes) > 0: x.appendChild(plusNodes.pop(0)) return x def _print_MatrixBase(self, m): x = self.dom.createElement('matrix') for i in range(m.rows): x_r = self.dom.createElement('matrixrow') for j in range(m.cols): x_r.appendChild(self._print(m[i, j])) x.appendChild(x_r) return x def _print_Rational(self, e): if e.q == 1: # don't divide x = self.dom.createElement('cn') x.appendChild(self.dom.createTextNode(str(e.p))) return x x = self.dom.createElement('apply') x.appendChild(self.dom.createElement('divide')) # numerator xnum = self.dom.createElement('cn') xnum.appendChild(self.dom.createTextNode(str(e.p))) # denominator xdenom = self.dom.createElement('cn') xdenom.appendChild(self.dom.createTextNode(str(e.q))) x.appendChild(xnum) x.appendChild(xdenom) return x def _print_Limit(self, e): x = self.dom.createElement('apply') x.appendChild(self.dom.createElement(self.mathml_tag(e))) x_1 = self.dom.createElement('bvar') x_2 = self.dom.createElement('lowlimit') x_1.appendChild(self._print(e.args[1])) x_2.appendChild(self._print(e.args[2])) x.appendChild(x_1) x.appendChild(x_2) x.appendChild(self._print(e.args[0])) return x def _print_ImaginaryUnit(self, e): return self.dom.createElement('imaginaryi') def _print_EulerGamma(self, e): return self.dom.createElement('eulergamma') def _print_GoldenRatio(self, e): """We use unicode #x3c6 for Greek letter phi as defined here http://www.w3.org/2003/entities/2007doc/isogrk1.html""" x = self.dom.createElement('cn') x.appendChild(self.dom.createTextNode(u"\N{GREEK SMALL LETTER PHI}")) return x def _print_Exp1(self, e): return self.dom.createElement('exponentiale') def _print_Pi(self, e): return self.dom.createElement('pi') def _print_Infinity(self, e): return self.dom.createElement('infinity') def _print_Negative_Infinity(self, e): x = self.dom.createElement('apply') x.appendChild(self.dom.createElement('minus')) x.appendChild(self.dom.createElement('infinity')) return x def _print_Integral(self, e): def lime_recur(limits): x = self.dom.createElement('apply') x.appendChild(self.dom.createElement(self.mathml_tag(e))) bvar_elem = self.dom.createElement('bvar') bvar_elem.appendChild(self._print(limits[0][0])) x.appendChild(bvar_elem) if len(limits[0]) == 3: low_elem = self.dom.createElement('lowlimit') low_elem.appendChild(self._print(limits[0][1])) x.appendChild(low_elem) up_elem = self.dom.createElement('uplimit') up_elem.appendChild(self._print(limits[0][2])) x.appendChild(up_elem) if len(limits[0]) == 2: up_elem = self.dom.createElement('uplimit') up_elem.appendChild(self._print(limits[0][1])) x.appendChild(up_elem) if len(limits) == 1: x.appendChild(self._print(e.function)) else: x.appendChild(lime_recur(limits[1:])) return x limits = list(e.limits) limits.reverse() return lime_recur(limits) def _print_Sum(self, e): # Printer can be shared because Sum and Integral have the # same internal representation. return self._print_Integral(e) def _print_Symbol(self, sym): ci = self.dom.createElement(self.mathml_tag(sym)) def join(items): if len(items) > 1: mrow = self.dom.createElement('mml:mrow') for i, item in enumerate(items): if i > 0: mo = self.dom.createElement('mml:mo') mo.appendChild(self.dom.createTextNode(" ")) mrow.appendChild(mo) mi = self.dom.createElement('mml:mi') mi.appendChild(self.dom.createTextNode(item)) mrow.appendChild(mi) return mrow else: mi = self.dom.createElement('mml:mi') mi.appendChild(self.dom.createTextNode(items[0])) return mi # translate name, supers and subs to unicode characters greek_letters = set(greeks) # make a copy def translate(s): if s in greek_unicode: return greek_unicode.get(s) else: return s name, supers, subs = split_super_sub(sym.name) name = translate(name) supers = [translate(sup) for sup in supers] subs = [translate(sub) for sub in subs] mname = self.dom.createElement('mml:mi') mname.appendChild(self.dom.createTextNode(name)) if len(supers) == 0: if len(subs) == 0: ci.appendChild(self.dom.createTextNode(name)) else: msub = self.dom.createElement('mml:msub') msub.appendChild(mname) msub.appendChild(join(subs)) ci.appendChild(msub) else: if len(subs) == 0: msup = self.dom.createElement('mml:msup') msup.appendChild(mname) msup.appendChild(join(supers)) ci.appendChild(msup) else: msubsup = self.dom.createElement('mml:msubsup') msubsup.appendChild(mname) msubsup.appendChild(join(subs)) msubsup.appendChild(join(supers)) ci.appendChild(msubsup) return ci def _print_Pow(self, e): # Here we use root instead of power if the exponent is the reciprocal of an integer if e.exp.is_Rational and e.exp.p == 1: x = self.dom.createElement('apply') x.appendChild(self.dom.createElement('root')) if e.exp.q != 2: xmldeg = self.dom.createElement('degree') xmlci = self.dom.createElement('ci') xmlci.appendChild(self.dom.createTextNode(str(e.exp.q))) xmldeg.appendChild(xmlci) x.appendChild(xmldeg) x.appendChild(self._print(e.base)) return x x = self.dom.createElement('apply') x_1 = self.dom.createElement(self.mathml_tag(e)) x.appendChild(x_1) x.appendChild(self._print(e.base)) x.appendChild(self._print(e.exp)) return x def _print_Number(self, e): x = self.dom.createElement(self.mathml_tag(e)) x.appendChild(self.dom.createTextNode(str(e))) return x def _print_Derivative(self, e): x = self.dom.createElement('apply') diff_symbol = self.mathml_tag(e) if requires_partial(e): diff_symbol = 'partialdiff' x.appendChild(self.dom.createElement(diff_symbol)) x_1 = self.dom.createElement('bvar') for sym in e.variables: x_1.appendChild(self._print(sym)) x.appendChild(x_1) x.appendChild(self._print(e.expr)) return x def _print_Function(self, e): x = self.dom.createElement("apply") x.appendChild(self.dom.createElement(self.mathml_tag(e))) for arg in e.args: x.appendChild(self._print(arg)) return x def _print_Basic(self, e): x = self.dom.createElement(self.mathml_tag(e)) for arg in e: x.appendChild(self._print(arg)) return x def _print_AssocOp(self, e): x = self.dom.createElement('apply') x_1 = self.dom.createElement(self.mathml_tag(e)) x.appendChild(x_1) for arg in e.args: x.appendChild(self._print(arg)) return x def _print_Relational(self, e): x = self.dom.createElement('apply') x.appendChild(self.dom.createElement(self.mathml_tag(e))) x.appendChild(self._print(e.lhs)) x.appendChild(self._print(e.rhs)) return x def _print_list(self, seq): """MathML reference for the <list> element: http://www.w3.org/TR/MathML2/chapter4.html#contm.list""" dom_element = self.dom.createElement('list') for item in seq: dom_element.appendChild(self._print(item)) return dom_element def _print_int(self, p): dom_element = self.dom.createElement(self.mathml_tag(p)) dom_element.appendChild(self.dom.createTextNode(str(p))) return dom_element def apply_patch(self): # Applying the patch of xml.dom.minidom bug # Date: 2011-11-18 # Description: http://ronrothman.com/public/leftbraned/xml-dom-minidom-\ # toprettyxml-and-silly-whitespace/#best-solution # Issue: http://bugs.python.org/issue4147 # Patch: http://hg.python.org/cpython/rev/7262f8f276ff/ from xml.dom.minidom import Element, Text, Node, _write_data def writexml(self, writer, indent="", addindent="", newl=""): # indent = current indentation # addindent = indentation to add to higher levels # newl = newline string writer.write(indent + "<" + self.tagName) attrs = self._get_attributes() a_names = list(attrs.keys()) a_names.sort() for a_name in a_names: writer.write(" %s=\"" % a_name) _write_data(writer, attrs[a_name].value) writer.write("\"") if self.childNodes: writer.write(">") if (len(self.childNodes) == 1 and self.childNodes[0].nodeType == Node.TEXT_NODE): self.childNodes[0].writexml(writer, '', '', '') else: writer.write(newl) for node in self.childNodes: node.writexml(writer, indent + addindent, addindent, newl) writer.write(indent) writer.write("</%s>%s" % (self.tagName, newl)) else: writer.write("/>%s" % (newl)) self._Element_writexml_old = Element.writexml Element.writexml = writexml def writexml(self, writer, indent="", addindent="", newl=""): _write_data(writer, "%s%s%s" % (indent, self.data, newl)) self._Text_writexml_old = Text.writexml Text.writexml = writexml def restore_patch(self): from xml.dom.minidom import Element, Text Element.writexml = self._Element_writexml_old Text.writexml = self._Text_writexml_old