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
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 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()
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 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 __init__(self, output, encoding='utf-8'): writer = XMLGenerator(output, encoding) writer.startDocument() writer.startPrefixMapping(u'sparql',SPARQL_XML_NAMESPACE) writer.startPrefixMapping(u'xml', XML_NAMESPACE) writer.startElementNS((SPARQL_XML_NAMESPACE, u'sparql'), u'sparql', AttributesNSImpl({}, {})) self.writer = writer self._output = output self._encoding = encoding
def test_1463026_3(): 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() return result.getvalue() == start + '<my:a xmlns:my="qux" b="c"></my:a>'
def test_1463026_2(): result = StringIO() gen = XMLGenerator(result) gen.startDocument() gen.startPrefixMapping(None, "qux") gen.startElementNS(("qux", "a"), "a", {}) gen.endElementNS(("qux", "a"), "a") gen.endPrefixMapping(None) gen.endDocument() return result.getvalue() == start + '<a xmlns="qux"></a>'
def test_1463026_2_empty(self): result = self.ioclass() 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(), self.xml('<a xmlns="qux"/>'))
def test_1463026_2(self): result = StringIO() 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(), start+'<a xmlns="qux"></a>')
def test_1463026_2(self): result = StringIO() 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(), start + '<a xmlns="qux"></a>')
def __init__(self, output, encoding='utf-8'): writer = XMLGenerator(output, encoding) writer.startDocument() writer.startPrefixMapping(u'sparql', SPARQL_XML_NAMESPACE) writer.startPrefixMapping(u'xml', XML_NAMESPACE) writer.startElementNS( (SPARQL_XML_NAMESPACE, u'sparql'), u'sparql', AttributesNSImpl({}, {})) self.writer = writer self._output = output self._encoding = encoding self._results = False
def test_1463026_3_empty(self): result = StringIO() 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(), start + '<my:a xmlns:my="qux" b="c"/>')
def test_1463026_3(): 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() return result.getvalue() == start+'<my:a xmlns:my="qux" b="c"></my:a>'
def test_1463026_3_empty(self): result = StringIO() 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(), start+'<my:a xmlns:my="qux" b="c"/>')
def test_1463026_3(self): result = self.ioclass() 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(), self.xml('<my:a xmlns:my="qux" b="c"></my:a>'))
def test_1463026_3(self): result = self.ioclass() 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(), self.xml('<my:a xmlns:my="qux" b="c"></my:a>'))
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))
def write_to(self, output): """Write indented XML to this file-like object.""" generator = XMLGenerator(output, 'UTF-8', short_empty_elements=True) generator.startDocument() prefixes_used = list( self.add_prefixes_used(self.prefix_namespaces, set())) prefixes_used.sort() for prefix in prefixes_used: generator.startPrefixMapping(prefix, self.prefix_namespaces[prefix]) self.sax_to(generator, prefix_namespaces=self.prefix_namespaces) for prefix in reversed(prefixes_used): generator.endPrefixMapping(prefix) generator.endDocument()
def test_xmlgen_ns(): result = StringIO() gen = XMLGenerator(result) 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() return result.getvalue() == start + ('<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' % ns_uri)
class _PrettyXMLWriter(object): def __init__(self, output, encoding='UTF-8', namespace=('bibtex', 'http://bibtexml.sf.net/'), header=True): self.prefix, self.uri = namespace self.generator = XMLGenerator(output, encoding=encoding) if header: self.generator.startDocument() self.generator.startPrefixMapping(self.prefix, self.uri) self.stack = [] def write(self, data): self.generator.characters(data) def newline(self): self.write('\n') def indent_line(self): self.write(' ' * (len(self.stack) * 4)) def start(self, tag, attrs=None, newline=True): if attrs is None: attrs = {} else: attrs = {(None, key): value for key, value in attrs.items()} self.indent_line() self.stack.append(tag) self.generator.startElementNS((self.uri, tag), tag, AttributesImpl(attrs)) if newline: self.newline() def end(self, indent=True): tag = self.stack.pop() if indent: self.indent_line() self.generator.endElementNS((self.uri, tag), tag) self.newline() def element(self, tag, data): self.start(tag, newline=False) self.write(data) self.end(indent=False) def close(self): self.generator.endDocument()
def test_xmlgen_ns(): result = StringIO() gen = XMLGenerator(result) 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() return result.getvalue() == start + \ ('<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' % ns_uri)
def test_xmlgen_ns(self): result = self.ioclass() gen = XMLGenerator(result) 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(), self.xml( '<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' % ns_uri))
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", {}) # 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(), self.xml('<ns1:doc xmlns:ns1="%s"><udoc/></ns1:doc>' % ns_uri))
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 get(self, project_id): PROM_EXPORT.labels('codebook', 'qdc').inc() project, _ = self.get_project(project_id) tags = list(project.tags) self.set_header('Content-Type', 'text/xml; charset=utf-8') self.set_header('Content-Disposition', 'attachment; filename="codebook.qdc"') # http://schema.qdasoftware.org/versions/Codebook/v1.0/Codebook.xsd output = XMLGenerator(WriteAdapter(self.write), encoding='utf-8', short_empty_elements=True) output.startDocument() output.startPrefixMapping(None, 'urn:QDA-XML:codebook:1.0') refi_qda.write_codebook(tags, output) output.endPrefixMapping(None) output.endDocument() return self.finish()
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 toXml( self, result, out ): atom = "http://www.w3.org/2005/Atom" tf = "http://sdk.nokia.com/test-framework/ns/1.0" gen = XMLGenerator( out, 'utf-8' ) gen.startDocument() gen.startPrefixMapping( 'atom', atom) gen.startPrefixMapping( 'tf', tf ) startElement( gen, atom, 'entry' ) writeElement( gen, atom, 'title', result.constructTitle() ) writeElement( gen, atom, 'updated', datetime.datetime.now().isoformat() ) writeElement( gen, tf, 'errorSummary', exitStatusAsString( result.status() ) ) writeElement( gen, tf, 'host', socket.gethostname() ) if result._testStart != None: writeElement( gen, tf, 'testStart', result._testStart.isoformat() ) else: result._internalErrors.append( "Result generator: no start timestamp found." ) if result._testEnd != None: writeElement( gen, tf, 'testEnd', result._testEnd.isoformat() ) else: result._internalErrors.append( "Result generator: no end timestamp found." ) startElement( gen, tf, 'installer' ) writeElement( gen, tf, 'sourceUrl', result._installerSourceLocation ) writeElement( gen, tf, 'platform', result._installerTargetPlatform ) #TODO revision endElement( gen, tf, 'installer' ) if result._testcase != None: startElement( gen, tf, 'testCase' ) writeElement( gen, tf, 'name', result._testcase.name() ) writeElement( gen, tf, 'path', result._testcase.path() ) writeElement( gen, tf, 'installScript', result._testcase.installscript() ) endElement( gen, tf, 'testCase' ) else: result._internalErrors.append( "Result generator: No test case given." ) if result._installationResult != None: startElement( gen, tf, 'installationResult' ) writeElement( gen, tf, 'exitCode', str( result._installationResult.exitCode ) ) writeElement( gen, tf, 'exitStatus', exitStatusAsString( result._installationResult.exitStatus ) ) endElement( gen, tf, 'installationResult' ) else: result._internalErrors.append( "Result generator: No installation result given." ) startElement( gen, tf, 'checkerResult' ) for err in result._checkerErrors: writeElement( gen, tf, 'error', err ) endElement( gen, tf, 'checkerResult' ) startElement( gen, tf, 'virtualMachine' ) writeElement( gen, tf, 'path', result._vm.vmxPath() ) writeElement( gen, tf, 'platform', result._vm.ostype() ) writeElement( gen, tf, 'snapshot', result._vm.snapshot() ) endElement( gen, tf, 'virtualMachine' ) startElement( gen, tf, 'internalErrors' ) for i in result._internalErrors: writeElement( gen, tf, 'internalError', str( i ) ) endElement( gen, tf, 'internalErrors' ) if result._errorSnapshot != None: writeElement( gen, tf, 'errorSnapshot', result._errorSnapshot ) endElement( gen, atom, 'entry' ) gen.endDocument()
class CombineSVG(object): """ CombineSVG combines multiple SVGa into a single SVG `output` stream. Different `layer_name`s are added into a separate SVG layers (`<g>`). Empty layers are stripped. Note: Only the simplest SVGs with <path> elements are supported (e.g. MapServer Cairo SVG output format). """ def __init__(self, output, root_id=None): self.first = True self.root_id = root_id self.out = XMLGenerator(output, "utf-8") self.out.startPrefixMapping(None, SVG_NS) self.out.startDocument() self.groups = [] self.actual_groups = [] def push_group(self, name): """ push_group adds a new SVG layer name to be used for the next SVG sub-document with add. """ self.groups.append(name) def pop_group(self): """ pop_group removes the last added SVG layer. """ self.groups = self.groups[:-1] def balance_group(self): """ balance_group opens/closes <g> tags as necessary. We can't create the <g> tags in push/pop_group as we do not want them for empty layers. """ for want, got in zip_longest(self.groups, self.actual_groups): if want == got: continue if got is None: self.out.startElement("g", {"id": want}) self.out.characters("\n") self.actual_groups.append(want) self.balance_group() return if want is None or want != got: self.out.endElement("g") self.out.characters("\n") self.actual_groups.pop() self.balance_group() return def __enter__(self): return self def __exit__(self, *exc): self.close() def add(self, r): """ Add an SVG layer with `layer_name` from file object `r`. """ for evt, elem in iterparse(r, events=("start", "end")): if evt == "start" and self.first and elem.tag == SVG_TAG: # copy <svg> from first doc, otherwise ignore svg_attrib = {(None, k): v for k, v in elem.attrib.items()} if self.root_id: svg_attrib[(None, "id")] = self.root_id self.out.startElementNS((SVG_NS, "svg"), "svg", svg_attrib) self.out.characters("\n") continue if evt == "end" and self.first and elem.tag == RECT_TAG: # copy only first <rect>, used by Mapserver to draw blank canvas, but we # need all additional to be transparent. self.balance_group() self.out.startElement("rect", elem.attrib) self.out.endElement("rect") self.out.characters("\n") elif evt == "end" and elem.tag == PATH_TAG: # all drawings are included in <path> tags self.balance_group() self.out.startElement("path", elem.attrib) self.out.endElement("path") self.out.characters("\n") self.first = False def close(self): """ Close all open SVG XML elements. """ self.groups = [] self.balance_group() self.out.endElementNS((SVG_NS, "svg"), "svg") self.out.endDocument()
class SkosCoreWriter: xmlns = { 'rdf': u'http://www.w3.org/1999/02/22-rdf-syntax-ns#', 'rdfs': u'http://www.w3.org/2000/01/rdf-schema#', 'skos': u'http://www.w3.org/2004/02/skos/core#', 'xml': u'http://www.w3.org/XML/1998/namespace', 'foaf': u'http://xmlns.com/foaf/0.1/', 'dc': u'http://purl.org/dc/elements/1.1/', 'dcterms': u'http://purl.org/dc/terms/', } def __init__(self, output, encoding='utf-8', source='http://platecom.inter-cultura.com/concepts', lang=['en','es','fr','de','nl']): self._l = lang self._term_url = lambda t: "%s#%s" % (source, t) self._concept_url = lambda c: self._term_url(c.get_prefered(self._l)[0]) self._xml = XMLGenerator(output, encoding) self._xml.startDocument() for prefix, uri in self.xmlns.items(): self._xml.startPrefixMapping(prefix or None, uri) pass def close(self): self._xml.endDocument() return def _build_tag(self, tag): if type(tag) == type(""): qname = tag tag = (None, tag) else: qname = "%s:%s" % tag tag = (self.xmlns[tag[0]], tag[1]) return tag, qname def startNode(self, tag, attr={}): tag, qname = self._build_tag(tag) self._xml.startElementNS(tag, qname, attr) def endNode(self, tag): tag, qname = self._build_tag(tag) self._xml.endElementNS(tag, qname) def simpleNode(self, tag, value, attr={}): self.startNode(tag, attr) if value: self._xml.characters(value) self.endNode(tag) def writeThesaurus(self, t): self.startNode(('rdf', 'RDF'), {}) for c in t.concepts(): self.writeConcept(t[c]) self.endNode(('rdf', 'RDF')) def writeConcept(self, c): if c.get_prefered(self._l) == []: return # No escribo conceptos sin términos attr={ (self.xmlns['rdf'],'about'): self._concept_url(c) } self.startNode(('skos', 'Concept'), attr) pt = c.get_prefered(self._l[0]) for tl in c['=']: t, l = tl.split("@") attr={ (self.xmlns['xml'],'lang'): l } if tl in pt: self.simpleNode(('skos', 'prefLabel'), t, attr) else: self.simpleNode(('skos', 'altLabel'), t, attr) for tl in c['#']: t, l = tl.split("@") attr={ (self.xmlns['xml'],'lang'): l } self.simpleNode(('skos', 'hiddenLabel'), t, attr) for tl in c['<']: resource = self._term_url(tl) attr={ (self.xmlns['rdf'],'resource'): resource } self.simpleNode(('skos', 'broader'), t, attr) for tl in c['>']: resource = self._term_url(tl) attr={ (self.xmlns['rdf'],'resource'): resource } self.simpleNode(('skos', 'narrower'), t, attr) for tl in c['-']: resource = self._term_url(tl) attr={ (self.xmlns['rdf'],'resource'): resource } self.simpleNode(('skos', 'related'), t, attr) for tl in c['~']: self.warning('SKOS not support similar concepts') self.writePublicNotes(c._pubn.items()) self.endNode(('skos', 'Concept')) pass def writePublicNotes(self, n): for k,v in n: if k == 'definition': for i in v: value, lang = i.split('@') attr={ (self.xmlns['xml'],'lang'): lang } self.simpleNode(('skos', 'definition'), value, attr) if k == 'changenote': for i in v: attr={ (self.xmlns['rdf'],'parseType'): 'Resource' } self.startNode(('skos', 'changenote'), attr) if 'value' in i: self.simpleNode(('rdf', 'value'), i['value'], {}) if 'creator' in i: self.writeCreator(i['creator']) self.endNode(('skos', 'changenote')) if k == 'scopenote': for i in v: attr = {} if 'resource' in i and i['resource'] != None: attr[(self.xmlns['rdf'],'resource')] = i['resource'] self.startNode(('skos', 'scopenote'), attr) if 'document' in i: self.writeDocument(i['document']) self.endNode(('skos', 'scopenote')) def writeDocument(self, d): attr = {} if 'resource' in d and d['resource'] != None: attr[(self.xmlns['rdf'],'resource')] = d['resource'] self.startNode(('foaf', 'document'), attr) if 'creator' in d: self.writeCreator(d['creator']) if 'language' in d: self.writeLanguage(d['language']) self.endNode(('foaf', 'document')) def writeLanguage(self, l): self.startNode(('dc', 'language'), {}) self.startNode(('dcterms', 'RFC1766'), {}) self.simpleNode(('rdf', 'value'), l['value'] , {}) self.simpleNode(('rdfs', 'label'), l['label'] , {}) self.endNode(('dcterms', 'RFC1766')) self.endNode(('dc', 'language')) def writeCreator(self, c): self.startNode(('dc', 'creator'), {}) if 'person' in c: self.startNode(('foaf', 'person'), {}) if 'name' in c['person']: self.simpleNode(('foaf', 'name'), c['person']['name'], {}) if 'mbox' in c['person']: attr={ (self.xmlns['rdf'],'resource'): c['person']['mbox'] } self.simpleNode(('foaf', 'mbox'), None, attr) self.endNode(('foaf', 'person')) self.endNode(('dc', 'creator'))
# regression test for SAX 2.0
def handle(self, *args, **options): if len(args) != 1: raise CommandError("This command takes exactly one argument") filepath = args[0] bzip2 = options.get('bzip2', False) gzip_opt = options.get('gzip', False) if bzip2 and not filepath.endswith(".bz2"): filepath += ".bz2" elif gzip_opt and not filepath.endswith(".gz"): filepath += ".gz" limit = options.get("limit", -1) skip = options.get("skip", 0) batch = options.get("batch", 100) newline = options.get("newline", False) qs = Record.objects.all().select_related(*[field.name for field in Record._meta.fields if isinstance(field, ForeignKey)]).prefetch_related(*([field.name for field in Record._meta.many_to_many] + [obj.get_accessor_name() for obj in Record._meta.get_all_related_objects()])).order_by('identifier') # @UndefinedVariable if limit>=0: qs = qs[skip:skip+limit] else: qs = qs[skip:] open_method = None open_args = [] decode_method = lambda s: s if bzip2: open_method = bz2.BZ2File open_args = [filepath, 'wb', 9] elif gzip_opt: open_method = gzip.GzipFile open_args = [filepath, 'wb', 9] else: open_method = codecs.open open_args = [filepath, 'wb', "utf-8"] decode_method = lambda s: s.decode("utf-8") total_records = qs.count() print("Total record to export : %d" % total_records) progress_writer = None with open_method(*open_args) as dest_file: writer = XMLGenerator(dest_file, "UTF-8") writer.startDocument() for prefix,uri in GRAPH_NAMESPACES.items(): writer.startPrefixMapping(prefix, uri) writer.startElementNS((RDF, 'RDF'), 'RDF', AttributesNSImpl({}, {})) writer.characters("\n") for n in range((total_records/batch)+1): for i,r in enumerate(qs[n*batch:((n+1)*batch)]): progress_writer = show_progress(i+(n*batch)+1, total_records, "Exporting record %s" % r.identifier, 40, writer=progress_writer, newline=newline) graph = self.get_graph_from_object(r) do_write = False for line in graph.serialize(format="pretty-xml", encoding="utf-8").splitlines(True): if "<iiep:Record" in line: do_write = True if do_write: dest_file.write(decode_method(line)) if "</iiep:Record>" in line: break writer.endElementNS((RDF, 'RDF'), 'RDF') writer.endDocument() dest_file.write("\n")
def dump(obj, fp, *, skipkeys=False, check_circular=True, allow_nan=True, indent=None, default=None, sort_keys=False): """ Serialize a value to a file in JSONx format. :param obj: Value to be serialized. :param fp: File-like object to write JSONx :class:`str` to. :param bool skipkeys: If true, then dictionary keys that are not of a basic type (:class:`str`, :class:`int`, :class:`float`, :class:`bool`, ``None``) will be skipped. Otherwise, a :exc:`TypeError` is raised. (Default: ``False``) :param bool check_circular: If false, then the circular reference check for container types will be skipped. Otherwise, a :exc:`ValueError` is raised. (Default: ``True``) :param bool allow_nan: If false, then it will be a :exc:`ValueError` to serialize out-of-range float values (``nan``, ``inf``, ``-inf``). Otherwise, their JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``) will be used. (Default: ``True``) :param indent: If a positive integer, then JSON array elements and object members will be pretty-printed with that many spaces per level. If a string, that string is used to indent each level. An indent level of 0, negative, or ``""`` will only insert newlines. ``None`` selects the most compact representation. (Default: ``None``) :type indent: int or str :param default: If specified, it must be a function that gets called for objects that can’t otherwise be serialized, and it must return an encodable version of the object. If not specified, :exc:`TypeError` is raised. (Default: ``None``) :param bool sort_keys: If true, then the output of dictionaries will be sorted by key. (Default: ``False``) """ def _attrs(name=None): return AttributesNSImpl( {(None, 'name'): name} if name is not None else {}, None) def _str(value): if value is None: return 'null' if isinstance(value, bool): return 'true' if value else 'false' if isinstance(value, float): if isnan(value): return 'NaN' if isinf(value): return 'Infinity' if value > 0 else '-Infinity' return str(value) def _dump(value, name=None): nonlocal stack, level if indent is not None: gen.ignorableWhitespace(indent * level) if isinstance(value, dict): if check_circular: if id(value) in stack: raise ValueError('container has circular reference') stack.add(id(value)) gen.startElementNS((JSONX_NS_URI, 'object'), None, attrs=_attrs(name)) if value: if indent is not None: gen.ignorableWhitespace('\n') level += 1 for k, v in sorted( value.items(), key=lambda kv: kv[0]) if sort_keys else value.items(): if k is not None and not isinstance( k, (str, int, float, bool)): if not skipkeys: raise TypeError( 'dictionary key is not of a basic type: %r' % (k, )) continue _dump(v, name=_str(k)) level -= 1 if indent is not None: gen.ignorableWhitespace(indent * level) gen.endElementNS((JSONX_NS_URI, 'object'), None) if check_circular: stack.remove(id(value)) elif isinstance(value, list): if check_circular: if id(value) in stack: raise ValueError('container has circular reference') stack.add(id(value)) gen.startElementNS((JSONX_NS_URI, 'array'), None, attrs=_attrs(name)) if value: if indent is not None: gen.ignorableWhitespace('\n') level += 1 for v in value: _dump(v) level -= 1 if indent is not None: gen.ignorableWhitespace(indent * level) gen.endElementNS((JSONX_NS_URI, 'array'), None) if check_circular: stack.remove(id(value)) elif isinstance(value, str): gen.startElementNS((JSONX_NS_URI, 'string'), None, attrs=_attrs(name)) gen.characters(value) gen.endElementNS((JSONX_NS_URI, 'string'), None) elif isinstance(value, bool): gen.startElementNS((JSONX_NS_URI, 'boolean'), None, attrs=_attrs(name)) gen.characters(_str(value)) gen.endElementNS((JSONX_NS_URI, 'boolean'), None) elif isinstance(value, (int, float)): if not allow_nan and (isinf(value) or isnan(value)): raise ValueError('float value is out of range: %r' % value) gen.startElementNS((JSONX_NS_URI, 'number'), None, attrs=_attrs(name)) gen.characters(_str(value)) gen.endElementNS((JSONX_NS_URI, 'number'), None) elif value is None: gen.startElementNS((JSONX_NS_URI, 'null'), None, attrs=_attrs(name)) gen.endElementNS((JSONX_NS_URI, 'null'), None) elif default: _dump(default(value), name=name) else: raise TypeError('cannot serialize object: %r' % (value, )) if indent is not None: gen.ignorableWhitespace('\n') stack = set() level = 0 if indent is not None and isinstance(indent, int): indent = ' ' * indent if indent > 0 else '' gen = XMLGenerator(fp, encoding='UTF-8', short_empty_elements=True) gen.startDocument() gen.startPrefixMapping(JSONX_PREFIX, JSONX_NS_URI) _dump(obj) gen.endPrefixMapping(JSONX_PREFIX) gen.endDocument()
class SchemaGenerator(object): """ This class generates XSD schema based on class description from qooxdoo API. Constructor takes dictinary with class description, generated by qxt.xsd.utils.ApiDataParser. """ def __init__(self, classInfoDict): self.__classInfoDict = classInfoDict def generate(self, fileName): """ Generates XSD based on given classes definitions. Writes it to specified fileName. """ #TODO make proper error handling if something wrong with file. self.__output = open(fileName, "w") self.__doc = XMLGenerator(self.__output, "utf-8") self.__doc.startDocument() self.__start_schema() # generate attibute groups self.__generate_attribute_groups() # generate group of references # generate allGroup element self.__generate_all_group() # generate elements self.__generate_elements() # generate top level elements self.__generate_top_elements() self.__end_schema() self.__doc.endDocument() self.__output.close() def __start_schema(self): """Generates schema header.""" self.__doc.startPrefixMapping(u'xsd', XSD_NS) self.__doc.startPrefixMapping(u'qx', QX_NS) self.__doc.startPrefixMapping(u'qxt', QXT_NS) shemaattr = AttributesNSImpl( { (None, 'targetNamespace'): "http://www.qxtransformer.org/qooxdoo/0.8", (None, 'elementFormDefault'): 'qualified', (None, 'attributeFormDefault'): 'unqualified' }, {}) self.__doc.startElementNS((XSD_NS, u'schema'), u'xsd:schema', shemaattr) def __end_schema(self): """Generated closing tags for schema.""" self.__doc.endElementNS((XSD_NS, u'schema'), u'xsd:schema') self.__doc.endPrefixMapping(u'xsd') def __generate_attribute_groups(self): """Geneartes all groups for API data. Iterates over al classes definitions. """ for className, classInfo in self.__classInfoDict.iteritems(): self.__generate_attribute_group(className, classInfo) def __generate_attribute_group(self, className, classInfo): """Generate an attribute group based on given classInfo for each class. Includes class property in group if it's not overriden from base class (in other case it will be added for base class). """ self.__doc.startElementNS( (XSD_NS, u'attributeGroup'), u'xsd:attributeGroup', AttributesNSImpl({(None, 'name'): className}, {})) #generate attrubute group only if class has any properties if classInfo.has_key('properties'): properties = classInfo['properties'] for propName, prop in properties.iteritems(): #include property only if it's not overriden from base class if not prop.get('overriddenFrom'): self.__doc.startElementNS( (XSD_NS, u'attribute'), u'xsd:attribute', AttributesNSImpl({(None, 'name'): propName}, {})) self.__doc.startElementNS((XSD_NS, u'annotation'), u'xsd:annotation', AttributesNSImpl({}, {})) self.__doc.startElementNS((XSD_NS, u'documentation'), u'xsd:documentation', AttributesNSImpl({}, {})) self.__doc.characters(prop.get('info', '')) self.__doc.endElementNS((XSD_NS, u'documentation'), u'xsd:documentation') self.__doc.endElementNS((XSD_NS, u'annotation'), u'xsd:annotation') self.__doc.endElementNS((XSD_NS, u'attribute'), u'xsd:attribute') self.__doc.endElementNS((XSD_NS, u'attributeGroup'), u'xsd:attributeGroup') def __generate_elements(self): """Generated all elements for given API data. Iterates over all definitions.""" for className, classInfo in self.__classInfoDict.iteritems(): tagName = self.__parse_tag_name(classInfo.get('tagName')) # generate tag only if tag name has namespace (tags without namespaces in config # are base tags only for inheritance inside config file) if tagName and tagName[0]: inheritance_chain = [] self.__fill_inheritance_chain(inheritance_chain, className) self.__generate_element(tagName, className, classInfo, inheritance_chain, [('qx', 'allGroup')]) def __generate_element(self, tagName, className, classInfo, attributeGroups, elementGroup): """Generates an definition of XSD element. @param tagName tuple produced by __parse_tag_name @param className name of widget class @param classInfo dictionary with class information @param attributeGroups array with all attribute groups which this class includes (simply all inheritance chain) @param elementGroup array with all allowed child elements """ self.__doc.startElementNS( (XSD_NS, u'element'), u'xsd:element', AttributesNSImpl({(None, 'name'): tagName[1]}, {})) self.__doc.startElementNS((XSD_NS, u'annotation'), u'xsd:annotation', AttributesNSImpl({}, {})) self.__doc.startElementNS( (XSD_NS, u'documentation'), u'xsd:documentation', AttributesNSImpl({}, {})) self.__doc.characters(classInfo.get('info', '')) self.__doc.endElementNS((XSD_NS, u'documentation'), u'xsd:documentation') self.__doc.endElementNS((XSD_NS, u'annotation'), u'xsd:annotation') self.__doc.startElementNS((XSD_NS, u'complexType'), u'xsd:complexType', AttributesNSImpl({}, {})) #generate references for allowed child elements self.__doc.startElementNS((XSD_NS, u'sequence'), u'xsd:sequence', AttributesNSImpl({}, {})) for group in elementGroup: self.__doc.startElementNS( (XSD_NS, u'group'), u'xsd:group', AttributesNSImpl({(None, 'ref'): ":".join(group)}, {})) self.__doc.endElementNS((XSD_NS, u'group'), u'xsd:group') self.__doc.endElementNS((XSD_NS, u'sequence'), u'xsd:sequence') #generate attribute group for attrGroupName in attributeGroups: #TODO fix namespace of the generated group self.__doc.startElementNS( (XSD_NS, u'attributeGroup'), u'xsd:attributeGroup', AttributesNSImpl({(None, 'ref'): "qx:%s" % attrGroupName}, {})) self.__doc.endElementNS((XSD_NS, u'attributeGroup'), u'xsd:attributeGroup') self.__doc.endElementNS((XSD_NS, u'complexType'), u'xsd:complexType') self.__doc.endElementNS((XSD_NS, u'element'), u'xsd:element') def __generate_group(self, name, tagNames): """Generates group with references to allowed element.""" self.__doc.startElementNS((XSD_NS, u'group'), u'xsd:group', AttributesNSImpl({(None, 'name'): name}, {})) self.__doc.startElementNS((XSD_NS, u'choice'), u'xsd:choice', AttributesNSImpl({}, {})) for tagName in tagNames: self.__doc.startElementNS((XSD_NS, u'element'), u'xsd:element', AttributesNSImpl( { (None, 'ref'): ':'.join(tagName), (None, 'minOccurs'): '0', (None, 'maxOccurs'): 'unbounded' }, {})) self.__doc.endElementNS((XSD_NS, u'element'), u'xsd:element') self.__doc.endElementNS((XSD_NS, u'choice'), u'xsd:choice') self.__doc.endElementNS((XSD_NS, u'group'), u'xsd:group') def __generate_all_group(self): """Genrates group with name 'allGroup' which includes all tags from XSD.""" # getting all tags from class info (only with defined namespaces) groupTags = [] for className, classInfo in self.__classInfoDict.iteritems(): tagName = self.__parse_tag_name(classInfo.get('tagName')) # tag with defined namespace if tagName and tagName[0]: groupTags.append(tagName) # generate group self.__generate_group('allGroup', groupTags) def __generate_top_elements(self): """Generates a set of predefined top level elements.""" self.__generate_element((None, 'application'), None, {}, [], [('qx', 'allGroup')]) def __fill_inheritance_chain(self, chain, className): """Fills inheritance chain for given className. Chain will contain base class, base class of base class, ... Uses recursion. """ chain.append(className) superClass = self.__classInfoDict[className].get('superClass') if superClass: self.__fill_inheritance_chain(chain, superClass) def __parse_tag_name(self, tagName): """Parses tag name and returns it as tuple.""" if not tagName: return None parts = tagName.split(':') if len(parts) == 2: return (parts[0], parts[1]) elif len(parts) == 1: return (None, tagName) else: return None
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
class GrafRenderer(object): """ Renders a GrAF XML representation that can be read back by an instance of L{GraphParser}. Version: 1.0. """ def __init__(self, out, constants=Constants): """Create an instance of a GrafRenderer. """ out = out if hasattr(out, 'write') else open(out, "w") # TODO: use a generator with indents try: # For Python >= 3.2 self._gen = XMLGenerator(out, 'utf-8', short_empty_elements=True) except TypeError: self._gen = XMLGenerator(out, 'utf-8') self._g = Constants def _tag(self, tag, attribs=None): return TagWriter(self._gen, self._g.NAMESPACE, tag, attribs) def render_node(self, n): """ Used to render the node elements of the Graph. """ tag = self._tag(self._g.NODE, { self._g.ID: n.id, self._g.ROOT: 'true' if n.is_root else None, }) with tag: for link in n.links: self.render_link(link) for a in n.annotations: self.render_ann(a) def render_link(self, link): """ Used to render the link elements of the Graph. """ self._tag(self._g.LINK, { 'targets': ' '.join(str(region.id) for region in link) }).write() def render_region(self, region): """ Used to render the region elements of the Graph. """ self._tag( self._g.REGION, { self._g.ID: region.id, self._g.ANCHORS: ' '.join(str(a) for a in region.anchors) }).write() def render_edge(self, e): """ Used to render the edge elements of the Graph. """ with self._tag(self._g.EDGE, { self._g.FROM: e.from_node.id, self._g.TO: e.to_node.id }): for a in e.annotations: self.render_ann(a) def render_as(self, aSet): """ Used to render the annotation set elements of the Graph. """ with self._tag(self._g.ASET, {self._g.NAME: aSet.name}): for a in aSet: self.render_ann(a) def render_ann(self, a): """ Used to render the annotation elements of the Graph. """ tag = self._tag( self._g.ANNOTATION, { 'label': a.label, 'ref': a.element.id, self._g.ASET: None if a.aspace is None else a.aspace.name }) with tag: self.render_fs(a.features) def render_fs(self, fs): """ Used to render the feature structure elements of the Graph. """ if not fs: return with self._tag(self._g.FS, {self._g.TYPE: fs.type}): for name, value in fs.items(): self.render_feature(name, value) def render_feature(self, name, value): """ Used to render the features elements of the Graph. """ if hasattr(value, 'items'): with self._tag(self._g.FEATURE, {self._g.NAME: name}): self.render_fs(value) else: self._tag(self._g.FEATURE, { self._g.NAME: name, self._g.VALUE: value }).write() def write_header(self, g): """ Writes the header tag at the beginning of the XML file. """ header = g.header with self._tag(self._g.HEADER): self.render_tag_usage(g) self.write_header_elements(graph, header) def write_header_elements(self, graph, header): """ Helper method for write_header. """ roots = header.roots if roots: with self._tag(self._g.ROOTS): for root in roots: self._tag(self._g.ROOT).write() depends_on = header.depends_on if depends_on: with self._tag(self._g.ROOTS): for dependency in depends_on: self._tag(self._g.DEPENDSON, { self._g.TYPE: dependency }).write() aspaces = graph.annotation_spaces if aspaces: with self._tag(self._g.ANNOTATION_SPACES): for aspace in aspaces: self._tag(self._g.ANNOTATION_SPACE, { self._g.NAME: aspace.name, self._g.TYPE: aspace.type }).write() def count_tag_usage(self, g): annotations = {} for node in g.nodes: for a in node.annotations: count = annotations.setdefault(a.label, 0) annotations[a.label] = count + 1 return annotations def render_tag_usage(self, g): annotations = self.count_tag_usage(g) with self._tag(self._g.TAGSDECL): for k, v in annotations.items(): self._tag(self._g.TAGUSAGE, { self._g.GI: str(k), self._g.OCCURS: str(v) }).write() def render(self, g): self._gen.startDocument() self._gen.startPrefixMapping(None, self._g.NAMESPACE) with self._tag(self._g.GRAPH): self.write_header(g) # Add any features of the graph if g.features is not None: self.render_fs(g.features) # Render the regions for region in sorted(g.regions): self.render_region(region) # Render the nodes nodes = sorted(g.nodes) for node in nodes: self.render_node(node) # Render the edges for edge in g.edges: self.render_edge(edge)
class GrafRenderer(object): """ Renders a GrAF XML representation that can be read back by an instance of L{GraphParser}. Version: 1.0. """ def __init__(self, out, constants=Constants): """Create an instance of a GrafRenderer. """ out = out if hasattr(out, 'write') else open(out, "w") # TODO: use a generator with indents try: # For Python >= 3.2 self._gen = XMLGenerator(out, 'utf-8', short_empty_elements=True) except TypeError: self._gen = XMLGenerator(out, 'utf-8') self._g = Constants def _tag(self, tag, attribs=None): return TagWriter(self._gen, self._g.NAMESPACE, tag, attribs) def render_node(self, n): """ Used to render the node elements of the Graph. """ tag = self._tag(self._g.NODE, { self._g.ID: n.id, self._g.ROOT: 'true' if n.is_root else None, }) with tag: for link in n.links: self.render_link(link) for a in n.annotations: self.render_ann(a) def render_link(self, link): """ Used to render the link elements of the Graph. """ self._tag(self._g.LINK, {'targets': ' '.join(str(region.id) for region in link)}).write() def render_region(self, region): """ Used to render the region elements of the Graph. """ self._tag(self._g.REGION, { self._g.ID: region.id, self._g.ANCHORS: ' '.join(str(a) for a in region.anchors) }).write() def render_edge(self, e): """ Used to render the edge elements of the Graph. """ with self._tag(self._g.EDGE, {self._g.FROM: e.from_node.id, self._g.TO: e.to_node.id}): for a in e.annotations: self.render_ann(a) def render_as(self, aSet): """ Used to render the annotation set elements of the Graph. """ with self._tag(self._g.ASET, {self._g.NAME: aSet.name}): for a in aSet: self.render_ann(a) def render_ann(self, a): """ Used to render the annotation elements of the Graph. """ tag = self._tag(self._g.ANNOTATION, { 'label': a.label, 'ref': a.element.id, self._g.ASET: None if a.aspace is None else a.aspace.name }) with tag: self.render_fs(a.features) def render_fs(self, fs): """ Used to render the feature structure elements of the Graph. """ if not fs: return with self._tag(self._g.FS, {self._g.TYPE: fs.type}): for name, value in fs.items(): self.render_feature(name, value) def render_feature(self, name, value): """ Used to render the features elements of the Graph. """ if hasattr(value, 'items'): with self._tag(self._g.FEATURE, {self._g.NAME: name}): self.render_fs(value) else: self._tag(self._g.FEATURE, {self._g.NAME: name, self._g.VALUE: value}).write() def write_header(self, g): """ Writes the header tag at the beginning of the XML file. """ header = g.header with self._tag(self._g.HEADER): self.render_tag_usage(g) self.write_header_elements(graph, header) def write_header_elements(self, graph, header): """ Helper method for write_header. """ roots = header.roots if roots: with self._tag(self._g.ROOTS): for root in roots: self._tag(self._g.ROOT).write() depends_on = header.depends_on if depends_on: with self._tag(self._g.ROOTS): for dependency in depends_on: self._tag(self._g.DEPENDSON, {self._g.TYPE: dependency}).write() aspaces = graph.annotation_spaces if aspaces: with self._tag(self._g.ANNOTATION_SPACES): for aspace in aspaces: self._tag(self._g.ANNOTATION_SPACE, {self._g.NAME: aspace.name, self._g.TYPE: aspace.type}).write() def count_tag_usage(self, g): annotations = {} for node in g.nodes: for a in node.annotations: count = annotations.setdefault(a.label, 0) annotations[a.label] = count + 1 return annotations def render_tag_usage(self, g): annotations = self.count_tag_usage(g) with self._tag(self._g.TAGSDECL): for k, v in annotations.items(): self._tag(self._g.TAGUSAGE, {self._g.GI: str(k), self._g.OCCURS: str(v)}).write() def render(self, g): self._gen.startDocument() self._gen.startPrefixMapping(None, self._g.NAMESPACE) with self._tag(self._g.GRAPH): self.write_header(g) # Add any features of the graph if g.features is not None: self.render_fs(g.features) # Render the regions for region in sorted(g.regions): self.render_region(region) # Render the nodes nodes = sorted(g.nodes) for node in nodes: self.render_node(node) # Render the edges for edge in g.edges: self.render_edge(edge)
def toXml(self, result, out): atom = "http://www.w3.org/2005/Atom" tf = "http://sdk.nokia.com/test-framework/ns/1.0" gen = XMLGenerator(out, 'utf-8') gen.startDocument() gen.startPrefixMapping('atom', atom) gen.startPrefixMapping('tf', tf) startElement(gen, atom, 'entry') writeElement(gen, atom, 'title', result.constructTitle()) writeElement(gen, atom, 'updated', datetime.datetime.now().isoformat()) writeElement(gen, tf, 'errorSummary', exitStatusAsString(result.status())) writeElement(gen, tf, 'host', socket.gethostname()) if result._testStart != None: writeElement(gen, tf, 'testStart', result._testStart.isoformat()) else: result._internalErrors.append( "Result generator: no start timestamp found.") if result._testEnd != None: writeElement(gen, tf, 'testEnd', result._testEnd.isoformat()) else: result._internalErrors.append( "Result generator: no end timestamp found.") startElement(gen, tf, 'installer') writeElement(gen, tf, 'sourceUrl', result._installerSourceLocation) writeElement(gen, tf, 'platform', result._installerTargetPlatform) #TODO revision endElement(gen, tf, 'installer') if result._testcase != None: startElement(gen, tf, 'testCase') writeElement(gen, tf, 'name', result._testcase.name()) writeElement(gen, tf, 'path', result._testcase.path()) writeElement(gen, tf, 'installScript', result._testcase.installscript()) endElement(gen, tf, 'testCase') else: result._internalErrors.append( "Result generator: No test case given.") if result._installationResult != None: startElement(gen, tf, 'installationResult') writeElement(gen, tf, 'exitCode', str(result._installationResult.exitCode)) writeElement( gen, tf, 'exitStatus', exitStatusAsString(result._installationResult.exitStatus)) endElement(gen, tf, 'installationResult') else: result._internalErrors.append( "Result generator: No installation result given.") startElement(gen, tf, 'checkerResult') for err in result._checkerErrors: writeElement(gen, tf, 'error', err) endElement(gen, tf, 'checkerResult') startElement(gen, tf, 'virtualMachine') writeElement(gen, tf, 'path', result._vm.vmxPath()) writeElement(gen, tf, 'platform', result._vm.ostype()) writeElement(gen, tf, 'snapshot', result._vm.snapshot()) endElement(gen, tf, 'virtualMachine') startElement(gen, tf, 'internalErrors') for i in result._internalErrors: writeElement(gen, tf, 'internalError', str(i)) endElement(gen, tf, 'internalErrors') if result._errorSnapshot != None: writeElement(gen, tf, 'errorSnapshot', result._errorSnapshot) endElement(gen, atom, 'entry') gen.endDocument()