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()
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 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_xmlgen_pi(): result = StringIO() gen = XMLGenerator(result) gen.startDocument() gen.processingInstruction("test", "data") gen.startElement("doc", {}) gen.endElement("doc") gen.endDocument() return result.getvalue() == start + "<?test data?><doc></doc>"
def test_xmlgen_pi(self): result = StringIO() gen = XMLGenerator(result) gen.startDocument() gen.processingInstruction("test", "data") gen.startElement("doc", {}) gen.endElement("doc") gen.endDocument() self.assertEqual(result.getvalue(), start + "<?test data?><doc></doc>")
class ClipExtractor(ContentHandler): def __init__(self, output, clipId): self._sink = XMLGenerator(output, 'UTF-8', True) self._locator = None self._id = clipId def setDocumentLocator(self, locator): self._locator = locator self._skip = None self._stopAt = None return self._sink.setDocumentLocator(locator) def startDocument(self): # self._prefixes = {} self.scale = self.units = None self._context = [] self._outerSvgRendered = False return self._sink.startDocument() def endDocument(self): # self._prefixes.clear() return self._sink.endDocument() def startPrefixMapping(self, prefix, uri): self._context.append(('xmlns', None, prefix, uri)) # mappings = self._prefixes.get(prefix) # if mappings is None: # self._prefixes[prefix] = mappings = [] # mappings.append(uri) return self._sink.startPrefixMapping(prefix, uri) def endPrefixMapping(self, prefix): context = self._context.pop() assert ('xmlns', None, prefix) == context[:-1] # mappings = self._prefixes.get(prefix) # assert mappings is not None # mappings.pop() return self._sink.endPrefixMapping(prefix) def startElement(self, qname, attrs): raise xml.sax.SAXNotSupportedException( 'This handler must be used with feature "%s"' ' turned on' % xml.sax.handler.feature_namespaces) # if 'xmlns' in attrs: # if self._context: # raise xml.sax.SAXNotSupportedException( # 'This document must be parsed with feature "%s"' # ' turned on' # % xml.sax.handler.feature_namespaces # ) # else: # self.startPrefixMapping('', attrs.get('xmlns')) # ns, name = self._splitNS(qname) # handler = self.ELEMENTS.get((ns, name)) # if handler and handler[0]: # update = handler[0](self, attrs, ns, name) # if not update: # if self._skip is None: # self._skip = len(self._context) + 1 # elif isinstance(update, collections.Sequence): # attrs = update[0] # if len(update) > 1: # ns, name, qname = update[1:] # self._context.append((ns, name, qname, attrs.copy())) # if self._skip is None: # return self._sink.startElement(qname, attrs) def endElement(self, qname): raise xml.sax.SAXNotSupportedException( 'This handler must be used with feature "%s"' ' turned on' % xml.sax.handler.feature_namespaces) # ns, name = self._splitNS(qname) # handler = self.ELEMENTS.get((ns, name)) # if handler and handler[1]: # handler[1](self, ns, name) # context = self._context.pop() # assert (ns, name) == context[:2] # if self._skip is None: # self._sink.endElement(qname) # elif len(self._context) < self._skip: # self._skip = None # if len(self._context) == self._stopAt: # raise self.Done('extraction complete', # self._locator.getLineNumber(), # self._locator.getColumnNumber() # ) def startElementNS(self, name, qname, attrs): if (None, 'xmlns') in attrs: self.startPrefixMapping(None, attrs.get('xmlns')) handler = self.ELEMENTS.get(name) if handler and handler[0]: update = handler[0](self, attrs, *name, qname) if not update: if self._skip is None: self._skip = len(self._context) + 1 elif isinstance(update, collections.Sequence): attrs = update[0] if len(update) > 1: name = tuple(update[1:3]) if len(update) > 3: qname = update[3] self._context.append(name + (qname, attrs.copy())) if self._skip is None: return self._sink.startElementNS(name, qname, attrs) def endElementNS(self, name, qname): handler = self.ELEMENTS.get(name) if handler and handler[1]: handler[1](self, *name, qname) context = self._context.pop() assert name == context[:2] if self._skip is None: self._sink.endElementNS(name, qname) elif len(self._context) < self._skip: self._skip = None if len(self._context) == self._stopAt: while self._context: toClose = self._context.pop() if 'xmlns' == toClose[0]: self._sink.endPrefixMapping(toClose[2]) else: self._sink.ignorableWhitespace('\n') self._sink.endElementNS(toClose[:2], toClose[2]) self._sink.endDocument() raise self.Done('extraction complete', (self._locator.getLineNumber(), self._locator.getColumnNumber())) def elementSvgEnd(self, *args): attrs = self._context[-1][3] if self.ATTR_ID in attrs and \ self._id == attrs.get(self.ATTR_ID): self._stopAt = len(self._context) - 1 def elementSvgStart(self, attrs, *args): if any((CardBackView.SVG_NAMESPACE, 'svg') == e[:2] for e in self._context): return self.ATTR_ID in attrs and \ self._id == attrs.get(self.ATTR_ID) elif not 'viewBox' in attrs and not (None, 'viewBox') in attrs: self._error(None, 'Main <svg> element has no viewBox attribute') else: try: internalSize = attrs.get((None, 'viewBox')) if internalSize is None: internalSize = attrs.get('viewBox') internalSize = self.parseBox(internalSize)[2:] externalSize = list(internalSize) units = [''] * 2 i = -1 for attr in CardBackView.ATTRS_SVG_DIMENSION: i += 1 value, unit = self._distanceAttr(attrs, attr) if unit.strip() == '%': value = None if value is not None: externalSize[i] = value units[i] = unit self.units = tuple(units) try: self.scale = tuple( e / i for e, i in zip(externalSize, internalSize)) except ZeroDivisionError as error: self._error( None, 'Found <svg> with zero dimension(s), viewBox="%s"' % attrs.get((None, 'viewBox'))) return False except: self._error() def elementUseStart(self, attrs, ns, name, qname): target = attrs.get(CardBackView.XLINK_HREF_ATTR) if not target: return False target = target.strip() if '#' == target[0] and self._id == target[1:] \ and not self._outerSvgRendered: try: outerSvg = next(e for e in self._context if (CardBackView.SVG_NAMESPACE, 'svg') == e[:2]) except StopIteration: self._error(None, 'Found <use> element outside of an <svg>') size = [] for attr in CardBackView.ATTRS_SVG_DIMENSION: value, unit = self._distanceAttr(attrs, attr) if unit.strip(): self._error( None, 'Attribute <use %s="%s" ...> is not valid' ' in this context, expected a unit-free number.' % (attr, attrs.get(None, attr))) if value is None: self._error( None, 'Attribute `%s` is missing from <use> element,' ' but is expected in this context.' % attr) size.append(value) sattrs = ('%.6f%s' % (s * v, u) for s, v, u in zip(self.scale, size, self.units)) qnames = { name: outerSvg[3].getQNameByName(name) for name in outerSvg[3].getNames() } attrMap = dict(outerSvg[3].items()) attrMap[(None, 'viewBox')] = self.boxValue((0, 0) + tuple(size)) for attr in zip(CardBackView.ATTRS_SVG_DIMENSION, sattrs): attrMap[(None, attr[0])] = attr[1] self._sink.startElementNS(outerSvg[:2], outerSvg[2], AttributesNSImpl(attrMap, qnames)) self._sink.ignorableWhitespace('\n') self._outerSvgRendered = True qnames = { name: attrs.getQNameByName(name) for name in attrs.getNames() } attrMap = dict(attrs.items()) for attr in ('x', 'y') + CardBackView.ATTRS_SVG_DIMENSION: qnames.pop((None, attr), None) attrMap.pop((None, attr), None) self._sink.startElementNS((ns, name), qname, AttributesNSImpl(attrMap, qnames)) self._sink.endElementNS((ns, name), qname) self._sink.ignorableWhitespace('\n') return False def elementDefsStart(self, attrs, *args): if not self._outerSvgRendered: self._error( None, 'Element <use xlink:href="#%s" ...> must precede' ' the <defs> element in this context.' % self._id) self._skip = None return True ATTR_ID = (None, 'id') ELEMENTS = { (CardBackView.SVG_NAMESPACE, 'svg'): (elementSvgStart, elementSvgEnd), (CardBackView.SVG_NAMESPACE, 'use'): (elementUseStart, None), (CardBackView.SVG_NAMESPACE, 'defs'): (elementDefsStart, None), } def characters(self, content): if self._skip is None: return self._sink.characters(content) def ignorableWhitespace(self, whitespace): if self._skip is None: return self._sink.ignorableWhitespace(whitespace) def processingInstruction(self, target, data): if self._skip is None: return self._sink.processingInstruction(target, data) def skippedEntity(self, name): if self._skip is None: return self._sink.skippedEntity(name) def _error(self, error=True, message=''): if error == True: error = sys.exc_info()[1] if error is None: assert message error = SAXParseException(message, None, self._locator) elif not isinstance(error, SAXParseException): msg = error.args[0] if error.args else '' if msg: msg += ' ' if message: msg += message + ' ' error.args = (msg + 'at line %d, column %d.' % (self._locator.getLineNumber(), self._locator.getColumnNumber()), ) + error.args[1:] raise error class Done(xml.sax.SAXException): pass
# regression test for SAX 2.0