def write_2(glos, filename): from xml.sax.saxutils import XMLGenerator from xml.sax.xmlreader import AttributesNSImpl xdbFp = open(filename, 'wb') fp = XMLGenerator(xdbFp, 'utf-8') attrs = AttributesNSImpl({}, {}) fp.startElement('xfardic', attrs) for key, value in glos.iterInfo(): fp.startElement(key, attrs) fp.characters(value) fp.endElement(key) fp.endElement('xfardic') fp.startElement('words', attrs) for entry in glos: word = entry.getWord() defi = entry.getDefi() try: tmpXmlFile.characters(defi) except: log.exception('While writing xdb file, an error on word "%s":'%word) continue fp.startElement('word', attrs) fp.startElement('in', attrs) fp.characters(str(word)) fp.endElement('in') fp.startElement('out', attrs) fp.characters(str(defi)) fp.endElement('out') fp.endElement('words') fp.endDocument() xdbFp.close()
def encode(self, obj, root='root'): buf = StringIO() xml = XMLGenerator(buf, encoding='utf-8') xml.startDocument() self.encode_obj(xml, root, obj) xml.endDocument() return buf.getvalue()
class KanjiListToXmlFile: def __init__(self, filepath): self.file = open(filepath, "w+") self.handler = XMLGenerator(self.file, 'utf-8') self.handler.startDocument() self.handler.startElement('list', {}) def __del__(self): self.handler.endElement('list') self.handler.endDocument() def kanjiToXml(self, kanji): self.handler.startElement('character', {}) for el in kanji.element: if isinstance(kanji.element[el], unicode): self.handler.startElement(el, {}) self.handler.characters(kanji.element[el]) self.handler.endElement(el) elif isinstance(kanji.element[el], int): self.handler.startElement(el, {}) self.handler.characters(str(kanji.element[el])) self.handler.endElement(el) elif isinstance(kanji.element[el], list): for m in kanji.element[el]: self.handler.startElement(el, {}) self.handler.characters(m) self.handler.endElement(el) self.handler.endElement('character') self.file.write('\n') def kanjiListToXml(self, kanjiList): for kanji in kanjiList: self.kanjiToXml(kanji)
def test_5027_2(self): # The xml prefix (as in xml:lang below) is reserved and bound by # definition to http://www.w3.org/XML/1998/namespace. XMLGenerator had # a bug whereby a KeyError is thrown because this namespace is missing # from a dictionary. # # This test demonstrates the bug by direct manipulation of the # XMLGenerator. result = StringIO() gen = XMLGenerator(result) gen.startDocument() gen.startPrefixMapping('a', 'http://example.com/ns') gen.startElementNS(('http://example.com/ns', 'g1'), 'g1', {}) lang_attr = {('http://www.w3.org/XML/1998/namespace', 'lang'): 'en'} gen.startElementNS(('http://example.com/ns', 'g2'), 'g2', lang_attr) gen.characters('Hello') gen.endElementNS(('http://example.com/ns', 'g2'), 'g2') gen.endElementNS(('http://example.com/ns', 'g1'), 'g1') gen.endPrefixMapping('a') gen.endDocument() self.assertEqual(result.getvalue(), start + ( '<a:g1 xmlns:a="http://example.com/ns">' '<a:g2 xml:lang="en">Hello</a:g2>' '</a:g1>'))
class XmlLogger(object): def __init__(self, path): if os.access(path, os.F_OK): os.rename(path, path + '.bak-' + str(load_time)) self.output = open(path, 'w') self.xml_gen = XMLGenerator(self.output, 'utf-8') self.lock = RLock() def start_log(self, tag, attributes): self.doc_tag = tag with self.lock: self.xml_gen.startDocument() self.xml_gen.startElement(tag, attributes) def end_log(self): with self.lock: self.xml_gen.endElement(self.doc_tag) self.xml_gen.endDocument() @contextmanager def element(self, name, attrs={}): with self.lock: attrs = dict((key, str(value)) for key, value in attrs.items()) self.text('\n') self.xml_gen.startElement(name, attrs) yield self.xml_gen.endElement(name) def text(self, text): with self.lock: self.xml_gen.characters(str(text))
def save(self, filename=None): if self.filename and filename is None: filename = self.filename if len(self.__dict__) == 0 or filename == None: return try: fileobj = open(filename, 'w') except: print 'ERROR>>> cannot write preferences into %s' % filename return writer = XMLGenerator(out=fileobj, encoding=self.system_encoding) writer.startDocument() defaults = XmlConfigParser.__dict__ items = self.__dict__.items() items.sort() writer.startElement('preferences', {}) writer.characters('\n') for key, value in items: if defaults.has_key(key) and defaults[key] == value: continue if key in ['filename', 'app']: continue writer.characters('\t') writer.startElement('%s' % key, {}) str_value = path_unicode(value.__str__()) if isinstance(value, str): str_value = "'%s'" % (escape_quote(str_value)) writer.characters(str_value) writer.endElement('%s' % key) writer.characters('\n') writer.endElement('preferences') writer.endDocument() fileobj.close
def unparse(input_dict, output=None, encoding='utf-8', full_document=True, **kwargs): """Emit an XML document for the given `input_dict` (reverse of `parse`). The resulting XML document is returned as a string, but if `output` (a file-like object) is specified, it is written there instead. Dictionary keys prefixed with `attr_prefix` (default=`'@'`) are interpreted as XML node attributes, whereas keys equal to `cdata_key` (default=`'#text'`) are treated as character data. The `pretty` parameter (default=`False`) enables pretty-printing. In this mode, lines are terminated with `'\n'` and indented with `'\t'`, but this can be customized with the `newl` and `indent` parameters. """ if full_document and len(input_dict) != 1: raise ValueError('Document must have exactly one root.') must_return = False if output is None: output = StringIO() must_return = True content_handler = XMLGenerator(output, encoding) if full_document: content_handler.startDocument() for key, value in input_dict.items(): _emit(key, value, content_handler, full_document=full_document, **kwargs) if full_document: content_handler.endDocument() if must_return: value = output.getvalue() try: # pragma no cover value = value.decode(encoding) except AttributeError: # pragma no cover pass return value
def test_conditional_formatting_update(self): class WS(): conditional_formatting = ConditionalFormatting() worksheet = WS() rules = {'A1:A4': [{'type': 'colorScale', 'priority': 13, 'colorScale': {'cfvo': [{'type': 'min'}, {'type': 'max'}], 'color': [Color('FFFF7128'), Color('FFFFEF9C')]}}]} worksheet.conditional_formatting.update(rules) temp_buffer = StringIO() doc = XMLGenerator(out=temp_buffer, encoding='utf-8') write_worksheet_conditional_formatting(doc, worksheet) doc.endDocument() xml = temp_buffer.getvalue() temp_buffer.close() diff = compare_xml(xml, """ <conditionalFormatting sqref="A1:A4"> <cfRule type="colorScale" priority="1"> <colorScale> <cfvo type="min" /> <cfvo type="max" /> <color rgb="FFFF7128" /> <color rgb="FFFFEF9C" /> </colorScale> </cfRule> </conditionalFormatting> """) assert diff is None, diff
def manifest_xml(f, files): from xml.sax.saxutils import XMLGenerator xml = XMLGenerator(f, "utf-8") xml.startDocument() uri = "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0" prefix = "manifest" xml.startPrefixMapping(prefix, uri) def startElement(name, attrs): attrs = dict(((uri, n), v) for n, v in attrs.iteritems()) xml.startElementNS((uri, name), prefix + ":" + name, attrs) def endElement(name): xml.endElementNS((uri, name), prefix + ":" + name) def file_entry(full_path, media_type, **kwargs): attrs = {"media-type": media_type, "full-path": full_path} attrs.update(dict((n.replace("_", "-"), v) for n, v in kwargs.iteritems())) startElement("file-entry", attrs) endElement("file-entry") startElement("manifest", dict(version="1.2")) file_entry("/", "application/vnd.oasis.opendocument.text", version="1.2") for e in files: e = dict(e) full_path = e.pop("full_path") media_type = e.pop("media_type", "application/octet-stream") file_entry(full_path, media_type) endElement("manifest") xml.endPrefixMapping(prefix) xml.endDocument()
class XMLTweets(): ns = "http://www.milowski.com/twitter" out = None xml = None def open(self,filename): self.out = open(filename,"w") self.xml = XMLGenerator(self.out,"utf-8") self.xml.startDocument() self.xml.startPrefixMapping("",self.ns) self.xml.startElementNS((self.ns,"tweets"),"tweets",{}) self.xml.characters("\n") def tweet(self,tweet): self.xml.startElementNS((self.ns,"tweet"),"tweet",{(None,"alias"):tweet.user.screen_name, (None,"created"): tweet.created_at.strftime("%Y-%m-%dT%H-%M-%SZ")}) self.xml.characters(tweet.text) self.xml.endElementNS((self.ns,"tweet"),"tweet") self.xml.characters("\n") def close(self): if self.out != None: self.xml.endElementNS((self.ns,"tweets"),"tweets") self.xml.endDocument() self.out.close() self.xml = None self.out = None
class XmlWriter(AbstractXmlWriter): def __init__(self, path): self.path = path self._output = open(path, 'wb') self._writer = XMLGenerator(self._output, 'UTF-8') self._writer.startDocument() self.closed = False def start(self, name, attributes={}, newline=True): attrs = AttributesImpl(attributes) self._writer.startElement(name, attrs) if newline: self.content('\n') def content(self, content): if content is not None: self._writer.characters(self._encode(content)) def end(self, name, newline=True): self._writer.endElement(name) if newline: self.content('\n') def close(self): self._writer.endDocument() self._output.close() self.closed = True
def unparse(input_dict, output=None, encoding='utf-8', full_document=True, **kwargs): """ dict(json)转xml格式 :param input_dict: :param output: :param encoding: :param full_document: :param kwargs: :return: """ if full_document and len(input_dict) != 1: raise ValueError('Document must have exactly one root.') must_return = False if output is None: output = StringIO() must_return = True content_handler = XMLGenerator(output, encoding) if full_document: content_handler.startDocument() for k, v in input_dict.items(): _emit(k, v, content_handler, full_document=full_document, **kwargs) if full_document: content_handler.endDocument() if must_return: rep_value = output.getvalue() try: rep_value = rep_value.decode(encoding) except AttributeError: pass return rep_value
def main(): optparser = optparse.OptionParser(usage="Usage: %prog [options] POFILE ...") optparser.add_option("-r", "--roundtrip", help="generate round-tripable output", action="store_true", dest="roundtrip", default=False) optparser.add_option("-o", "--output", help="write output to XMLFILE", metavar="XMLFILE", action="store", dest="output", default="-") (options, args) = optparser.parse_args() if options.output == "-": output = sys.stdout else: output = open(options.output, "w") writer = XMLGenerator(output or sys.stdout, "utf-8") writer.startDocument() writer.processingInstruction("xml-stylesheet", 'type="text/xsl" href="format-html.xsl"') writer.ignorableWhitespace("\n") writer.startElement("messages", {}) writer.ignorableWhitespace("\n") msg = Message(writer, options.roundtrip) for l in fileinput.input(args): # Continuation string? m = re.match(r'\s*"(.*)"', l) if m: assert(msg.current) msg.current.append(unescape_c(m.group(1))) continue else: msg.flush() m = re.match(r'(?s)msgid "(.*)"', l) if m: msg.msgid = [unescape_c(m.group(1))] msg.current = msg.msgid m = re.match(r'(?s)msgstr "(.*)"', l) if m: msg.msgstr = [unescape_c(m.group(1))] msg.current = msg.msgstr m = re.match(r'# \s*(.*)', l) if m: msg.usrcomment.append(m.group(1)) m = re.match(r'#\.\s*(.*)', l) if m: msg.dotcomment.append(m.group(1)) m = re.match(r'#:\s*(.*)', l) if m: msg.reference.append(m.group(1)) m = re.match(r'#,\s*(.*)', l) if m: msg.flags.append(m.group(1)) msg.flush() writer.endElement("messages") writer.ignorableWhitespace("\n") writer.endDocument()
def manifest_xml(f, files): from xml.sax.saxutils import XMLGenerator xml = XMLGenerator(f, 'utf-8') xml.startDocument() uri = 'urn:oasis:names:tc:opendocument:xmlns:manifest:1.0' prefix = 'manifest' xml.startPrefixMapping(prefix, uri) def startElement(name, attrs): attrs = dict( ((uri, n), v) for n, v in attrs.iteritems() ) xml.startElementNS( (uri, name), prefix+':'+name, attrs) def endElement(name): xml.endElementNS( (uri, name), prefix+':'+name) def file_entry(full_path, media_type, **kwargs): attrs = {'media-type': media_type, 'full-path': full_path} attrs.update(dict((n.replace('_', '-'), v) for n, v in kwargs.iteritems())) startElement('file-entry', attrs) endElement('file-entry') startElement( 'manifest', dict(version='1.2') ) file_entry('/', 'application/vnd.oasis.opendocument.text', version='1.2') for e in files: e = dict(e) full_path = e.pop('full_path') media_type = e.pop('media_type', 'application/octet-stream') file_entry(full_path, media_type) endElement( 'manifest' ) xml.endPrefixMapping(prefix) xml.endDocument()
class XmlItemExporter(BaseItemExporter): def __init__(self, file, **kwargs): self.item_element = kwargs.pop('item_element', 'item') self.root_element = kwargs.pop('root_element', 'items') self._configure(kwargs) self.xg = XMLGenerator(file, encoding=self.encoding) def start_exporting(self): self.xg.startDocument() self.xg.startElement(self.root_element, {}) def export_item(self, item): self.xg.startElement(self.item_element, {}) for name, value in self._get_serialized_fields(item, default_value=''): self._export_xml_field(name, value) self.xg.endElement(self.item_element) def finish_exporting(self): self.xg.endElement(self.root_element) self.xg.endDocument() def _export_xml_field(self, name, serialized_value): self.xg.startElement(name, {}) if hasattr(serialized_value, '__iter__'): for value in serialized_value: self._export_xml_field('value', value) else: self.xg.characters(serialized_value) self.xg.endElement(name)
class XmlFormat(ModelEventHandler): def __init__(self, out): self.xmlgen = XMLGenerator(out, 'utf-8') def startDocument(self): self.xmlgen.startDocument() def startModel(self, model, attributes, **context): logger.debug('xmlmodel.XmlFormat: model: %s, %s', model.__name__, attributes) logger.debug('xmlmodel.XmlFormat: context: %s', context) recordid = context.get('recordid', ('UNKNOWN', 'UNKNOWN', -1)) hwptag = context.get('hwptag', '') logger.info('xmlmodel.XmlFormat: rec:%d %s', recordid[2], hwptag) if model is Text: text = attributes.pop('text') else: text = None for x in startelement(context, self.xmlgen, (model, attributes)): x[0](*x[1:]) if model is Text and text is not None: self.xmlgen.characters(text) unparsed = context.get('unparsed', '') if len(unparsed) > 0: logger.debug('UNPARSED: %s', hexdump(unparsed, True)) def endModel(self, model): self.xmlgen.endElement(model.__name__) def endDocument(self): self.xmlgen.endDocument()
def test_5027_2(self): # The xml prefix (as in xml:lang below) is reserved and bound by # definition to http://www.w3.org/XML/1998/namespace. XMLGenerator had # a bug whereby a KeyError is raised because this namespace is missing # from a dictionary. # # This test demonstrates the bug by direct manipulation of the # XMLGenerator. result = StringIO() gen = XMLGenerator(result) gen.startDocument() gen.startPrefixMapping("a", "http://example.com/ns") gen.startElementNS(("http://example.com/ns", "g1"), "g1", {}) lang_attr = {("http://www.w3.org/XML/1998/namespace", "lang"): "en"} gen.startElementNS(("http://example.com/ns", "g2"), "g2", lang_attr) gen.characters("Hello") gen.endElementNS(("http://example.com/ns", "g2"), "g2") gen.endElementNS(("http://example.com/ns", "g1"), "g1") gen.endPrefixMapping("a") gen.endDocument() self.assertEqual( result.getvalue(), start + ('<a:g1 xmlns:a="http://example.com/ns">' '<a:g2 xml:lang="en">Hello</a:g2>' "</a:g1>"), )
def generateXML(self,output): gen = XMLGenerator(output,"UTF-8") gen.startDocument() gen.startElement("xml",{}); if self.skipguid: gen.startElement("sheet",{}) else: gen.startElement("sheet",{'guid':self.sheetUID}) for cellattrs in [{'col':val[0],'row':val[1],'formula':val[2]} for val in self.cells]: if self.skipCol: del cellattrs['col'] if self.skipRow: del cellattrs['row'] if self.skipFormula: del cellattrs['formula'] gen.startElement("cell",cellattrs) gen.endElement("cell") gen.endElement("sheet") if not self.badxml: gen.endElement("xml") gen.endDocument()
class xmlreport: def __init__(self, filename, xslfile): self.fp = open(filename, "wb") self.xmlgen = XMLGenerator(self.fp, "utf-8") self.xmlgen.startDocument() self.xmlgen.processingInstruction("xml-stylesheet", 'type="text/xsl" href="{}"'.format(xslfile)) attrs = AttributesNSImpl({}, {}) self.xmlgen.startElementNS((None, "report"), "report", attrs) def write(self, path, code, message): attr_vals = { (None, "code"): code, (None, "path"): path } attr_qnames = { (None, "code"): "code", (None, "path"): "path" } attrs = AttributesNSImpl(attr_vals, attr_qnames) self.xmlgen.startElementNS((None, "file"), "file", attrs) self.xmlgen.characters(message) self.xmlgen.endElementNS((None, "file"), "file") def newline(self): #self.fp.write("\n") self.xmlgen.characters("\n") def close(self): self.xmlgen.endElementNS((None, "report"), "report") self.xmlgen.endDocument() self.fp.close()
def export(self,filename,transport): vprint( "osm-xml export...",1) #remember all nodes already exported unodes = {} fp = open(filename, "w") x = XMLGenerator(fp, "UTF-8") x.startDocument() x.startElement('osm',{"version":"0.6","generator":"crazy py script"}) for w in self.ways.itervalues(): if not 'highway' in w.tags: continue if transport == "all" or transport == "pt": if not (w.tags['highway']=='bus' or w.tags['highway']=='tram'): continue if transport == "all" or transport == "hw": if (w.tags['highway']=='bus' or w.tags['highway']=='tram'): continue w.toOSM(x) for nid in w.nds: if nid in unodes:#already used continue unodes[nid]=True if w.nds.index(nid)==0 or w.nds.index(nid)==len(w.nds)-1: self.nodes[nid].toOSM(x,True) else: self.nodes[nid].toOSM(x) x.endElement('osm') x.endDocument()
def saveProfiles(self, filename = None): '''saves the profiles to filename (default asstes/profiles.xml)''' if not filename: filename = os.path.join('assets', 'profiles.xml') xml_file = open(filename, "w") xmlgen = XMLGenerator(xml_file, 'UTF-8') xmlgen.startDocument() xmlgen.startElement('profilelist', {'default': str(self.currentProfile['id'])}) xml_file.write('\n') for profile in self.profiles: keys = {} for key in profile: if not key == 'active': keys[key] = str(profile[key]) xml_file.write('\t') xmlgen.startElement('profile', keys) for s in profile.shiplist: keys = {} for key in profile.shiplist[s]: keys[key] = str(profile.shiplist[s][key]) xml_file.write('\n\t\t') xmlgen.startElement('ship', keys) xmlgen.endElement('ship') xml_file.write('\t') xmlgen.endElement('profile') xml_file.write('\n') xmlgen.endElement('profilelist') xml_file.write('\n') xmlgen.endDocument() xml_file.close() self.createDisplay()
def toOSM(self,x): # Generate SAX events frame = False if x == None : frame=True # Start Document x = XMLGenerator(sys.stdout, "UTF-8") x.startDocument() x.startElement('osm',{"version":"0.6"}) x.startElement('relation',{"id":"-"+self.id.split("-",2)[1]}) #bad but for rendering ok #x.startElement('way',{"id":self.id.replace("special","").split("-",2)[0]}) for nid,role in map(lambda t: (t.items()[0]), self.mnode): x.startElement('member',{"type":"node", "ref":nid, "role":role}) x.endElement('member') for wid,role in map(lambda t: (t.items()[0]), self.mway): x.startElement('member',{"type":"way", "ref":wid, "role":role}) x.endElement('member') for rid,role in map(lambda t: (t.items()[0]), self.mrelation): x.startElement('member',{"type":"relation", "ref":rid, "role":role}) x.endElement('member') for k, v in self.tags.iteritems(): x.startElement('tag',{"k":k, "v":v}) x.endElement('tag') x.endElement('way') if frame: x.endElement('osm') x.endDocument()
def get_update_result_as_xml(status, txn_id, prv_txn, sum, comment=None): out = StringIO.StringIO("") g = XMLGenerator(out, encoding='UTF-8') g.startDocument() g.startElement("response", {}) g.startElement("mgpe_txn_id", {}) g.characters(txn_id) g.endElement("mgpe_txn_id") g.startElement("txn_id", {}) g.characters(txn_id) g.endElement("txn_id") g.startElement("prv_txn", {}) g.characters(prv_txn) g.endElement("prv_txn") g.startElement("sum", {}) g.characters(sum) g.endElement("sum") g.startElement("result", {}) g.characters(status) g.endElement("result") if comment: g.startElement("comment", {}) g.characters(comment) g.endElement("comment") g.endElement("response") g.endDocument() return out.getvalue()
def write_2(glos, filename): from xml.sax.saxutils import XMLGenerator from xml.sax.xmlreader import AttributesNSImpl xdbFp = open(filename, 'wb') fp = XMLGenerator(xdbFp, 'utf-8') attrs = AttributesNSImpl({}, {}) fp.startElement(u'xfardic', attrs) for t in glos.info: fp.startElement(unicode(t[0]), attrs) fp.characters(unicode(t[1])) fp.endElement(unicode(t[0])) fp.endElement(u'xfardic') fp.startElement(u'words', attrs) for item in glos.data: try: tmpXmlFile.characters(item[1]) except: myRaise(__file__) printAsError('While writing xdb file, an error on word "%s"'%item[0]) continue fp.startElement(u'word', attrs) fp.startElement(u'in', attrs) fp.characters(unicode(item[0])) fp.endElement(u'in') fp.startElement(u'out', attrs) fp.characters(unicode(item[1])) fp.endElement(u'out') fp.endElement(u'words') fp.endDocument() xdbFp.close()
class RspecFreezer(): #repositories is a dict of names and CTXRepo objects def __init__ (self, repositories, output = sys.stdout): self.default_version = "1" self.repos = repositories self.msgSender = "rspecRecursiveFreezer" self.xmlgenerator = XMLGenerator(output,'utf-8'); self.rcsclient = dict() self.rcsclient['svn']= ctx_svn_client.CTXSubversionClient() self.rcsclient['git']= ctx_git_client.CTXGitClient() #-------------------------------------------------------------------------- def generateFrozen(self, repo_names_to_freeze = None): self.xmlgenerator.startDocument() self.xmlgenerator.characters("\n") self.xmlgenerator.startElement('ctx-rspec', attrs = {}) self.xmlgenerator.characters("\n") for repo in self.repos: if repo_names_to_freeze == None: self.freezeRepo(repo) else: if repo.getID() in repo_names_to_freeze: self.freezeRepo(repo) self.xmlgenerator.endElement('ctx-rspec') self.xmlgenerator.characters("\n") self.xmlgenerator.endDocument() #self.rspec. def freezeRepo(self, repo): id = repo.getID() href = repo.getHref() rcs = repo.getRcs() path = repo.getPath() rev = repo.getRSpecRevision() repo_path = repo.getAbsLocalPath() #TODO: make it possible to base the freeze on an existing rspec (only freeze repos included in there) if (rcs == 'svn' or rcs == 'git'): if rev == 'HEAD' or rev == None or rev == 'master': curr_rev = self.rcsclient[rcs].getRevisionFromWorkingCopy(repo_path) else: curr_rev = self.rcsclient[rcs].getRevisionFromWorkingCopy(repo_path) if str(curr_rev) != rev: warningMessage('%s: Overwriting strict revision nr %s with %s'%(id, str(rev), str(curr_rev))) self.xmlgenerator.characters("\t") self.xmlgenerator.startElement('ctx-repo', attrs = {'id':id,'rcs':rcs, 'href': href, 'rev': str(curr_rev), 'path':path }) self.xmlgenerator.characters("\n") else: warningMessage("Currently only supporting freeze for svn-repos, skipping '%s'"%repo_path) return paths = repo.getAllRelativePaths() for path_type in paths: for path_spec in paths[path_type]: self.xmlgenerator.characters("\t\t") self.xmlgenerator.startElement('ctx-path', attrs = {'type':path_type, 'spec':path_spec}) self.xmlgenerator.endElement('ctx-path') self.xmlgenerator.characters("\n") self.xmlgenerator.characters("\t") self.xmlgenerator.endElement('ctx-repo') self.xmlgenerator.characters("\n\n")
def dump_xml(self, output_dir): """ Dumps test result to xml """ self.buffer = False with open(os.path.join(output_dir, 'junit.xml'), 'w') as output: document = XMLGenerator(output, 'utf-8') document.startDocument() document.startElement('testsuites', AttributesImpl({})) suites = groupby(self.testInfos, key=lambda test_info: self.test_case_name(test_info.test_method)) for suite_name, suite in suites: document.startElement('testsuite', AttributesImpl({'name' : suite_name})) for test_info in suite: document.startElement('testcase', AttributesImpl({ 'classname' : suite_name, 'name' : self.test_method_name(test_info.test_method), 'time' : '%3f' % total_seconds(test_info.end_time - test_info.start_time) })) if test_info.result == TestInfo.RESULT.ERROR: document.startElement('error', AttributesImpl({ 'message' : smart_text(test_info.err[1]) })) document.characters(self._exc_info_to_string(test_info.err, test_info.test_method)) document.endElement('error') elif test_info.result == TestInfo.RESULT.FAILURE: document.startElement('failure', AttributesImpl({ 'message' : smart_text(test_info.err[1]) })) document.characters(self._exc_info_to_string(test_info.err, test_info.test_method)) document.endElement('failure') elif test_info.result == TestInfo.RESULT.UNEXPECTED_SUCCESS: document.startElement('error', AttributesImpl({ 'message' : 'Unexpected success' })) document.endElement('error') elif test_info.result == TestInfo.RESULT.SKIPPED: document.startElement('skipped', AttributesImpl({})) document.characters(test_info.reason) document.endElement('skipped') if test_info.stdout: document.startElement('system-out', AttributesImpl({})) document.characters(test_info.stdout) document.endElement('system-out') if test_info.stderr: document.startElement('system-err', AttributesImpl({})) document.characters(test_info.stderr) document.endElement('system-err') document.endElement('testcase') document.endElement('testsuite') document.endElement('testsuites') document.endDocument()
def __call__(self, url, data, coords, metadata): file = StringIO.StringIO() gen = XMLGenerator( file, 'UTF-8' ) gen.startDocument() gen.startElement('img', {'usemap':'#map', 'src':str(url)}) gen.endElement('img') self.writeMap( gen, data, coords, metadata ) gen.endDocument() return file.getvalue()
def test_xmlgen_basic_empty(self): result = StringIO() gen = XMLGenerator(result, short_empty_elements=True) gen.startDocument() gen.startElement("doc", {}) gen.endElement("doc") gen.endDocument() self.assertEqual(result.getvalue(), start + "<doc/>")
def test_xmlgen_basic(self): result = StringIO() gen = XMLGenerator(result) gen.startDocument() gen.startElement("doc", {}) gen.endElement("doc") gen.endDocument() self.assertEqual(result.getvalue(), start + "<doc></doc>")
def test_xmlgen_basic(): result = StringIO() gen = XMLGenerator(result) gen.startDocument() gen.startElement("doc", {}) gen.endElement("doc") gen.endDocument() return result.getvalue() == start + "<doc></doc>"
def unparse(input_dict, output=None, encoding='utf-8', full_document=True, short_empty_elements=False, **kwargs): """Emit an XML document for the given `input_dict` (reverse of `parse`). The resulting XML document is returned as a string, but if `output` (a file-like object) is specified, it is written there instead. Dictionary keys prefixed with `attr_prefix` (default=`'@'`) are interpreted as XML node attributes, whereas keys equal to `cdata_key` (default=`'#text'`) are treated as character data. The `pretty` parameter (default=`False`) enables pretty-printing. In this mode, lines are terminated with `'\n'` and indented with `'\t'`, but this can be customized with the `newl` and `indent` parameters. """ if full_document and len(input_dict) != 1: raise ValueError('Document must have exactly one root.') must_return = False if output is None: output = StringIO() must_return = True if short_empty_elements: content_handler = XMLGenerator(output, encoding, True) else: content_handler = XMLGenerator(output, encoding) if full_document: content_handler.startDocument() for key, value in input_dict.items(): _emit(key, value, content_handler, full_document=full_document, **kwargs) if full_document: content_handler.endDocument() if must_return: value = output.getvalue() try: # pragma no cover value = value.decode(encoding) except AttributeError: # pragma no cover pass return value
def convert_from_json_to_xml_file(jsonfile, xmlfile=None): if (check_if_string(jsonfile) and re.findall("^(http|https)\:\/\/", jsonfile)): jsonheaders = { 'User-Agent': useragent_string } tree = json.load( urllib2.urlopen(urllib2.Request(jsonfile, None, jsonheaders))) else: if (check_if_string(jsonfile)): jsonfile = open(jsonfile, "r") tree = json.load(jsonfile) jsonfile.close() try: bctree = tree['barcodes']['barcode'] except: return False bctreeln = len(bctree) bctreect = 0 bcdrawlist = [] xmlout = StringIO() upcxml = XMLGenerator(xmlout, "utf-8") upcxml.startDocument() upcxml.startElement("barcodes", {}) upcxml.characters("\n") while (bctreect < bctreeln): upcxml.characters(" ") upcxml.startElement("barcode", bctree[bctreect]) upcxml.endElement("barcode") upcxml.characters("\n") bctreect = bctreect + 1 upcxml.endElement("barcodes") upcxml.endDocument() xmlout.seek(0) if (xmlfile is not None): xmlofile = open(xmlfile, "w+") xmlofile.write(xmlout.read()) xmlofile.close() return True if (xmlfile is None): return xmlout.read()
def create_event_xml(events, output): """ Write out the final XML given an input iterator of events.""" from xml.sax.saxutils import XMLGenerator generator = XMLGenerator(output, "utf-8") generator.startDocument() generator.startElement('file_events', {}) qnames = { (None, "date"): "date", (None, "filename"): "filename", (None, "author"): "author" } for event in events: generator.startElement("event", event.properties()) generator.endElement("event") generator.endElement('file_events') generator.endDocument()
def unparse(input_dict, output=None, encoding='utf-8', full_document=True, **kwargs): if full_document and len(input_dict) != 1: raise ValueError('Document must have exactly one root.') must_return = False if output is None: output = StringIO() must_return = True content_handler = XMLGenerator(output, encoding) if full_document: content_handler.startDocument() for key, value in input_dict.items(): _emit(key, value, content_handler, full_document=full_document, **kwargs) if full_document: content_handler.endDocument() if must_return: value = output.getvalue() try: value = value.decode(encoding) except AttributeError: pass return value
def write_2(glos, filename): from xml.sax.saxutils import XMLGenerator from xml.sax.xmlreader import AttributesNSImpl fp = open(filename, 'wb') xmlFile = XMLGenerator(fp, 'utf-8') attrs = AttributesNSImpl({}, {}) for item in glos.data: """ try: tmpXmlFile.characters(item[1]) except: myRaise(__file__) printAsError('While writing xdb. an error on word "%s"'%item[0]) continue """ xmlFile.characters(unicode(item[0])) xmlFile.characters(u'\t') xmlFile.characters(unicode(item[1])) #xmlFile.characters(u'\n') xmlFile.endDocument() fp.close()
class XMLWriter: def __init__(self, fileName): self.out = open(fileName, 'w') self.g = XMLGenerator(self.out, 'utf-8') return def writeHeader(self, header): #self.out.write("""<?xml version="1.0" encoding="UTF-8"?>""") #self.out.write("""<gexf version="1.2" xmlns="http://www.gexf.net/1.2draft" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.gexf.net/1.2draft http://www.gexf.net/1.2draft/gexf.xsd">""") self.out.write(header) return def startTag(self, name, attr={}, body=None, namespace=None): attr_vals = {} attr_keys = {} for key, val in attr.iteritems(): key_tuple = (namespace, key) attr_vals[key_tuple] = val attr_keys[key_tuple] = key attr2 = AttributesNSImpl(attr_vals, attr_keys) self.g.startElementNS((namespace, name), name, attr2) if body: self.g.characters(body) return def endTag(self, name, namespace=None): self.g.endElementNS((namespace, name), name) return def tag(self, name, attr={}, body=None, namespace=None): self.startTag(name, attr, body, namespace) self.endTag(name, namespace) return def endDocument(self): self.g.endDocument() self.out.close() return
def generate(self, filename, foods): fp = open(filename, "w") out = XMLGenerator(fp, 'utf-8') out.startDocument() out.startElement("fooddb", {}) for food in foods: food = foods[food] out.startElement("food", {}) out.startElement("name", {}) out.characters(food.name) out.endElement("name") out.startElement("energy", {}) out.characters(str(food.energy)) out.endElement("energy") out.endElement("food") out.endElement("fooddb") out.endDocument() fp.close()
def save(self, filename=None): if self.filename and filename is None: filename = self.filename if len(self.__dict__) == 0 or filename is None: return try: fileobj = get_fileptr(filename, True) except Exception as e: LOG.error('Cannot write preferences into %s %s', filename, e) return writer = XMLGenerator(out=fileobj, encoding=self.system_encoding) writer.startDocument() defaults = XmlConfigParser.__dict__ items = self.__dict__.items() items.sort() writer.startElement('preferences', {}) writer.characters('\n') for key, value in items: if key in defaults and defaults[key] == value: continue if key in ['filename', 'app']: continue writer.characters('\t') writer.startElement('%s' % key, {}) str_value = path_unicode(value.__str__()) if isinstance(value, str): str_value = "'%s'" % (escape_quote(str_value)) writer.characters(str_value) writer.endElement('%s' % key) writer.characters('\n') writer.endElement('preferences') writer.endDocument() fileobj.close()
class PreferenceWriter: def startElement(self, names, attrs): self.depth_idx += 1 self.writer.characters(' ' * self.depth_idx) self.writer.startElement(names, attrs) def endElement(self, name): self.writer.endElement(name) self.writer.characters('\n') self.depth_idx -= 1 def __init__(self, fname, options): output = open(fname, 'w') self.depth_idx = -1 self.writer = XMLGenerator(output, 'utf-8') self.writer.startDocument() self.startElement('PacketManipulator', {}), self.writer.characters('\n') items = options.items() items.sort() for key, option in items: attr_vals = { 'id' : key, 'value' : str(option.value) } attrs = AttributesImpl(attr_vals) self.startElement(str(option.type), attrs) self.endElement(str(option.type)) self.endElement('PacketManipulator') self.writer.endDocument() output.close()
def create_testdoc(_title, _content, _data_count, _data_text): xml_doc = BytesIO() try: xml_generator = XMLGenerator(xml_doc, 'UTF-8') start_element = lambda name, attrs: xml_generator.startElement( name, attrs) end_element = lambda name: xml_generator.endElement(name) text = lambda value: xml_generator.characters(value) attrs = lambda values: AttributesImpl(values) empty_attrs = attrs({}) xml_generator.startDocument() start_element('html', attrs({'xmlns': XHTML_NAMESPACE})) start_element('head', empty_attrs) start_element('title', empty_attrs) text(_title) end_element('title') end_element('head') start_element('body', empty_attrs) start_element('h1', empty_attrs) text(_title) end_element('h1') start_element('p', empty_attrs) text(_content) end_element('p') for i in range(_data_count): start_element('div', attrs({'data-i': str(i)})) for j in range(_data_count): start_element('p', attrs({'data-j': str(j)})) text(_data_text) end_element('p') end_element('div') end_element('body') end_element('html') xml_generator.endDocument() return xml_doc.getvalue() finally: xml_doc.close()
def run(self): xml = XMLGenerator(self.out, 'UTF-8', True) xml.startDocument() xml.startPrefixMapping('', self.SVG_NAMESPACE) xml.startPrefixMapping(self.XLINK_PREFIX, self.XLINK_NAMESPACE) canvasWidth = int(self.marginWidth + (self.count - 1) * self.offset) attrs = self._defaultNSAttrs({ self._svgName('version'): self.SVG_VERSION, self._svgName('width'): str(canvasWidth), self._svgName('height'): str(self.canvasHeight), self._svgName('viewBox'): ('%d %d %d %g' % (0, 0, canvasWidth, self.canvasHeight)) }) xml.startElementNS(self.SVG_ELEMENT, None, attrs) self._defs(xml) self._contentGroup(xml) xml.ignorableWhitespace('\n') xml.endElementNS(self.SVG_ELEMENT, None) xml.endPrefixMapping('') xml.endPrefixMapping(self.XLINK_PREFIX) xml.endDocument()
def render(self, data, namespaces=None): namespaces = namespaces or [] stream = BytesIO() xml = XMLGenerator(stream, encoding='utf-8') xml.startDocument() if isinstance(data, (list, tuple)): raise RenderError('Renderer of iterables is not supported') keys = list(data.keys()) if len(keys) != 1: raise RenderError('`data` should have only one key, the root') root_element = keys[0] attrs = {'xmlns:' + ns: url for ns, url in namespaces} xml.startElement(root_element, attrs) self._to_xml(xml, data[root_element]) xml.endElement(root_element) xml.endDocument() return stream.getvalue()
def test_formula_rule(self): class WS(): conditional_formatting = ConditionalFormatting() worksheet = WS() worksheet.conditional_formatting.add( 'C1:C10', FormulaRule(formula=['ISBLANK(C1)'], stopIfTrue=True)) worksheet.conditional_formatting.setDxfStyles(self.workbook) temp_buffer = StringIO() doc = XMLGenerator(out=temp_buffer, encoding='utf-8') write_worksheet_conditional_formatting(doc, worksheet) doc.endDocument() xml = temp_buffer.getvalue() temp_buffer.close() diff = compare_xml( xml, """ <conditionalFormatting sqref="C1:C10"> <cfRule dxfId="0" type="expression" stopIfTrue="1" priority="1"> <formula>ISBLANK(C1)</formula> </cfRule> </conditionalFormatting> """) assert diff is None, diff
class XmlItemExporter(BaseItemExporter): def __init__(self, file, **kwargs): self.item_element = kwargs.pop('item_element', 'item') self.root_element = kwargs.pop('root_element', 'items') self._configure(kwargs) self.xg = XMLGenerator(file, encoding=self.encoding) def start_exporting(self): self.xg.startDocument() self.xg.startElement(self.root_element, {}) def export_item(self, item): self.xg.startElement(self.item_element, {}) for value in item: self._export_xml_field(value, item[value]) self.xg.endElement(self.item_element) def finish_exporting(self): self.xg.endElement(self.root_element) self.xg.endDocument() def _export_xml_field(self, name, serialized_value): self.xg.startElement(name, {}) if hasattr(serialized_value, '__iter__'): if type(serialized_value).__name__ != 'dict': for value in serialized_value: if type(value).__name__ == 'str' or type( value).__name__ == 'unicode': self._export_xml_field('value', value) else: self.export_item(value) else: self.export_item(serialized_value) else: self.xg.characters(serialized_value) self.xg.endElement(name)
def dump_xml(replay): from xml.sax.saxutils import XMLGenerator d = replay_to_dict(replay) players = d.pop('player_slots') gen = XMLGenerator() gen.startDocument() gen.startElement('replay', {}) for key, value in d.iteritems(): gen.startElement(key, {}) gen.characters(str(value)) gen.endElement(key) gen.startElement('players', {}) for player in players: actions = player.pop('actions') gen.startElement('player', {}) for key, value in player.iteritems(): gen.startElement(key, {}) gen.characters(str(value)) gen.endElement(key) gen.startElement('actions', {}) for action in actions: gen.startElement('action', {}) for key, value in action.iteritems(): gen.startElement(key, {}) gen.characters(str(value)) gen.endElement(key) gen.endElement('action') gen.endElement('actions') gen.endElement('player') gen.endElement('players') gen.endElement('replay') gen.endDocument()
class XMLMapSaver(object): def __init__(self, filepath, engine, map, importList, state=0, datastate=0): self.SModel, self.SMap, self.SLayer, self.SInstances, self.SObject, self.SAction = list( range(6)) self.engine = engine self.model = self.engine.getModel() self.image_manager = self.engine.getImageManager() if (state): self.state = state if (state == self.SMap): self.map = datastate else: assert 0, "Invalid initialization state." else: self.state = self.SModel self.stack = [self.SModel] self.datastack = [] self.file = open(filepath, 'w') self.xmlout = XMLGenerator(self.file, 'ascii') self.xmlout.startDocument() self.indent_level = '' self.nspace = None self.map = map self.importList = importList def startElement(self, name, attrs): self.file.write(self.indent_level) self.xmlout.startElementNS((None, name), name, attrs) self.file.write('\n') self.indent_level = self.indent_level + '\t' def endElement(self, name): self.indent_level = self.indent_level[0:(len(self.indent_level) - 1)] self.file.write(self.indent_level) self.xmlout.endElementNS((None, name), name) self.file.write('\n') def write_map(self): assert self.state == self.SModel, "Declaration of <map> not at the top level." attr_vals = { (None, 'id'): self.map.getId(), (None, 'format'): MAPFORMAT, } attr_names = { (None, 'id'): 'id', (None, 'format'): 'format', } attrs = AttributesNSImpl(attr_vals, attr_names) self.startElement('map', attrs) self.state = self.SMap self.write_imports(self.map, self.importList) self.write_layers(self.map) self.write_camera(self.map) self.endElement('map') def write_imports(self, map, importList): for importdir in importList: self.write_importdir(root_subfile(map.getFilename(), importdir)) imports = [] for layer in map.getLayers(): for instance in layer.getInstances(): file = instance.getObject().getFilename() if not (file in imports): if not self.have_superdir(file, importList): imports.append(file) self.write_import(root_subfile(map.getFilename(), file)) def have_superdir(self, file, importList): '''returns true, if file is in directories given in importList''' for dir in importList: have = True for test in zip(dir.split(os.path.sep), file.split(os.path.sep)): if test[0] != test[1]: have = False if have: return True return False def write_import(self, file): attr_vals = { (None, 'file'): file, } attr_names = { (None, 'file'): 'file', } attrs = AttributesNSImpl(attr_vals, attr_names) self.file.write(self.indent_level) self.xmlout.startElementNS((None, 'import'), 'import', attrs) self.xmlout.endElementNS((None, 'import'), 'import') self.file.write('\n') def write_importdir(self, dir): attr_vals = { (None, 'dir'): dir, } attr_names = { (None, 'dir'): 'dir', } attrs = AttributesNSImpl(attr_vals, attr_names) self.file.write(self.indent_level) self.xmlout.startElementNS((None, 'import'), 'import', attrs) self.xmlout.endElementNS((None, 'import'), 'import') self.file.write('\n') def pathing_val_to_str(self, val): if val == fife.CELL_EDGES_AND_DIAGONALS: return "cell_edges_and_diagonals" if val == fife.FREEFORM: return "freeform" return "cell_edges_only" def layer_type_to_str(self, layer): if layer.isWalkable(): return "walkable" elif layer.isInteract(): return "interact" return "" def write_layers(self, map): for layer in map.getLayers(): cellgrid = layer.getCellGrid() attr_vals = { (None, 'id'): layer.getId(), (None, 'grid_type'): cellgrid.getType(), (None, 'x_scale'): str(cellgrid.getXScale()), (None, 'y_scale'): str(cellgrid.getYScale()), (None, 'rotation'): str(cellgrid.getRotation()), (None, 'x_offset'): str(cellgrid.getXShift()), (None, 'y_offset'): str(cellgrid.getYShift()), (None, 'z_offset'): str(cellgrid.getZShift()), (None, 'pathing'): self.pathing_val_to_str(layer.getPathingStrategy()), (None, 'transparency'): str(layer.getLayerTransparency()), (None, 'layer_type'): str(self.layer_type_to_str(layer)), (None, 'layer_type_id'): str(layer.getWalkableId()), } attr_names = { (None, 'id'): 'id', (None, 'grid_type'): 'grid_type', (None, 'scaling'): 'scaling', (None, 'rotation'): 'rotation', (None, 'x_offset'): 'x_offset', (None, 'y_offset'): 'y_offset', (None, 'z_offset'): 'z_offset', (None, 'pathing'): 'pathing', (None, 'layer_type'): 'layer_type', (None, 'layer_type_id'): 'layer_type_id', } attrs = AttributesNSImpl(attr_vals, attr_names) self.startElement('layer', attrs) self.write_instances(layer) self.write_lights(layer) self.endElement('layer') def write_instances(self, layer): attrs = AttributesNSImpl({}, {}) self.startElement('instances', attrs) for inst in layer.getInstances(): position = inst.getLocationRef().getExactLayerCoordinates() attr_vals = { (None, 'o'): inst.getObject().getId(), (None, 'x'): str(position.x), (None, 'y'): str(position.y), (None, 'z'): str(position.z), (None, 'r'): str(inst.getRotation()), } attr_names = { (None, 'o'): 'o', (None, 'x'): 'x', (None, 'y'): 'y', (None, 'z'): 'z', (None, 'r'): 'r', } visual = inst.get2dGfxVisual() if visual: attr_vals[(None, 'stackpos')] = str(visual.getStackPosition()) attr_names[(None, 'stackpos')] = 'stackpos' nspace = inst.getObject().getNamespace() if nspace != self.nspace: attr_vals[(None, 'ns')] = inst.getObject().getNamespace() attr_names[(None, 'ns')] = 'ns' self.nspace = nspace instId = inst.getId() if instId: attr_vals[(None, 'id')] = inst.getId() attr_names[(None, 'id')] = 'id' if inst.isOverrideBlocking(): attr_vals[(None, 'override_blocking')] = str( int(inst.isOverrideBlocking())) attr_names[(None, 'override_blocking')] = 'override_blocking' if inst.getObject().isBlocking() is not inst.isBlocking(): attr_vals[(None, 'blocking')] = str(int(inst.isBlocking())) attr_names[(None, 'blocking')] = 'blocking' attrs = AttributesNSImpl(attr_vals, attr_names) self.file.write(self.indent_level) self.xmlout.startElementNS((None, 'i'), 'i', attrs) self.xmlout.endElementNS((None, 'i'), 'i') self.file.write('\n') self.endElement('instances') def write_lights(self, layer): attrs = AttributesNSImpl({}, {}) self.startElement('lights', attrs) cameras = layer.getMap().getCameras() for cam in cameras: hit = False layers = cam.getRenderer("LightRenderer").getActiveLayers() for lay in layers: if lay.getId() == layer.getId(): hit = True if hit == False: continue renderer = fife.LightRenderer.getInstance(cam) groups = renderer.getGroups() for group in groups: infos = renderer.getLightInfo(group) for info in infos: attr_vals = {} attr_names = {} type = info.getName() attr_vals[(None, 'group')] = str(group) attr_names[(None, 'group')] = 'group' attr_vals[(None, 'type')] = str(type) attr_names[(None, 'type')] = 'type' attr_vals[(None, 'instance')] = str( info.getNode().getInstance().getId()) attr_names[(None, 'instance')] = 'instance' if info.getSrcBlend() > -1: attr_vals[(None, 'src')] = str(info.getSrcBlend()) attr_names[(None, 'src')] = 'src' if info.getDstBlend() > -1: attr_vals[(None, 'dst')] = str(info.getDstBlend()) attr_names[(None, 'dst')] = 'dst' if info.getStencil() > -1: attr_vals[(None, 's_ref')] = str(info.getStencil()) attr_names[(None, 's_ref')] = 's_ref' attr_vals[(None, 'a_ref')] = str(info.getAlpha()) attr_names[(None, 'a_ref')] = 'a_ref' if type == 'simple': if info.getRadius() > 0: attr_vals[(None, 'radius')] = str(info.getRadius()) attr_names[(None, 'radius')] = 'radius' if info.getColor(): color = info.getColor() attr_vals[(None, 'color')] = '%d,%d,%d' % ( color[0], color[1], color[2]) attr_vals[(None, 'intensity')] = str(color[3]) attr_names[(None, 'color')] = 'color' attr_names[(None, 'intensity')] = 'intensity' if info.getSubdivisions() is not 32: attr_vals[(None, 'subdivisions')] = str( info.getSubdivisions()) attr_names[(None, 'subdivisions')] = 'subdivisions' if info.getXStretch() > 1.001 or info.getXStretch( ) < 0.999: attr_vals[(None, 'xstretch')] = str(info.getXStretch()) attr_names[(None, 'xstretch')] = 'xstretch' if info.getYStretch() > 1.001 or info.getYStretch( ) < 0.999: attr_vals[(None, 'ystretch')] = str(info.getYStretch()) attr_names[(None, 'ystretch')] = 'ystretch' elif type == 'image': if info.getImage() == 0: continue img = info.getImage() name = img.getName() attr_vals[(None, 'image')] = str('../' + name) attr_names[(None, 'image')] = 'image' elif type == 'animation': if info.getAnimation() == 0: continue ani = info.getAnimation() count = 0 newstr = '' image = ani.getFrame(ani.getActionFrame()) fname = image.getName() strings = ([str(s) for s in fname.split('/')]) leng = len(strings) - 1 while count < leng: newstr = str(newstr + strings[count] + '/') count += 1 name = str('../' + newstr + 'animation.' + fileExtensions[0]) attr_vals[(None, 'animation')] = str(name) attr_names[(None, 'animation')] = 'animation' else: continue attrs = AttributesNSImpl(attr_vals, attr_names) self.file.write(self.indent_level) self.xmlout.startElementNS((None, 'l'), 'l', attrs) self.xmlout.endElementNS((None, 'l'), 'l') self.file.write('\n') self.endElement('lights') # Save the linked camera of a map. def write_camera(self, map): cameralist = map.getCameras() for cam in cameralist: if cam.getMap().getId() == map.getId(): celldimensions = cam.getCellImageDimensions() viewport = cam.getViewPort() attr_names = { (None, 'id'): 'id', (None, 'zoom'): 'zoom', (None, 'tilt'): 'tile', (None, 'rotation'): 'rotation', (None, 'ref_cell_width'): 'ref_cell_width', (None, 'ref_cell_height'): 'ref_cell_height', } attr_vals = { (None, 'id'): cam.getId(), (None, 'zoom'): str(cam.getZoom()), (None, 'tilt'): str(cam.getTilt()), (None, 'rotation'): str(cam.getRotation()), (None, 'ref_cell_width'): str(celldimensions.x), (None, 'ref_cell_height'): str(celldimensions.y), } # add a viewport entry if the cam isn't full sized if not (viewport == self.engine.getRenderBackend().getArea()): attr_names[(None, 'viewport')] = 'viewport' attr_vals[(None, 'viewport')] = '%d,%d,%d,%d' % ( viewport.x, viewport.y, viewport.w, viewport.h) colors = cam.getLightingColor() if colors[0] < 1.0 or colors[1] < 1.0 or colors[2] < 1.0: attr_names[(None, 'light_color')] = 'light_color' attr_vals[(None, 'light_color')] = '%f,%f,%f' % ( colors[0], colors[1], colors[2]) attrs = AttributesNSImpl(attr_vals, attr_names) self.startElement('camera', attrs) self.endElement('camera') def flush(self): self.xmlout.endDocument() self.file.close() def saveResource(self): self.write_map()
class SeqXmlWriter(SequentialSequenceWriter): """Writes SeqRecords into seqXML file. SeqXML requires the sequence alphabet be explicitly RNA, DNA or protein, i.e. an instance or subclass of Bio.Alphapet.RNAAlphabet, Bio.Alphapet.DNAAlphabet or Bio.Alphapet.ProteinAlphabet. """ def __init__(self, handle, source=None, source_version=None, species=None, ncbiTaxId=None): """Create Object and start the xml generator.""" SequentialSequenceWriter.__init__(self, handle) self.xml_generator = XMLGenerator(handle, "utf-8") self.xml_generator.startDocument() self.source = source self.source_version = source_version self.species = species self.ncbiTaxId = ncbiTaxId def write_header(self): """Write root node with document metadata.""" SequentialSequenceWriter.write_header(self) attrs = { "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance", "xsi:noNamespaceSchemaLocation": "http://www.seqxml.org/0.4/seqxml.xsd", "seqXMLversion": "0.4" } if self.source is not None: attrs["source"] = self.source if self.source_version is not None: attrs["sourceVersion"] = self.source_version if self.species is not None: if not isinstance(self.species, basestring): raise TypeError("species should be of type string") attrs["speciesName"] = self.species if self.ncbiTaxId is not None: if not isinstance(self.ncbiTaxId, (basestring, int)): raise TypeError("ncbiTaxID should be of type string or int") attrs["ncbiTaxID"] = self.ncbiTaxId self.xml_generator.startElement("seqXML", AttributesImpl(attrs)) def write_record(self, record): """Write one record.""" if not record.id or record.id == "<unknown id>": raise ValueError("SeqXML requires identifier") if not isinstance(record.id, basestring): raise TypeError("Identifier should be of type string") attrb = {"id": record.id} if "source" in record.annotations and self.source != record.annotations[ "source"]: if not isinstance(record.annotations["source"], basestring): raise TypeError("source should be of type string") attrb["source"] = record.annotations["source"] self.xml_generator.startElement("entry", AttributesImpl(attrb)) self._write_species(record) self._write_description(record) self._write_seq(record) self._write_dbxrefs(record) self._write_properties(record) self.xml_generator.endElement("entry") def write_footer(self): """Close the root node and finish the XML document.""" SequentialSequenceWriter.write_footer(self) self.xml_generator.endElement("seqXML") self.xml_generator.endDocument() def _write_species(self, record): """Write the species if given.""" local_ncbi_taxid = None if "ncbi_taxid" in record.annotations: local_ncbi_taxid = record.annotations["ncbi_taxid"] if isinstance(local_ncbi_taxid, list): # SwissProt parser uses a list (which could cope with chimeras) if len(local_ncbi_taxid) == 1: local_ncbi_taxid = local_ncbi_taxid[0] elif len(local_ncbi_taxid) == 0: local_ncbi_taxid = None else: ValueError( 'Multiple entries for record.annotations["ncbi_taxid"], %r' % local_ncbi_taxid) if "organism" in record.annotations and local_ncbi_taxid: local_org = record.annotations["organism"] if not isinstance(local_org, basestring): raise TypeError("organism should be of type string") if not isinstance(local_ncbi_taxid, (basestring, int)): raise TypeError("ncbiTaxID should be of type string or int") # The local species definition is only written if it differs from the global species definition if local_org != self.species or local_ncbi_taxid != self.ncbiTaxId: attr = {"name": local_org, "ncbiTaxID": local_ncbi_taxid} self.xml_generator.startElement("species", AttributesImpl(attr)) self.xml_generator.endElement("species") def _write_description(self, record): """Write the description if given.""" if record.description: if not isinstance(record.description, basestring): raise TypeError("Description should be of type string") description = record.description if description == "<unknown description>": description = "" if len(record.description) > 0: self.xml_generator.startElement("description", AttributesImpl({})) self.xml_generator.characters(description) self.xml_generator.endElement("description") def _write_seq(self, record): """Write the sequence. Note that SeqXML requires a DNA, RNA or protein alphabet. """ if isinstance(record.seq, UnknownSeq): raise TypeError( "Sequence type is UnknownSeq but SeqXML requires sequence") seq = str(record.seq) if not len(seq) > 0: raise ValueError("The sequence length should be greater than 0") # Get the base alphabet (underneath any Gapped or StopCodon encoding) alpha = Alphabet._get_base_alphabet(record.seq.alphabet) if isinstance(alpha, Alphabet.RNAAlphabet): seqElem = "RNAseq" elif isinstance(alpha, Alphabet.DNAAlphabet): seqElem = "DNAseq" elif isinstance(alpha, Alphabet.ProteinAlphabet): seqElem = "AAseq" else: raise ValueError("Need a DNA, RNA or Protein alphabet") self.xml_generator.startElement(seqElem, AttributesImpl({})) self.xml_generator.characters(seq) self.xml_generator.endElement(seqElem) def _write_dbxrefs(self, record): """Write all database cross references.""" if record.dbxrefs is not None: for dbxref in record.dbxrefs: if not isinstance(dbxref, basestring): raise TypeError("dbxrefs should be of type list of string") if dbxref.find(':') < 1: raise ValueError( "dbxrefs should be in the form ['source:id', 'source:id' ]" ) dbsource, dbid = dbxref.split(':', 1) attr = {"source": dbsource, "id": dbid} self.xml_generator.startElement("DBRef", AttributesImpl(attr)) self.xml_generator.endElement("DBRef") def _write_properties(self, record): """Write all annotations that are key value pairs with values of a primitive type or list of primitive types.""" for key, value in record.annotations.items(): if key not in ("organism", "ncbi_taxid", "source"): if value is None: attr = {"name": key} self.xml_generator.startElement("property", AttributesImpl(attr)) self.xml_generator.endElement("property") elif isinstance(value, list): for v in value: if isinstance(value, (int, float, basestring)): attr = {"name": key, "value": v} self.xml_generator.startElement( "property", AttributesImpl(attr)) self.xml_generator.endElement("property") elif isinstance(value, (int, float, basestring)): attr = {"name": key, "value": str(value)} self.xml_generator.startElement("property", AttributesImpl(attr)) self.xml_generator.endElement("property")
class XmlItemExporter(BaseItemExporter): def __init__(self, file, **kwargs): self.item_element = kwargs.pop('item_element', 'item') self.root_element = kwargs.pop('root_element', 'items') self._configure(kwargs) if not self.encoding: self.encoding = 'utf-8' self.xg = XMLGenerator(file, encoding=self.encoding) def _beautify_newline(self, new_item=False): if self.indent is not None and (self.indent > 0 or new_item): self._xg_characters('\n') def _beautify_indent(self, depth=1): if self.indent: self._xg_characters(' ' * self.indent * depth) def start_exporting(self): self.xg.startDocument() self.xg.startElement(self.root_element, {}) self._beautify_newline(new_item=True) def export_item(self, item): self._beautify_indent(depth=1) self.xg.startElement(self.item_element, {}) self._beautify_newline() for name, value in self._get_serialized_fields(item, default_value=''): self._export_xml_field(name, value, depth=2) self._beautify_indent(depth=1) self.xg.endElement(self.item_element) self._beautify_newline(new_item=True) def finish_exporting(self): self.xg.endElement(self.root_element) self.xg.endDocument() def _export_xml_field(self, name, serialized_value, depth): self._beautify_indent(depth=depth) self.xg.startElement(name, {}) if hasattr(serialized_value, 'items'): self._beautify_newline() for subname, value in serialized_value.items(): self._export_xml_field(subname, value, depth=depth + 1) self._beautify_indent(depth=depth) elif is_listlike(serialized_value): self._beautify_newline() for value in serialized_value: self._export_xml_field('value', value, depth=depth + 1) self._beautify_indent(depth=depth) elif isinstance(serialized_value, six.text_type): self._xg_characters(serialized_value) else: self._xg_characters(str(serialized_value)) self.xg.endElement(name) self._beautify_newline() # Workaround for https://bugs.python.org/issue17606 # Before Python 2.7.4 xml.sax.saxutils required bytes; # since 2.7.4 it requires unicode. The bug is likely to be # fixed in 2.7.6, but 2.7.6 will still support unicode, # and Python 3.x will require unicode, so ">= 2.7.4" should be fine. if sys.version_info[:3] >= (2, 7, 4): def _xg_characters(self, serialized_value): if not isinstance(serialized_value, six.text_type): serialized_value = serialized_value.decode(self.encoding) return self.xg.characters(serialized_value) else: # pragma: no cover def _xg_characters(self, serialized_value): return self.xg.characters(serialized_value)
def end_test(self, result): """Called after each test.""" failures = errors = skipped = disabled = 0 if result.eofs == 'O': pass elif result.eofs == 'S': skipped = 1 elif result.eofs == 'F': failures = 1 elif result.eofs == 'E': errors = 1 else: errors = 1 classname = encode(result.case.uid.replace("/", ".")) if classname.endswith('.py'): classname = classname[:-3] filename = os.path.join(self.outdir, '%s.xml' % (result.case.uid, )) dirname = os.path.dirname(filename) try: os.makedirs(dirname) except OSError as ex: if ex.errno != errno.EEXIST: raise f_report = open(filename, 'w') try: xml = XMLGenerator(f_report, encoding='utf-8') xml.startDocument() xml.startElement( 'testsuite', { 'name': classname, 'tests': '%d' % (1, ), 'failures': '%d' % (failures, ), 'errors': '%d' % (errors, ), 'time': '%0.3f' % (result.duration / 1000.0, ), 'disabled': '%d' % (disabled, ), 'skipped': '%d' % (skipped, ), 'timestamp': self.now.isoformat(), 'hostname': os.uname()[1], }) xml.startElement('properties', {}) xml.startElement('property', { 'name': 'hostname', 'value': result.environment.hostname, }) xml.endElement('property') xml.startElement('property', { 'name': 'architecture', 'value': result.environment.architecture, }) xml.endElement('property') xml.startElement('property', { 'name': 'role', 'value': result.environment.role, }) xml.endElement('property') xml.startElement( 'property', { 'name': 'version', 'value': '%s' % (result.environment.ucs_version, ), }) xml.endElement('property') if result.case.description: xml.startElement( 'property', { 'name': 'description', 'value': encode(result.case.description or result.case.uid), }) xml.endElement('property') xml.endElement('properties') xml.startElement( 'testcase', { 'name': result.environment.hostname, # 'assertions': '%d' % (0,), 'time': '%0.3f' % (result.duration / 1000.0, ), 'classname': classname, # 'status': '???', }) if skipped: try: mime, content = result.artifacts['check'] except KeyError: msg = '' else: msg = '\n'.join(['%s' % (c, ) for c in content]) xml.startElement('skipped', { 'message': msg, }) xml.endElement('skipped') elif errors: xml.startElement('error', { 'type': 'TestError', 'message': '%s' % (result.result, ), }) xml.endElement('error') elif failures: msg = TestCodes.MESSAGE.get(result.reason, '') xml.startElement( 'failure', { 'type': 'TestFailure', 'message': '{} ({})'.format( msg, result.case.description or result.case.uid), }) xml.endElement('failure') try: mime, content = result.artifacts['stdout'] except KeyError: pass else: xml.startElement('system-out', {}) xml.characters(self.utf8(content)) xml.endElement('system-out') try: mime, content = result.artifacts['stderr'] except KeyError: pass else: xml.startElement('system-err', {}) xml.characters(self.utf8(content)) xml.endElement('system-err') xml.endElement('testcase') xml.endElement('testsuite') xml.endDocument() finally: f_report.close() super(Junit, self).end_test(result)
class SphinxXML(object): TAG_ROOT = 'sphinx:docset' TAG_SCHEMA = 'sphinx:schema' TAG_DOCUMENT = 'sphinx:document' def __init__(self, output=stdout): self._generator = XMLGenerator(encoding='utf-8', out=output) self._output = output self._logger = logging.getLogger(self.__class__.__name__) self._schema = {'field': [], 'attr': []} self._document_id = 0 def add_field(self, name): self._schema['field'].append({"name": name}) def add_attr(self, name, attr_type, **kwargs): attr = kwargs attr['name'] = name attr['type'] = attr_type self._schema['attr'].append(attr) def start(self): self._generator.startDocument() self._generator.startElement( self.TAG_ROOT, {'xmlns:sphinx': 'http://sphinxsearch.com/'}) # print schema self._generator.ignorableWhitespace("\n\n") self._generator.startElement(self.TAG_SCHEMA, {}) for key, items in self._schema.items(): for item in items: self._generator.ignorableWhitespace("\n\t") self._generator.startElement('sphinx:{}'.format(key), attrs=item) self._generator.endElement('sphinx:{}'.format(key)) self._generator.ignorableWhitespace("\n") self._generator.endElement(self.TAG_SCHEMA) self._generator.ignorableWhitespace("\n\n") self._output.flush() def add_document(self, **kwargs): # auto-generate incrementing document IDs self._document_id += 1 self._logger.info('Adding document #{}'.format(self._document_id)) self._generator.startElement(self.TAG_DOCUMENT, {"id": str(self._document_id)}) try: for key, val in kwargs.items(): self._generator.ignorableWhitespace("\n\t") self._generator.startElement(key, {}) self._generator.characters(val) self._generator.endElement(key) except ValueError: self._logger.error('add_document failed (doc ID #{})'.format( self._document_id), exc_info=True) self._generator.ignorableWhitespace("\n") self._generator.endElement(self.TAG_DOCUMENT) self._generator.ignorableWhitespace("\n\n") self._output.flush() def end(self): self._generator.endElement(self.TAG_ROOT) self._generator.endDocument() self._logger.info('XML closed')
class Renderer(base.Renderer): def __init__( self, size, units, unitmult=1, *, margin=0, down=+1, # -1 if y axis points upwards line=None, textsize=10, textbottom=False, colour=None): self.textsize = textsize width = size[0] + 2 * margin height = size[1] + 2 * margin if down < 0: top = -size[1] self.flip = (+1, -1) else: top = 0 self.flip = (+1, +1) viewbox = "{},{} {},{}".format(-margin, top - margin, width, height) self.xml = XMLGenerator(encoding=stdout.encoding, short_empty_elements=True) self.xml.startDocument() attrs = { "xmlns": "http://www.w3.org/2000/svg", "xmlns:xlink": "http://www.w3.org/1999/xlink", "width": "{}{}".format(width * unitmult, units), "height": "{}{}".format(height * unitmult, units), "viewBox": viewbox, } if line is None: self.linewidth = 1 else: attrs["stroke-width"] = format(line) self.linewidth = line attrs.update(self._colour(colour)) self.xml.startElement("svg", attrs) text = list() if textbottom: text.append("dominant-baseline: text-after-edge") text.append("fill: currentColor") self.rulesets = [ (".outline, path, line, polyline", ("stroke: currentColor", "fill: none")), (".solid", ("fill: currentColor", "stroke: none")), ("text", text), ] self.fonts = dict() def addfont(self, id, size, family, *, italic=False, bold=False, underline=False): props = [ "font-size: {}px".format(size), "font-family: {}".format(family), ] if italic: props.append("font-style: italic") if bold: props.append("font-weight: bold") if underline: props.append("text-decoration: underline") self.fonts["." + id] = props def setdefaultfont(self, id): id = "." + id self.fonts["text, " + id] = self.fonts.pop(id) def start(self): self.rulesets.extend(self.fonts.items()) css = list() for (selector, rules) in self.rulesets: rules = "".join(map(" {};\n".format, rules)) css.append("{} {{\n{}}}\n".format(selector, rules)) self.tree(("style", dict(type="text/css"), css)) def finish(self): self.xml.endElement("svg") self.xml.endDocument() def line(self, a, b=None, *pos, **kw): attrs = dict() if b: points = (a, b) else: points = (a, ) for (n, p) in enumerate(points, 1 + 2 - len(points)): (x, y) = p attrs["x{}".format(n)] = format(x) attrs["y{}".format(n)] = format(y * self.flip[1]) self._line(attrs, *pos, **kw) def hline(self, a, b=None, *, width=None, offset=None, colour=None): a = format(a) if b is None: attrs = {"x2": a} else: attrs = {"x1": a, "x2": format(b)} self._line(attrs, width=width, offset=offset, colour=colour) def vline(self, a, b=None, *pos, **kw): a = format(a * self.flip[1]) if b is None: attrs = {"y2": a} else: attrs = {"y1": a, "y2": format(b * self.flip[1])} self._line(attrs, *pos, **kw) def _line(self, attrs, *, offset=None, width=None, colour=None): self._width(attrs, width) attrs.update(self._colour(colour)) transform = self._offset(offset) self.emptyelement("line", attrs, transform=transform) def polyline(self, points, *, width=None, colour=None): s = list() for (x, y) in points: s.append("{},{}".format(x, y * self.flip[1])) attrs = {"points": " ".join(s)} self._width(attrs, width) attrs.update(self._colour(colour)) self.emptyelement("polyline", attrs) def cubicbezier(self, a, b, c, d, *, offset=None, colour=None, width=None): attrs = dict(self._colour(colour)) s = list() for p in (a, b, c, d): s.append("{},{}".format(*map(operator.mul, p, self.flip))) attrs["d"] = "M{} C {} {} {}".format(*s) self._width(attrs, width) self.emptyelement("path", attrs, transform=self._offset(offset)) def ellipse(self, r, offset=None, *, outline=None, fill=None, width=None): [rx, ry] = r attrs = {"rx": format(rx), "ry": format(ry)} style = list() self._closed(attrs, style, outline, fill, width) if offset: (x, y) = offset attrs["cx"] = format(x) attrs["cy"] = format(y * self.flip[1]) self.emptyelement("ellipse", attrs, style=style) def polygon(self, points, *, offset=None, rotate=None, outline=None, fill=None, width=None): s = list() for (x, y) in points: s.append("{},{}".format(x, y * self.flip[1])) attrs = {"points": " ".join(s)} style = list() transform = self._offset(offset) if rotate is not None: transform.append("rotate({})".format(rotate)) self._closed(attrs, style, outline, fill, width) self.emptyelement("polygon", attrs, style=style, transform=transform) def rectangle(self, a, b=None, *, offset=None, rotate=None, outline=None, fill=None, width=None, _attrs=()): """ rectangle(a) -> <rect width=a /> rectangle(a, b) -> <rect x=a width=(b - a) /> Offset implemented independently using transform="translate(offset)" """ attrs = dict(_attrs) style = list() transform = self._offset(offset) if rotate is not None: transform.append("rotate({})".format(rotate)) if b: (x, y) = a attrs["x"] = format(x) attrs["y"] = format(y * self.flip[1]) (bx, by) = b w = bx - x h = by - y else: (w, h) = a h *= self.flip[1] # Compensate for SVG not allowing negative dimensions translate = dict() if w < 0: translate["x"] = format(w) w = -w if h < 0: translate["y"] = format(h) h = -h if translate: if b: # x and y attributes already used for a, so use a transform x = translate.get("x", 0) y = translate.get("y", 0) transform.append("translate({}, {})".format(x, y)) else: attrs.update(translate) attrs["width"] = format(w) attrs["height"] = format(h) self._closed(attrs, style, outline, fill, width) self.emptyelement("rect", attrs, style=style, transform=transform) def roundrect(self, r, *pos, **kw): (x, y) = r attrs = {"rx": format(x), "ry": format(y)} return self.rectangle(*pos, _attrs=attrs, **kw) def _closed(self, attrs, style, outline=None, fill=None, width=None): if fill and (not outline or isinstance(outline, Iterable) or \ not isinstance(fill, Iterable)): attrs["class"] = "solid" else: attrs["class"] = "outline" if isinstance(fill, Iterable): style.extend(self._colour(fill, "fill")) if isinstance(outline, Iterable): style.extend(self._colour(outline, "stroke")) self._width(attrs, width) def _width(self, attrs, width=None): if width is not None: attrs["stroke-width"] = format(width) def arc(self, r, start, end, offset=None, *, colour=None, width=None): if abs(end - start) >= 360: return self.ellipse(r, offset, outline=colour, width=width) a = list() d = list() for x in range(2): sincos = (cos, sin)[x] da = sincos(radians(start)) db = sincos(radians(end)) a.append(format(da * r[x] * self.flip[x])) d.append(format((db - da) * r[x] * self.flip[x])) large = (end - start) % 360 > 180 at = dict(self._colour(colour)) at["d"] = "M{a} a{r} 0 {large:d},0 {d}".format( a=",".join(a), r=",".join(map(format, r)), large=large, d=",".join(d), ) self._width(at, width) self.emptyelement("path", at, transform=self._offset(offset)) def text(self, text, offset=None, horiz=None, vert=None, *, angle=None, font=None, colour=None, width=None): attrs = dict() style = list() transform = list() if vert is not None: baselines = { self.CENTRE: "central", self.TOP: "text-before-edge", self.BOTTOM: "text-after-edge", } style.append(("dominant-baseline", baselines[vert])) if horiz is not None: anchors = { self.CENTRE: "middle", self.LEFT: "start", self.RIGHT: "end", } style.append(("text-anchor", anchors[horiz])) transform.extend(self._offset(offset)) if angle is not None: transform.append("rotate({})".format(angle * self.flip[1])) if font is not None: attrs["class"] = font attrs.update(self._colour(colour)) with self.element("text", attrs, style=style, transform=transform): if width is None: if isinstance(text, str): self.xml.characters(text) else: for seg in text: attrs = dict() if seg.get("overline"): attrs["text-decoration"] = "overline" self.tree(("tspan", attrs, (seg["text"], ))) return # Very hacky approximation of the size of each character # as one en wide width /= self.textsize / 2 wrapper = TextWrapper(width=width, replace_whitespace=False) hardlines = text.splitlines(keepends=True) if not hardlines: hardlines.append("") line = 0 for hardline in hardlines: wrapped = wrapper.wrap(hardline) if not wrapped: # Caused by empty string wrapped.append("") for softline in wrapped: lineattrs = { "x": "0", "y": "{}em".format(line / 0.875), "xml:space": "preserve", } self.tree(("tspan", lineattrs, (softline, ))) line += 1 def image(self, a, b=None, *, file=None, data=None, offset=None): """ image(a) -> <image width=a /> image(a, b) -> <rect x=a width=(b - a) /> Offset implemented independently using transform="translate(offset)" """ if data is None: with open(file, "rb") as file: data = file.read() data = "data:image/bmp;base64," + b64encode(data).decode("ascii") attrs = {"xlink:href": data} if b: (x, y) = a attrs["x"] = format(x) (bx, by) = b w = bx - x h = by - y if self.flip[1] < 0: y = -by attrs["y"] = format(y) else: (w, h) = a attrs["width"] = format(w) attrs["height"] = format(h) self.emptyelement("image", attrs, transform=self._offset(offset)) def addobjects(self, objects): with self.element("defs"): for d in objects: with self.element("g", dict(id=d.__name__)): d(self) def draw(self, object, offset=None, *, rotate=None, colour=None): attrs = {"xlink:href": _buildurl(fragment=object.__name__)} transform = None if rotate is not None: transform = self._offset(offset) transform.append("rotate({})".format(rotate * 90 * self.flip[1])) elif offset: (x, y) = offset attrs["x"] = format(x) attrs["y"] = format(y * self.flip[1]) attrs.update(self._colour(colour)) self.emptyelement("use", attrs, transform=transform) @contextmanager def view(self, *, offset=None, rotate=None, colour=None): transform = self._offset(offset) if rotate is not None: transform.append("rotate({})".format(rotate * self.flip[1] * 90)) attrs = dict(self._colour(colour)) with self.element("g", attrs, transform=transform): yield self def _offset(self, offset=None): if offset: (x, y) = offset y *= self.flip[1] return [("translate({}, {})".format(x, y))] else: return [] def _colour(self, colour=None, attr="color"): if colour: colour = (min(int(x * 0x100), 0xFF) for x in colour) return ((attr, "#" + "".join(map("{:02X}".format, colour))), ) else: return () @contextmanager def element(self, name, attrs=(), style=None, transform=None): attrs = dict(attrs) if style: attrs["style"] = "; ".join("{}: {}".format(*s) for s in style) if transform: attrs["transform"] = " ".join(transform) self.xml.startElement(name, attrs) yield self.xml.endElement(name) def emptyelement(self, *pos, **kw): with self.element(*pos, **kw): pass def tree(self, *elements): for e in elements: if isinstance(e, str): self.xml.characters(e) else: (name, attrs, children) = e with self.element(name, attrs): self.tree(*children)
class Logger: def __init__(self) -> None: self.logfile = os.environ.get("LOGFILE", "/dev/null") self.logfile_handle = open(self.logfile, "wb") self.xml = XMLGenerator(self.logfile_handle, encoding="utf-8") self.queue: "Queue[Dict[str, str]]" = Queue(1000) self.xml.startDocument() self.xml.startElement("logfile", attrs={}) def close(self) -> None: self.xml.endElement("logfile") self.xml.endDocument() self.logfile_handle.close() def sanitise(self, message: str) -> str: return "".join(ch for ch in message if unicodedata.category(ch)[0] != "C") def maybe_prefix(self, message: str, attributes: Dict[str, str]) -> str: if "machine" in attributes: return "{}: {}".format(attributes["machine"], message) return message def log_line(self, message: str, attributes: Dict[str, str]) -> None: self.xml.startElement("line", attributes) self.xml.characters(message) self.xml.endElement("line") def log(self, message: str, attributes: Dict[str, str] = {}) -> None: eprint(self.maybe_prefix(message, attributes)) self.drain_log_queue() self.log_line(message, attributes) def enqueue(self, message: Dict[str, str]) -> None: self.queue.put(message) def drain_log_queue(self) -> None: try: while True: item = self.queue.get_nowait() attributes = {"machine": item["machine"], "type": "serial"} self.log_line(self.sanitise(item["msg"]), attributes) except Empty: pass @contextmanager def nested(self, message: str, attributes: Dict[str, str] = {}) -> Iterator[None]: eprint(self.maybe_prefix(message, attributes)) self.xml.startElement("nest", attrs={}) self.xml.startElement("head", attributes) self.xml.characters(message) self.xml.endElement("head") tic = time.time() self.drain_log_queue() yield self.drain_log_queue() toc = time.time() self.log("({:.2f} seconds)".format(toc - tic)) self.xml.endElement("nest")
xml.startElement('system-out', {}) xml.characters(content) xml.endElement('system-out') try: mime, content = result.artifacts['stderr'] except KeyError: pass else: xml.startElement('system-err', {}) xml.characters(content) xml.endElement('system-err') xml.endElement('testcase') xml.endElement('testsuite') xml.endDocument() finally: f_report.close() super(Junit, self).end_test(result) def format(self, result): """ >>> from univention.testing.data import TestCase, TestEnvironment, \ TestResult >>> te = TestEnvironment() >>> tc = TestCase() >>> tc.uid = 'python/data.py' >>> tr = TestResult(tc, te) >>> tr.success() >>> Junit().format(tr) """
class SocialGraphExport(object): def __init__(self, userinfo, dataset, output): self.gzfd = gzip.open(output, "w") self.output = XMLGenerator(self.gzfd, "utf-8") self.level = 0 self.start_document() self.userinfo = self.load_userinfo(userinfo) for user_id in self.userinfo: self.start_element('node', {'id': str(user_id)}, False) self.start_element('data', {'key': 'screen_name'}, True) self.output.characters(self.get_screen_name(user_id)) self.end_element('data', True) self.end_element('node', False) self.dataset = os.path.abspath(dataset) self.extract_graph() self.end_document() def load_userinfo(self, inputfile): info = {} with gzip.open(inputfile, 'r') as input: for line in input: user = json.loads(line.strip()) info[int(user['id_str'])] = user return info def get_screen_name(self, user_id): return self.userinfo[user_id]['screen_name'] def attrs(self, attributes): return AttributesNSImpl( dict(((None, k), v) for (k, v) in attributes.iteritems()), {}) def start_element(self, name, attrs, nochar=False): self.output.characters(' ' * self.level) self.output.startElementNS((None, name), name, self.attrs(attrs)) if not nochar: self.output.characters('\n') self.level += 1 def end_element(self, name, nochar=False): self.level -= 1 if not nochar: self.output.characters(' ' * self.level) self.output.endElementNS((None, name), name) self.output.characters('\n') def start_document(self): self.start_element( 'graphml', { "xmlns": u"http://graphml.graphdrawing.org/xmlns", "xmlns:xsi": u"http://www.w3.org/2001/XMLSchema-instance", "xsi:schemaLocation": u"http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd", }) self.start_element( 'key', { "id": "screen_name", "for": "node", "attr.name": "screen_name", "attr.type": "string", }) self.end_element('key') self.start_element('graph', { 'id': 'G', 'edgedefault': 'directed', }) def end_document(self): self.end_element('graph') self.output.endElementNS((None, u'graphml'), u'graphml') self.output.endDocument() self.gzfd.close() def extract_graph(self): lastid = 1 lastuser = 0 users = set(self.userinfo.keys()) for user_id in users: opener = open filename = os.path.join(self.dataset, str(user_id)[:2], str(user_id) + '.fws') if not os.path.exists(filename): filename += '.gz' opener = gzip.open if not os.path.exists(filename): continue followers = set() datasize = struct.calcsize('!Q') with opener(filename, 'r') as ffile: while True: data = ffile.read(datasize) if not data: break following = struct.unpack('!Q', data)[0] followers.add(following) for following in followers.intersection(users): self.start_element( 'edge', { "id": str(lastid), "source": str(user_id), "target": str(following), "label": "follows", }, True) self.end_element('edge', True) lastid += 1 lastuser += 1 sys.stderr.write( '\rUser: %d of %d [%02d%%]' % (lastuser, len(users), lastuser * 100.0 / len(users))) sys.stderr.flush() sys.stderr.write('\nCompleted') sys.stderr.flush()
class SeqXmlWriter(SequenceWriter): """Writes SeqRecords into seqXML file. SeqXML requires the sequence alphabet be explicitly RNA, DNA or protein, i.e. an instance or subclass of Bio.Alphabet.RNAAlphabet, Bio.Alphabet.DNAAlphabet or Bio.Alphabet.ProteinAlphabet. """ def __init__(self, target, source=None, source_version=None, species=None, ncbiTaxId=None): """Create Object and start the xml generator. Arguments: - target - Output stream opened in binary mode, or a path to a file. - source - The source program/database of the file, for example UniProt. - source_version - The version or release number of the source program or database from which the data originated. - species - The scientific name of the species of origin of all entries in the file. - ncbiTaxId - The NCBI taxonomy identifier of the species of origin. """ super().__init__(target, "wb") handle = self.handle self.xml_generator = XMLGenerator(handle, "utf-8") self.xml_generator.startDocument() self.source = source self.source_version = source_version self.species = species self.ncbiTaxId = ncbiTaxId def write_header(self): """Write root node with document metadata.""" attrs = { "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance", "xsi:noNamespaceSchemaLocation": "http://www.seqxml.org/0.4/seqxml.xsd", "seqXMLversion": "0.4", } if self.source is not None: attrs["source"] = self.source if self.source_version is not None: attrs["sourceVersion"] = self.source_version if self.species is not None: if not isinstance(self.species, str): raise TypeError("species should be of type string") attrs["speciesName"] = self.species if self.ncbiTaxId is not None: if not isinstance(self.ncbiTaxId, (str, int)): raise TypeError("ncbiTaxID should be of type string or int") attrs["ncbiTaxID"] = self.ncbiTaxId self.xml_generator.startElement("seqXML", AttributesImpl(attrs)) def write_record(self, record): """Write one record.""" if not record.id or record.id == "<unknown id>": raise ValueError("SeqXML requires identifier") if not isinstance(record.id, str): raise TypeError("Identifier should be of type string") attrb = {"id": record.id} if ("source" in record.annotations and self.source != record.annotations["source"]): if not isinstance(record.annotations["source"], str): raise TypeError("source should be of type string") attrb["source"] = record.annotations["source"] self.xml_generator.startElement("entry", AttributesImpl(attrb)) self._write_species(record) self._write_description(record) self._write_seq(record) self._write_dbxrefs(record) self._write_properties(record) self.xml_generator.endElement("entry") def write_footer(self): """Close the root node and finish the XML document.""" self.xml_generator.endElement("seqXML") self.xml_generator.endDocument() def _write_species(self, record): """Write the species if given (PRIVATE).""" local_ncbi_taxid = None if "ncbi_taxid" in record.annotations: local_ncbi_taxid = record.annotations["ncbi_taxid"] if isinstance(local_ncbi_taxid, list): # SwissProt parser uses a list (which could cope with chimeras) if len(local_ncbi_taxid) == 1: local_ncbi_taxid = local_ncbi_taxid[0] elif len(local_ncbi_taxid) == 0: local_ncbi_taxid = None else: ValueError( "Multiple entries for record.annotations['ncbi_taxid'], %r" % local_ncbi_taxid) if "organism" in record.annotations and local_ncbi_taxid: local_org = record.annotations["organism"] if not isinstance(local_org, str): raise TypeError("organism should be of type string") if not isinstance(local_ncbi_taxid, (str, int)): raise TypeError("ncbiTaxID should be of type string or int") # The local species definition is only written if it differs from the global species definition if local_org != self.species or local_ncbi_taxid != self.ncbiTaxId: attr = {"name": local_org, "ncbiTaxID": str(local_ncbi_taxid)} self.xml_generator.startElement("species", AttributesImpl(attr)) self.xml_generator.endElement("species") def _write_description(self, record): """Write the description if given (PRIVATE).""" if record.description: if not isinstance(record.description, str): raise TypeError("Description should be of type string") description = record.description if description == "<unknown description>": description = "" if len(record.description) > 0: self.xml_generator.startElement("description", AttributesImpl({})) self.xml_generator.characters(description) self.xml_generator.endElement("description") def _write_seq(self, record): """Write the sequence (PRIVATE). Note that SeqXML requires a DNA, RNA or protein alphabet. """ if isinstance(record.seq, UnknownSeq): raise TypeError( "Sequence type is UnknownSeq but SeqXML requires sequence") seq = str(record.seq) if not len(seq) > 0: raise ValueError("The sequence length should be greater than 0") molecule_type = record.annotations.get("molecule_type") if molecule_type is None: raise ValueError("molecule_type is not defined") elif "DNA" in molecule_type: seqElem = "DNAseq" elif "RNA" in molecule_type: seqElem = "RNAseq" elif molecule_type == "protein": seqElem = "AAseq" else: raise ValueError("unknown molecule_type '%s'" % molecule_type) self.xml_generator.startElement(seqElem, AttributesImpl({})) self.xml_generator.characters(seq) self.xml_generator.endElement(seqElem) def _write_dbxrefs(self, record): """Write all database cross references (PRIVATE).""" if record.dbxrefs is not None: for dbxref in record.dbxrefs: if not isinstance(dbxref, str): raise TypeError("dbxrefs should be of type list of string") if dbxref.find(":") < 1: raise ValueError( "dbxrefs should be in the form ['source:id', 'source:id' ]" ) dbsource, dbid = dbxref.split(":", 1) attr = {"source": dbsource, "id": dbid} self.xml_generator.startElement("DBRef", AttributesImpl(attr)) self.xml_generator.endElement("DBRef") def _write_properties(self, record): """Write all annotations that are key value pairs with values of a primitive type or list of primitive types (PRIVATE).""" for key, value in record.annotations.items(): if key not in ("organism", "ncbi_taxid", "source"): if value is None: attr = {"name": key} self.xml_generator.startElement("property", AttributesImpl(attr)) self.xml_generator.endElement("property") elif isinstance(value, list): for v in value: if isinstance(value, (int, float, str)): attr = {"name": key, "value": v} self.xml_generator.startElement( "property", AttributesImpl(attr)) self.xml_generator.endElement("property") elif isinstance(value, (int, float, str)): attr = {"name": key, "value": str(value)} self.xml_generator.startElement("property", AttributesImpl(attr)) self.xml_generator.endElement("property")
def dump(obj, fp): xg = XMLGenerator(fp, 'utf-8') xg.startDocument() _write_item(xg, obj, root=True) xg.endDocument()
class XmlAnnotationWriter: VERSION = '1.1' def __init__(self, f): self.xmlgen = XMLGenerator(f, 'utf-8') self._level = 0 def _indent(self, newline=True): if newline: self.xmlgen.ignorableWhitespace('\n') self.xmlgen.ignorableWhitespace(' ' * self._level) def _add_version(self): self._indent() self.xmlgen.startElement('version', {}) self.xmlgen.characters(self.VERSION) self.xmlgen.endElement('version') def open_root(self): self.xmlgen.startDocument() self.xmlgen.startElement('annotations', {}) self._level += 1 self._add_version() def _add_meta(self, meta): self._level += 1 for k, v in meta.items(): if isinstance(v, OrderedDict): self._indent() self.xmlgen.startElement(k, {}) self._add_meta(v) self._indent() self.xmlgen.endElement(k) elif isinstance(v, list): self._indent() self.xmlgen.startElement(k, {}) for tup in v: self._add_meta(OrderedDict([tup])) self._indent() self.xmlgen.endElement(k) else: self._indent() self.xmlgen.startElement(k, {}) self.xmlgen.characters(v) self.xmlgen.endElement(k) self._level -= 1 def write_meta(self, meta): self._indent() self.xmlgen.startElement('meta', {}) self._add_meta(meta) self._indent() self.xmlgen.endElement('meta') def open_track(self, track): self._indent() self.xmlgen.startElement('track', track) self._level += 1 def open_image(self, image): self._indent() self.xmlgen.startElement('image', image) self._level += 1 def open_box(self, box): self._indent() self.xmlgen.startElement('box', box) self._level += 1 def open_polygon(self, polygon): self._indent() self.xmlgen.startElement('polygon', polygon) self._level += 1 def open_polyline(self, polyline): self._indent() self.xmlgen.startElement('polyline', polyline) self._level += 1 def open_points(self, points): self._indent() self.xmlgen.startElement('points', points) self._level += 1 def open_tag(self, tag): self._indent() self.xmlgen.startElement("tag", tag) self._level += 1 def add_attribute(self, attribute): self._indent() self.xmlgen.startElement('attribute', {'name': attribute['name']}) self.xmlgen.characters(attribute['value']) self.xmlgen.endElement('attribute') def _close_element(self, element): self._level -= 1 self._indent() self.xmlgen.endElement(element) def close_box(self): self._close_element('box') def close_polygon(self): self._close_element('polygon') def close_polyline(self): self._close_element('polyline') def close_points(self): self._close_element('points') def close_tag(self): self._close_element('tag') def close_image(self): self._close_element('image') def close_track(self): self._close_element('track') def close_root(self): self._close_element('annotations') self.xmlgen.endDocument()
def endDocument(self): "Finish document output; checks that the element tag stack is empty." if len(self._element_stack) != 0: raise IOError("element(s) not closed: %s" % str(self._element_stack)) XMLGenerator.endDocument(self)
class Logger: def __init__(self) -> None: self.logfile = os.environ.get("LOGFILE", "/dev/null") self.logfile_handle = codecs.open(self.logfile, "wb") self.xml = XMLGenerator(self.logfile_handle, encoding="utf-8") self.queue: "Queue[Dict[str, str]]" = Queue() self.xml.startDocument() self.xml.startElement("logfile", attrs={}) self._print_serial_logs = True @staticmethod def _eprint(*args: object, **kwargs: Any) -> None: print(*args, file=sys.stderr, **kwargs) def close(self) -> None: self.xml.endElement("logfile") self.xml.endDocument() self.logfile_handle.close() def sanitise(self, message: str) -> str: return "".join(ch for ch in message if unicodedata.category(ch)[0] != "C") def maybe_prefix(self, message: str, attributes: Dict[str, str]) -> str: if "machine" in attributes: return "{}: {}".format(attributes["machine"], message) return message def log_line(self, message: str, attributes: Dict[str, str]) -> None: self.xml.startElement("line", attributes) self.xml.characters(message) self.xml.endElement("line") def info(self, *args, **kwargs) -> None: # type: ignore self.log(*args, **kwargs) def warning(self, *args, **kwargs) -> None: # type: ignore self.log(*args, **kwargs) def error(self, *args, **kwargs) -> None: # type: ignore self.log(*args, **kwargs) sys.exit(1) def log(self, message: str, attributes: Dict[str, str] = {}) -> None: self._eprint(self.maybe_prefix(message, attributes)) self.drain_log_queue() self.log_line(message, attributes) def log_serial(self, message: str, machine: str) -> None: self.enqueue({"msg": message, "machine": machine, "type": "serial"}) if self._print_serial_logs: self._eprint(Style.DIM + "{} # {}".format(machine, message) + Style.RESET_ALL) def enqueue(self, item: Dict[str, str]) -> None: self.queue.put(item) def drain_log_queue(self) -> None: try: while True: item = self.queue.get_nowait() msg = self.sanitise(item["msg"]) del item["msg"] self.log_line(msg, item) except Empty: pass @contextmanager def nested(self, message: str, attributes: Dict[str, str] = {}) -> Iterator[None]: self._eprint(self.maybe_prefix(message, attributes)) self.xml.startElement("nest", attrs={}) self.xml.startElement("head", attributes) self.xml.characters(message) self.xml.endElement("head") tic = time.time() self.drain_log_queue() yield self.drain_log_queue() toc = time.time() self.log("({:.2f} seconds)".format(toc - tic)) self.xml.endElement("nest")
class XmlAnnotationWriter: def __init__(self, file): self.version = "1.1" self.file = file self.xmlgen = XMLGenerator(self.file, 'utf-8') self._level = 0 def _indent(self, newline=True): if newline: self.xmlgen.ignorableWhitespace("\n") self.xmlgen.ignorableWhitespace(" " * self._level) def _add_version(self): self._indent() self.xmlgen.startElement("version", {}) self.xmlgen.characters(self.version) self.xmlgen.endElement("version") def open_root(self): self.xmlgen.startDocument() self.xmlgen.startElement("annotations", {}) self._level += 1 self._add_version() def _add_meta(self, meta): self._level += 1 for k, v in meta.items(): if isinstance(v, OrderedDict): self._indent() self.xmlgen.startElement(k, {}) self._add_meta(v) self._indent() self.xmlgen.endElement(k) elif isinstance(v, list): self._indent() self.xmlgen.startElement(k, {}) for tup in v: self._add_meta(OrderedDict([tup])) self._indent() self.xmlgen.endElement(k) else: self._indent() self.xmlgen.startElement(k, {}) self.xmlgen.characters(v) self.xmlgen.endElement(k) self._level -= 1 def add_meta(self, meta): self._indent() self.xmlgen.startElement("meta", {}) self._add_meta(meta) self._indent() self.xmlgen.endElement("meta") def open_track(self, track): self._indent() self.xmlgen.startElement("track", track) self._level += 1 def open_image(self, image): self._indent() self.xmlgen.startElement("image", image) self._level += 1 def open_box(self, box): self._indent() self.xmlgen.startElement("box", box) self._level += 1 def open_polygon(self, polygon): self._indent() self.xmlgen.startElement("polygon", polygon) self._level += 1 def open_polyline(self, polyline): self._indent() self.xmlgen.startElement("polyline", polyline) self._level += 1 def open_points(self, points): self._indent() self.xmlgen.startElement("points", points) self._level += 1 def open_cuboid(self, cuboid): self._indent() self.xmlgen.startElement("cuboid", cuboid) self._level += 1 def open_tag(self, tag): self._indent() self.xmlgen.startElement("tag", tag) self._level += 1 def add_attribute(self, attribute): self._indent() self.xmlgen.startElement("attribute", {"name": attribute["name"]}) self.xmlgen.characters(attribute["value"]) self.xmlgen.endElement("attribute") def close_box(self): self._level -= 1 self._indent() self.xmlgen.endElement("box") def close_polygon(self): self._level -= 1 self._indent() self.xmlgen.endElement("polygon") def close_polyline(self): self._level -= 1 self._indent() self.xmlgen.endElement("polyline") def close_points(self): self._level -= 1 self._indent() self.xmlgen.endElement("points") def close_cuboid(self): self._level -= 1 self._indent() self.xmlgen.endElement("cuboid") def close_tag(self): self._level -= 1 self._indent() self.xmlgen.endElement("tag") def close_image(self): self._level -= 1 self._indent() self.xmlgen.endElement("image") def close_track(self): self._level -= 1 self._indent() self.xmlgen.endElement("track") def close_root(self): self._level -= 1 self._indent() self.xmlgen.endElement("annotations") self.xmlgen.endDocument()