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 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 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 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 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]