def __init__(self, out = sys.stdout, encoding = "utf-8", indent = "", addindent = "", newl = ""): XMLGenerator.__init__(self, out, encoding) # XMLGenerator does not export _write() self.write = self.ignorableWhitespace self.indents = [indent] self.addindent = addindent self.newl = newl
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 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 _close(self): """close an already opened channel""" generator = XMLGenerator(self.worker) generator.endElement('channel') # XXX self.worker.write('\n') self.exit = 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 __init__(self, break_into=None, break_after=1000, out=None, *args, **kwargs): XMLGenerator.__init__(self, out, *args, **kwargs) self.out_file = out self.break_into = break_into self.break_after = break_after self.context = [] self.count = 0
class ExportExtractor(XMLFilterBase): def __init__(self, file): XMLFilterBase.__init__(self) self.generator = XMLGenerator(file, 'UTF-8') self.generator.startPrefixMapping(u'', u'http://www.eucalyptus.com/ns/reporting/export/2012-08-24/') self.replyData = StringIO() self.replyGenerator = XMLGenerator( self.replyData, 'UTF-8' ) self.switchTarget( self.replyGenerator ) def startDocument(self): self.generator.startDocument() XMLFilterBase.startDocument(self) def endElementNS(self, name, qname): XMLFilterBase.endElementNS(self, name, qname) namespace, element = name if namespace == u'http://www.eucalyptus.com/ns/reporting/export/2012-08-24/' and element == u'Export': self.switchTarget( self.replyGenerator ) def startElementNS(self, name, qname, attrs): namespace, element = name if namespace == u'http://www.eucalyptus.com/ns/reporting/export/2012-08-24/' and element == u'Export': self.switchTarget( self.generator ) XMLFilterBase.startElementNS(self, name, qname, attrs) def switchTarget(self, target): self._cont_handler = target self._dtd_handler = target self._ent_handler = target self._err_handler = target def getReply(self): return self.replyData.getvalue()
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()
def __init__(self, out, enc, reader): XMLGenerator.__init__(self, GetFile(out, "w"), enc) self.reader = reader self.num_read_nodes = 0 self.num_read_ways = 0 self.num_read_relations = 0
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 __init__(self, output, encoding, top_level_tag, attrs): xml_writer = XMLGenerator(output, encoding, True) xml_writer.startDocument() xml_writer.startElement(top_level_tag, attrs) self._xml_writer = xml_writer self.top_level_tag = top_level_tag self.ident=4 self._xml_writer.characters('\n')
def startElement(self, tag, attrs={}): attrs_write = {'CREATED': gMF(attrs['created_mindmap']), 'MODIFIED': gMF(max(attrs['modified_mindmap'], attrs['modified_openerp'])), 'ID': attrs['id_mindmap'] or 'ID_' + str(random.randint(1, 10**10)), 'TEXT': attrs['name'], } XMLGenerator.startElement(self, tag, attrs_write)
def startElement(self, name, attrs, indent = True, newl = True): if indent: self.ignorableWhitespace("".join(self.indents)) self.indents.append(self.addindent) XMLGenerator.startElement(self, name, attrs) if newl: self.ignorableWhitespace(self.newl)
def endElement(self, name, indent = True, newl = True): self.indents.pop() if indent: self.ignorableWhitespace("".join(self.indents)) XMLGenerator.endElement(self, name) if newl: self.ignorableWhitespace(self.newl)
def characters(self, content): try: if content.lstrip().startswith("<"): etree.fromstring(content) self._write(content) else: XMLGenerator.characters(self, content) except (AttributeError, Exception): #TODO could be more specific on errors caught XMLGenerator.characters(self, content)
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()
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()
def test_conditional_font(self): """Test to verify font style written correctly.""" class WS(): conditional_formatting = ConditionalFormatting() worksheet = WS() # Create cf rule redFill = Fill() redFill.start_color.index = 'FFEE1111' redFill.end_color.index = 'FFEE1111' redFill.fill_type = Fill.FILL_SOLID whiteFont = Font() whiteFont.color.index = "FFFFFFFF" worksheet.conditional_formatting.add('A1:A3', CellIsRule(operator='equal', formula=['"Fail"'], stopIfTrue=False, font=whiteFont, fill=redFill)) worksheet.conditional_formatting.setDxfStyles(self.workbook) # First, verify conditional formatting xml 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:A3"> <cfRule dxfId="0" operator="equal" priority="1" type="cellIs"> <formula>"Fail"</formula> </cfRule> </conditionalFormatting> """) assert diff is None, diff # Second, verify conditional formatting dxf styles w = StyleWriter(self.workbook) w._write_dxfs() xml = get_xml(w._root) diff = compare_xml(xml, """ <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"> <dxfs count="1"> <dxf> <font> <color rgb="FFFFFFFF" /> </font> <fill> <patternFill patternType="solid"> <fgColor rgb="FFEE1111" /> <bgColor rgb="FFEE1111" /> </patternFill> </fill> </dxf> </dxfs> </styleSheet> """) assert diff is None, diff
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 startElement(self, name, attrs={}, children=False): """Starts an XML element. Arguments: name -- String of element name. attrs -- Dictionary of element attributes. children -- Boolean, whether the element has children or not. """ self.ignorableWhitespace(self._indent * self._level) XMLGenerator.startElement(self, name, attrs)
def __init__(self, out=None, encoding="iso-8859-1", increment=2): """out Opened output file; sys.stdout if None given. encoding Character encoding to use. increment Indentation increment to use. """ XMLGenerator.__init__(self, out=out, encoding=encoding) self._element_stack = [] self._in_cdata = False self._indent_increment = increment self._newline_flag = False self._indent_level = 0
def endElement(self, tagname=None, forceNewLine=True): """Finish the current element. The tagname argument is not required and is in fact currently ignored, since the internal element tagname stack is used.""" self._indent_level -= self._indent_increment if not self._newline_flag: self.ignorableWhitespace(' ' * self._indent_level) XMLGenerator.endElement(self, self._element_stack.pop()) self._newline_flag = True if forceNewLine: self.newline()
def __init__(self, root, out, encoding='UTF-8', acceptAttributes=True, acceptUnknownTags=True, shortEmptyElements=True): ''' @param out: file object with write The file object to write the updated xml, needs to have a 'write' method that accepts text. @see: Digester.__init__ @see: XMLGenerator.__init__ ''' XMLGenerator.__init__(self, out, encoding, shortEmptyElements) Digester.__init__(self, root, acceptAttributes, acceptUnknownTags)
def startElement(self, tagname, forceNewLine=True, **attrs): """Start a new element, with appropriate indentation.""" if not self._newline_flag: self.ignorableWhitespace(' ' * self._indent_level) XMLGenerator.startElement(self, tagname, self.translate_name_aliases(**attrs)) self._element_stack.append(tagname) self._newline_flag = True self._indent_level += self._indent_increment if forceNewLine: self.newline()
def startElement(self, name, attrs): pos = name.find(':') tag = name if pos == -1 else name[pos+1:] attr = self.rules.get(tag) XMLGenerator.startElement(self, name, attrs) if attr is None: self.trans = False elif attr is True: self.trans = True else: self.trans = attrs.get(attr[0]) == attr[1]
def __init__(self, out, enc, reader=None, check_intersection=None, poly=None, poly_buffered=None): XMLGenerator.__init__(self, GetFile(out, "w"), enc) self.reader = reader self.check_intersection = check_intersection self.poly = [] self.poly.append(poly) self.poly.append(poly_buffered) self.poly_num = 2 self.num_read_nodes = 0 self.num_read_ways = 0 self.num_read_relations = 0
def endElementNS(self, ns, el) : self.__level = self.__level - 1 if self.__last == "end" : self.ignorableWhitespace("\n") if self.__last == 'end' : self.ignorableWhitespace(" " * (self.__level * self.__indent)) XMLGenerator.endElementNS(self, ns, el) self.__last = 'end'
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 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_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 check_parse(self, f): from xml.sax import parse result = StringIO() parse(f, XMLGenerator(result, 'utf-8')) self.assertEqual(result.getvalue(), xml_str(self.data, 'utf-8'))
def test_xmlgen_encoding_bytes(self): encodings = ('iso-8859-15', 'utf-8', 'utf-8-sig', 'utf-16', 'utf-16be', 'utf-16le', 'utf-32', 'utf-32be', 'utf-32le') for encoding in encodings: result = self.ioclass() gen = XMLGenerator(result, encoding=encoding) gen.startDocument() gen.startElement('doc', {'a': '€'}) gen.characters('€'.encode(encoding)) gen.ignorableWhitespace(' '.encode(encoding)) gen.endElement('doc') gen.endDocument() self.assertEqual( result.getvalue(), self.xml('<doc a="€">€ </doc>', encoding=encoding))
def test_1463026_3(self): result = StringIO() gen = XMLGenerator(result) gen.startDocument() gen.startPrefixMapping('my', 'qux') gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'): 'c'}) gen.endElementNS(('qux', 'a'), 'a') gen.endPrefixMapping('my') gen.endDocument() self.assertEqual(result.getvalue(), start + '<my:a xmlns:my="qux" b="c"></my:a>')
class XMLSerializer: """ Serializes data to XML for MKM requests. Original author: https://github.com/evonove """ def __init__(self): self.generator = None def serialize(self, data): """ Serializes data to XML so that it can be sent to backend, if data is not a dictionary. :raise SerializationException: On serialize error. :param data: A dictionary containing the data to serialize :return: Returns a string containing data serialized to XML """ if not isinstance(data, dict): raise SerializationException( "Can't serialize data, must be a dictionary.") stream = StringIO() self.generator = XMLGenerator(stream, 'utf-8') self.generator.startDocument() self.generator.startElement('request', {}) self._parse(data) self.generator.endElement('request') self.generator.endDocument() return stream.getvalue() def _parse(self, data, previous_element_tag=None): """ Recursively parses data and creates the relative elements. :param data: Data to parse :param previous_element_tag: When parsing a list we pass the previous element tag :return: """ if isinstance(data, dict): for key in data: value = data[key] self._parse(value, key) elif isinstance(data, (list, tuple)): for item in data: if isinstance(item, dict): self.generator.startElement(previous_element_tag, {}) self._parse(item, previous_element_tag) if isinstance(item, dict): self.generator.endElement(previous_element_tag) else: self.generator.startElement(previous_element_tag, {}) self.generator.characters(f'{data}') self.generator.endElement(previous_element_tag)
class Preferences(connector.Publisher): def __setattr__(self, attr, value): if not hasattr(self, attr) or getattr(self, attr) != value: self.__dict__[attr] = value self.issue(CHANGED, attr, value) def load(self, filename=None): import xml.sax from xml.sax.xmlreader import InputSource content_handler = XMLPrefReader(pref=self) error_handler = ErrorHandler() entity_resolver = EntityResolver() dtd_handler = DTDHandler() try: input = open(filename, "r") input_source = InputSource() input_source.setByteStream(input) xml_reader = xml.sax.make_parser() xml_reader.setContentHandler(content_handler) xml_reader.setErrorHandler(error_handler) xml_reader.setEntityResolver(entity_resolver) xml_reader.setDTDHandler(dtd_handler) xml_reader.parse(input_source) input.close except: pass def save(self, filename=None): if len(self.__dict__) == 0 or filename == None: return from xml.sax.saxutils import XMLGenerator try: file = open(filename, 'w') except (IOError, os.error), value: import sys sys.stderr('cannot write preferences into %s: %s' % ( ` filename `, value[1])) return writer = XMLGenerator(out=file, encoding=self.system_encoding) writer.startDocument() defaults = Preferences.__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 writer.characters(' ') writer.startElement('%s' % key, {}) if type(value) == PointType: to_write = '(%g, %g)' % tuple(value) writer.characters('Point%s' % to_write) else: writer.characters('%s' % ` value `) writer.endElement('%s' % key) writer.characters('\n') writer.endElement('preferences') writer.endDocument() file.close
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(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")
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("(finished: {}, in {:.2f} seconds)".format( message, toc - tic)) self.xml.endElement("nest")
def test_1463026_2_empty(self): result = StringIO() gen = XMLGenerator(result, short_empty_elements=True) gen.startDocument() gen.startPrefixMapping(None, 'qux') gen.startElementNS(('qux', 'a'), 'a', {}) gen.endElementNS(('qux', 'a'), 'a') gen.endPrefixMapping(None) gen.endDocument() self.assertEqual(result.getvalue(), start + '<a xmlns="qux"/>')
def test_xmlgen_content_escape(self): result = self.ioclass() gen = XMLGenerator(result) gen.startDocument() gen.startElement('doc', {}) gen.characters('<huhei&') gen.endElement('doc') gen.endDocument() self.assertEqual(result.getvalue(), self.xml('<doc><huhei&</doc>'))
def test_xmlgen_attr_escape(self): result = self.ioclass() gen = XMLGenerator(result) gen.startDocument() gen.startElement('doc', {'a': '"'}) gen.startElement('e', {'a': "'"}) gen.endElement('e') gen.startElement('e', {'a': '\'"'}) gen.endElement('e') gen.startElement('e', {'a': '\n\r\t'}) gen.endElement('e') gen.endElement('doc') gen.endDocument() self.assertEqual( result.getvalue(), self.xml( '<doc a=\'"\'><e a="\'"></e><e a="\'""></e><e a=" 	"></e></doc>' ))
def test_1463026_3_empty(self): result = self.ioclass() gen = XMLGenerator(result, short_empty_elements=True) gen.startDocument() gen.startPrefixMapping('my', 'qux') gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'): 'c'}) gen.endElementNS(('qux', 'a'), 'a') gen.endPrefixMapping('my') gen.endDocument() self.assertEqual(result.getvalue(), self.xml('<my:a xmlns:my="qux" b="c"/>'))
def test_1463026_2(self): result = self.ioclass() gen = XMLGenerator(result) gen.startDocument() gen.startPrefixMapping(None, 'qux') gen.startElementNS(('qux', 'a'), 'a', {}) gen.endElementNS(('qux', 'a'), 'a') gen.endPrefixMapping(None) gen.endDocument() self.assertEqual(result.getvalue(), self.xml('<a xmlns="qux"></a>'))
def test_xmlgen_unencodable(self): result = self.ioclass() gen = XMLGenerator(result, encoding='ascii') gen.startDocument() gen.startElement('doc', {'a': '€'}) gen.characters('€') gen.endElement('doc') gen.endDocument() self.assertEqual( result.getvalue(), self.xml('<doc a="€">€</doc>', encoding='ascii'))
def __init__(self, file): super().__init__(file, "1.0") self.xmlgen = XMLGenerator(self.file, 'utf-8') self._level = 0
class _XmlAnnotationWriter(_AnnotationWriter): def __init__(self, file): super().__init__(file, "1.0") 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 type(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 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_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()
def gen(): stream = io.StringIO() try: writer = XMLGenerator(stream, 'utf-8') writer.startDocument() start_element_attrs = {} if xmlns and schema_name: start_element_attrs['xmlns'] = xmlns start_element_attrs[ 'xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance' schema_url = get_xml_schema_url(xmlns, schema_name) start_element_attrs['xsi:schemaLocation'] = '{} {}'.format( xmlns, schema_url) for elem_name in root_element_name.split('.'): writer.startElement(elem_name, attrs=start_element_attrs) stream.seek(0) yield stream.getvalue() stream.truncate(0) i = 0 iterator = models.iterator( chunk_size=10000) if isinstance(models, QuerySet) else models for m in iterator: model_to_xml(writer, m, field_map, model_name, related_models_filter_function= related_models_filter_function, show_sequence_index=show_sequence_index, sequence_index=i) stream.seek(0) yield stream.getvalue() stream.truncate(0) i += 1 if sub_models is not None and sub_models_field_map is not None and sub_models_element_name is not None: writer.startElement(sub_models_element_name, attrs={}) stream.seek(0) yield stream.getvalue() stream.truncate(0) i = 0 iterator = sub_models.iterator(chunk_size=10000) if isinstance( sub_models, QuerySet) else sub_models for m in iterator: model_to_xml(writer, m, sub_models_field_map, sub_model_name, related_models_filter_function= sub_related_models_filter_function, show_sequence_index=show_sequence_index, sequence_index=i) stream.seek(0) yield stream.getvalue() stream.truncate(0) i += 1 writer.endElement(sub_models_element_name) for elem_name in root_element_name.split('.')[::-1]: writer.endElement(elem_name) writer.endDocument() stream.seek(0) yield stream.getvalue() except Exception as e: logger.error('Error in iterator: {}'.format(str(e))) raise finally: stream.close()
class XmlItemExporter(BaseItemExporter): def __init__(self, file, **kwargs): self.item_element = kwargs.pop('item_element', 'item') self.root_element = kwargs.pop('root_element', 'items') super().__init__(**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, str): self.xg.characters(serialized_value) else: self.xg.characters(str(serialized_value)) self.xg.endElement(name) self._beautify_newline()
def __init__(self, destination, encoding): XMLGenerator.__init__(self, destination, encoding)
def endElement(self, name): """End and XML element of the given name.""" XMLGenerator.endElement(self, name) self.write(u'\n')
def test_xmlgen_pi(self): result = self.ioclass() gen = XMLGenerator(result) gen.startDocument() gen.processingInstruction('test', 'data') gen.startElement('doc', {}) gen.endElement('doc') gen.endDocument() self.assertEqual(result.getvalue(), self.xml('<?test data?><doc></doc>'))
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>'))
def check_parseString(self, s): from xml.sax import parseString result = StringIO() parseString(s, XMLGenerator(result, 'utf-8')) self.assertEqual(result.getvalue(), xml_bytes(self.data, 'utf-8'))
def test_xmlgen_content_empty(self): result = self.ioclass() gen = XMLGenerator(result, short_empty_elements=True) gen.startDocument() gen.startElement('doc', {}) gen.characters('huhei') gen.endElement('doc') gen.endDocument() self.assertEqual(result.getvalue(), self.xml('<doc>huhei</doc>'))
def test_xmlgen_ignorable_empty(self): result = StringIO() gen = XMLGenerator(result, short_empty_elements=True) gen.startDocument() gen.startElement("doc", {}) gen.ignorableWhitespace(" ") gen.endElement("doc") gen.endDocument() self.assertEqual(result.getvalue(), start + "<doc> </doc>")
def test_5027_2(self): result = self.ioclass() 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(), self.xml( '<a:g1 xmlns:a="http://example.com/ns"><a:g2 xml:lang="en">Hello</a:g2></a:g1>' ))
def test_xmlgen_ignorable_empty(self): result = self.ioclass() gen = XMLGenerator(result, short_empty_elements=True) gen.startDocument() gen.startElement('doc', {}) gen.ignorableWhitespace(' ') gen.endElement('doc') gen.endDocument() self.assertEqual(result.getvalue(), self.xml('<doc> </doc>'))
def func(out): gen = XMLGenerator(out) gen.startDocument() gen.startElement('doc', {})
def test_xmlgen_fragment(self): result = self.ioclass() gen = XMLGenerator(result) gen.startElement('foo', {'a': '1.0'}) gen.characters('Hello') gen.endElement('foo') gen.startElement('bar', {'b': '2.0'}) gen.endElement('bar') self.assertEqual( result.getvalue(), self.xml('<foo a="1.0">Hello</foo><bar b="2.0"></bar>') [len(self.xml('')):])
def test_xmlgen_ns_empty(self): result = self.ioclass() gen = XMLGenerator(result, short_empty_elements=True) gen.startDocument() gen.startPrefixMapping('ns1', ns_uri) gen.startElementNS((ns_uri, 'doc'), 'ns1:doc', {}) gen.startElementNS((None, 'udoc'), None, {}) gen.endElementNS((None, 'udoc'), None) gen.endElementNS((ns_uri, 'doc'), 'ns1:doc') gen.endPrefixMapping('ns1') gen.endDocument() self.assertEqual( result.getvalue(), self.xml('<ns1:doc xmlns:ns1="%s"><udoc/></ns1:doc>' % ns_uri))
def test_xmlgen_ns_empty(self): result = StringIO() gen = XMLGenerator(result, short_empty_elements=True) gen.startDocument() gen.startPrefixMapping("ns1", ns_uri) gen.startElementNS((ns_uri, "doc"), "ns1:doc", {}) # add an unqualified name gen.startElementNS((None, "udoc"), None, {}) gen.endElementNS((None, "udoc"), None) gen.endElementNS((ns_uri, "doc"), "ns1:doc") gen.endPrefixMapping("ns1") gen.endDocument() self.assertEqual(result.getvalue(), start + \ ('<ns1:doc xmlns:ns1="%s"><udoc/></ns1:doc>' % ns_uri))