def write_codebook(tags, output):
output.startElementNS(
(None, 'CodeBook'), 'CodeBook',
AttributesNSImpl({(None, 'origin'): 'Taguette %s' % __version__},
{(None, 'origin'): 'origin'}),
)
output.startElementNS(
(None, 'Codes'), 'Codes',
AttributesNSImpl({}, {}),
)
for tag in tags:
guid = uuid.uuid5(TAGUETTE_NAMESPACE, tag.path)
guid = str(guid).upper()
output.startElementNS(
(None, 'Code'), 'Code',
AttributesNSImpl({(None, 'guid'): guid,
(None, 'name'): tag.path,
(None, 'isCodable'): 'true'},
{(None, 'guid'): 'guid',
(None, 'name'): 'name',
(None, 'isCodable'): 'isCodable'}),
)
output.endElementNS((None, 'Code'), 'Code')
output.endElementNS((None, 'Codes'), 'Codes')
output.startElementNS(
(None, 'Sets'), 'Sets',
AttributesNSImpl({}, {}),
)
output.endElementNS((None, 'Sets'), 'Sets')
output.endElementNS((None, 'CodeBook'), 'CodeBook')
def write_home (self) :
sects = {'ingredients' : 'Ingredients',
'directions' : 'Directions',
'stories' : 'Stories'}
home_attrs = AttributesNSImpl({(NS_MAP['h'], 'id'):'home',
(NS_MAP['h'], 'selected'):'true',
(NS_MAP['h'], 'title'):'FIX ME'},
{});
self.xml.startElementNS((NS_MAP['h'], 'ul'), None, list_attrs)
for id in sects :
href = "#%s" % id
home_attrs = AttributesNSImpl({(NS_MAP['h'], 'href'):href},
{});
self.xml.startElementNS((NS_MAP['h'], 'li'), None, {})
self.xml.startElementNS((NS_MAP['h'], 'a'), None, link_attrs)
self.xml.characters(sects[id]);
self.xml.endElementNS((NS_MAP['h'], 'a'), None)
self.xml.endElementNS((NS_MAP['h'], 'li'), None)
self.xml.endElementNS((NS_MAP['h'], 'ul'), None)
def soql2atom(loginResult, soql, title):
soqlWithFields = addRequiredFieldsToSoql(soql)
userInfo = loginResult[beatbox._tPartnerNS.userInfo]
serverUrl = str(loginResult[beatbox._tPartnerNS.serverUrl])
(scheme, host, path, params, query, frag) = urlparse(serverUrl)
sfbaseUrl = scheme + "://" + host + "/"
thisUrl = "http://" + os.environ["HTTP_HOST"] + os.environ["REQUEST_URI"]
qr = svc.query(soqlWithFields)
atom_ns = "http://www.w3.org/2005/Atom"
ent_ns = "urn:sobject.enterprise.soap.sforce.com"
print("content-type: application/atom+xml")
doGzip = "HTTP_ACCEPT_ENCODING" in os.environ and "gzip" in string.lower(os.environ["HTTP_ACCEPT_ENCODING"]).split(',')
if doGzip:
print("content-encoding: gzip")
print("")
x = beatbox.XmlWriter(doGzip)
x.startPrefixMapping("a", atom_ns)
x.startPrefixMapping("s", ent_ns)
x.startElement(atom_ns, "feed")
x.writeStringElement(atom_ns, "title", title)
x.characters("\n")
x.startElement(atom_ns, "author")
x.writeStringElement(atom_ns, "name", str(userInfo.userFullName))
x.endElement()
x.characters("\n")
rel = AttributesNSImpl(
{(None, "rel"): "self", (None, "href"): thisUrl},
{(None, "rel"): "rel", (None, "href"): "href"})
x.startElement(atom_ns, "link", rel)
x.endElement()
x.writeStringElement(atom_ns, "updated", datetime.datetime.utcnow().isoformat() + "Z")
x.writeStringElement(atom_ns, "id", thisUrl + "&userid=" + str(loginResult[beatbox._tPartnerNS.userId]))
x.characters("\n")
type = AttributesNSImpl({(None, "type"): "html"}, {(None, "type"): "type"})
for row in qr[sf.records:]:
x.startElement(atom_ns, "entry")
desc = ""
x.writeStringElement(atom_ns, "title", str(row[2]))
for col in row[2:]:
if col._name[1] == 'Id':
x.writeStringElement(atom_ns, "id", sfbaseUrl + str(col))
writeLink(x, atom_ns, "link", "alternate", "text/html", sfbaseUrl + str(col))
elif col._name[1] == 'SystemModstamp':
x.writeStringElement(atom_ns, "updated", str(col))
elif col._name[1] == 'CreatedDate':
x.writeStringElement(atom_ns, "published", str(col))
elif str(col) != "":
desc = desc + "<b>" + col._name[1] + "</b> : " + str(col) + "<br>"
x.writeStringElement(ent_ns, col._name[1], str(col))
x.startElement(atom_ns, "content", type)
x.characters(desc)
x.endElement() # content
x.characters("\n")
x.endElement() # entry
x.endElement() # feed
print(x.endDocument())
def codebook_xml(tags, file):
"""Export a codebook in REFI-QDA format for the given tags.
"""
with contextlib.ExitStack() as stack:
if not hasattr(file, 'write'):
file = stack.enter_context(open(file, 'wb'))
# http://schema.qdasoftware.org/versions/Codebook/v1.0/Codebook.xsd
output = XMLGenerator(
file,
encoding='utf-8',
short_empty_elements=True,
)
output.startDocument()
output.startPrefixMapping(None, 'urn:QDA-XML:codebook:1.0')
output.startElementNS(
(None, 'CodeBook'),
'CodeBook',
AttributesNSImpl({(None, 'origin'): 'Taguette %s' % version},
{(None, 'origin'): 'origin'}),
)
output.startElementNS(
(None, 'Codes'),
'Codes',
AttributesNSImpl({}, {}),
)
for tag in tags:
guid = uuid.uuid5(TAGUETTE_NAMESPACE, tag.path)
guid = str(guid).upper()
output.startElementNS(
(None, 'Code'),
'Code',
AttributesNSImpl(
{
(None, 'guid'): guid,
(None, 'name'): tag.path,
(None, 'isCodable'): 'true'
}, {
(None, 'guid'): 'guid',
(None, 'name'): 'name',
(None, 'isCodable'): 'isCodable'
}),
)
output.endElementNS((None, 'Code'), 'Code')
output.endElementNS((None, 'Codes'), 'Codes')
output.startElementNS(
(None, 'Sets'),
'Sets',
AttributesNSImpl({}, {}),
)
output.endElementNS((None, 'Sets'), 'Sets')
output.endElementNS((None, 'CodeBook'), 'CodeBook')
output.endPrefixMapping(None)
output.endDocument()
def write_instances(self, layer):
attrs = AttributesNSImpl({}, {})
self.startElement('instances', attrs)
for inst in layer.getInstances():
position = inst.getLocationRef().getExactLayerCoordinates()
attr_vals = {
(None, 'o'): inst.getObject().getId(),
(None, 'x'): str(position.x),
(None, 'y'): str(position.y),
(None, 'z'): str(position.z),
(None, 'r'): str(inst.getRotation()),
}
attr_names = {
(None, 'o'): 'o',
(None, 'x'): 'x',
(None, 'y'): 'y',
(None, 'z'): 'z',
(None, 'r'): 'r',
}
visual = inst.get2dGfxVisual()
if visual:
attr_vals[(None, 'stackpos')] = str(visual.getStackPosition())
attr_names[(None, 'stackpos')] = 'stackpos'
nspace = inst.getObject().getNamespace()
if nspace != self.nspace:
attr_vals[(None, 'ns')] = inst.getObject().getNamespace()
attr_names[(None, 'ns')] = 'ns'
self.nspace = nspace
instId = inst.getId()
if instId:
attr_vals[(None, 'id')] = inst.getId()
attr_names[(None, 'id')] = 'id'
if inst.isOverrideBlocking():
attr_vals[(None, 'override_blocking')] = str(
int(inst.isOverrideBlocking()))
attr_names[(None, 'override_blocking')] = 'override_blocking'
if inst.getObject().isBlocking() is not inst.isBlocking():
attr_vals[(None, 'blocking')] = str(int(inst.isBlocking()))
attr_names[(None, 'blocking')] = 'blocking'
attrs = AttributesNSImpl(attr_vals, attr_names)
self.file.write(self.indent_level)
self.xmlout.startElementNS((None, 'i'), 'i', attrs)
self.xmlout.endElementNS((None, 'i'), 'i')
self.file.write('\n')
self.endElement('instances')
def 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 write_binding(self, name, val):
assert self._resultStarted
attr_vals = {
(None, u"name"): str(name),
}
attr_qnames = {
(None, u"name"): u"name",
}
self.writer.startElementNS(
(SPARQL_XML_NAMESPACE, u"binding"),
u"binding",
AttributesNSImpl(attr_vals, attr_qnames),
)
if isinstance(val, URIRef):
self.writer.startElementNS((SPARQL_XML_NAMESPACE, u"uri"), u"uri",
AttributesNSImpl({}, {}))
self.writer.characters(val)
self.writer.endElementNS((SPARQL_XML_NAMESPACE, u"uri"), u"uri")
elif isinstance(val, BNode):
self.writer.startElementNS((SPARQL_XML_NAMESPACE, u"bnode"),
u"bnode", AttributesNSImpl({}, {}))
self.writer.characters(val)
self.writer.endElementNS((SPARQL_XML_NAMESPACE, u"bnode"),
u"bnode")
elif isinstance(val, Literal):
attr_vals = {}
attr_qnames = {}
if val.language:
attr_vals[(XML_NAMESPACE, u"lang")] = val.language
attr_qnames[(XML_NAMESPACE, u"lang")] = u"xml:lang"
elif val.datatype:
attr_vals[(None, u"datatype")] = val.datatype
attr_qnames[(None, u"datatype")] = u"datatype"
self.writer.startElementNS(
(SPARQL_XML_NAMESPACE, u"literal"),
u"literal",
AttributesNSImpl(attr_vals, attr_qnames),
)
self.writer.characters(val)
self.writer.endElementNS((SPARQL_XML_NAMESPACE, u"literal"),
u"literal")
else:
raise Exception("Unsupported RDF term: %s" % val)
self.writer.endElementNS((SPARQL_XML_NAMESPACE, u"binding"),
u"binding")
def write_header(self,allvarsL):
self.writer.startElementNS((SPARQL_XML_NAMESPACE, u'head'), u'head', AttributesNSImpl({}, {}))
for i in xrange(0,len(allvarsL)) :
attr_vals = {
(None, u'name'): unicode(allvarsL[i][1:]),
}
attr_qnames = {
(None, u'name'): u'name',
}
self.writer.startElementNS((SPARQL_XML_NAMESPACE, u'variable'),
u'variable',
AttributesNSImpl(attr_vals, attr_qnames))
self.writer.endElementNS((SPARQL_XML_NAMESPACE, u'variable'), u'variable')
self.writer.endElementNS((SPARQL_XML_NAMESPACE, u'head'), u'head')
def write_binding(self, name, val):
assert self._resultStarted
if val:
attr_vals = {
(None, u'name'): unicode(name),
}
attr_qnames = {
(None, u'name'): u'name',
}
self.writer.startElementNS(
(SPARQL_XML_NAMESPACE, u'binding'), u'binding',
AttributesNSImpl(attr_vals, attr_qnames))
if isinstance(val, URIRef):
self.writer.startElementNS(
(SPARQL_XML_NAMESPACE, u'uri'), u'uri',
AttributesNSImpl({}, {}))
self.writer.characters(val)
self.writer.endElementNS((SPARQL_XML_NAMESPACE, u'uri'),
u'uri')
elif isinstance(val, BNode):
self.writer.startElementNS(
(SPARQL_XML_NAMESPACE, u'bnode'), u'bnode',
AttributesNSImpl({}, {}))
self.writer.characters(val)
self.writer.endElementNS((SPARQL_XML_NAMESPACE, u'bnode'),
u'bnode')
elif isinstance(val, Literal):
attr_vals = {}
attr_qnames = {}
if val.language:
attr_vals[(XML_NAMESPACE, u'lang')] = val.language
attr_qnames[(XML_NAMESPACE, u'lang')] = u"xml:lang"
elif val.datatype:
attr_vals[(None, u'datatype')] = val.datatype
attr_qnames[(None, u'datatype')] = u'datatype'
self.writer.startElementNS(
(SPARQL_XML_NAMESPACE, u'literal'), u'literal',
AttributesNSImpl(attr_vals, attr_qnames))
self.writer.characters(val)
self.writer.endElementNS(
(SPARQL_XML_NAMESPACE, u'literal'), u'literal')
else:
raise Exception("Unsupported RDF term: %s" % val)
self.writer.endElementNS((SPARQL_XML_NAMESPACE, u'binding'),
u'binding')
def start_tag(doc, name, attr=None, body=None, namespace=None):
"""Wrapper to start an xml tag."""
if attr is None:
attr = {}
# name = bytes(name, 'utf-8')
# if namespace is not None:
# namespace = bytes(namespace, 'utf-8')
attr_vals = {}
attr_keys = {}
for key, val in attr.items():
# if key is not None:
# key = bytes(key, 'utf-8')
# if val is not None:
# val = bytes(val, 'utf-8')
key_tuple = (namespace, key)
attr_vals[key_tuple] = val
attr_keys[key_tuple] = key
attr2 = AttributesNSImpl(attr_vals, attr_keys)
doc.startElementNS((namespace, name), name, attr2)
if body:
doc.characters(body)
def _element_ns(self, n):
""" handle an ElementNode with NS interface"""
## convert DOM namedNodeMap to SAX attributes NS
prefix_list = []
nnm = n.attributes
attrs, qnames = {}, {}
for a in nnm.values():
a_uri = a.namespaceURI
if a_uri == XMLNS_NS:
prefix, val = a.localName, a.value
self._cont_handler.startPrefixMapping(prefix, val)
prefix_list.append(prefix)
if self._ns_prfx:
name = (a_uri, prefix)
attrs[name] = val
qnames[name] = a.nodeName
else:
name = (a_uri, a.localName)
attrs[name] = a.value
qnames[name] = a.nodeName
## handle element NS
name = (n.namespaceURI, n.localName)
self._cont_handler.startElementNS(name, n.nodeName,
AttributesNSImpl(attrs, qnames))
self._from_dom(n.firstChild)
self._cont_handler.endElementNS(name, n.nodeName)
prefix_list.reverse()
map(self._cont_handler.endPrefixMapping, prefix_list)
def _defs(self, xml):
element = self._svgName('defs')
xml.ignorableWhitespace('\n ')
xml.startElementNS(element, None, AttributesNSImpl({}, {}))
self._edgePath(xml)
xml.ignorableWhitespace('\n ')
xml.endElementNS(element, None)
def write_source(self, source):
self.xml.startElementNS((NS_MAP['e'], 'source'), None, {})
if self.isset_notempty(source, 'publication'):
xlink = {}
if self.isset_notempty(source, 'identifier'):
scheme, netloc, path, params, query, fragment = urlparse.urlparse(
source['identifier'])
if not scheme == '':
xlink = AttributesNSImpl(
{(NS_MAP['xlink'], 'href'): source['identifier']}, {})
self.xml.startElementNS((NS_MAP['e'], 'publication'), None, xlink)
self.write_name(source['publication'])
self.xml.endElementNS((NS_MAP['e'], 'publication'), None)
if self.isset_notempty(source, 'author'):
self.write_author(source['author'])
if self.isset_notempty(source, 'date'):
self.write_author(source['date'])
self.xml.endElementNS((NS_MAP['e'], 'source'), None)
def write_ask(self, val):
self.writer.startElementNS(
(SPARQL_XML_NAMESPACE, u'boolean'),
u'boolean', AttributesNSImpl({}, {}))
self.writer.characters(str(val).lower())
self.writer.endElementNS(
(SPARQL_XML_NAMESPACE, u'boolean'), u'boolean')
def getAttrs(self, attrs={}):
attr_values = {}
attr_qnames = {}
for key, value in attrs.iteritems():
attr_values[(None, key)] = value
attr_qnames[(None, key)] = key
return AttributesNSImpl(attr_values, attr_qnames)
def test_nest(self):
"""Testing deep nest"""
file_object = StringIO()
writer = XMLPrettyGenerator(file_object, 'UTF-8')
writer.startDocument()
attrs = AttributesNSImpl({}, {})
writer.startElementNS((None, 'root'), 'root', attrs)
writer.startElementNS((None, 'a'), 'a', attrs)
writer.startElementNS((None, 'b'), 'b', attrs)
writer.startElementNS((None, 'c'), 'c', attrs)
writer.endElementNS((None, 'c'), 'c')
writer.endElementNS((None, 'b'), 'b')
writer.endElementNS((None, 'a'), 'a')
writer.endElementNS((None, 'root'), 'root')
writer.endDocument()
result = file_object.getvalue()
self.assertEqual(
result.strip(), """
<?xml version="1.0" encoding="UTF-8"?>
<root>
<a>
<b>
<c></c>
</b>
</a>
</root>
""".strip())
def to_sax(walker, handler):
"""Call SAX-like content handler based on treewalker walker"""
handler.startDocument()
for prefix, namespace in prefix_mapping.items():
handler.startPrefixMapping(prefix, namespace)
for token in walker:
type = token['type']
if type == 'Doctype':
continue
elif type in ('StartTag', 'EmptyTag'):
attrs = AttributesNSImpl(token['data'], unadjustForeignAttributes)
handler.startElementNS((token['namespace'], token['name']),
token['name'], attrs)
if type == 'EmptyTag':
handler.endElementNS((token['namespace'], token['name']),
token['name'])
elif type == 'EndTag':
handler.endElementNS((token['namespace'], token['name']),
token['name'])
elif type in ('Characters', 'SpaceCharacters'):
handler.characters(token['data'])
elif type == 'Comment':
pass
else:
assert False, 'Unknown token type'
for prefix, namespace in prefix_mapping.items():
handler.endPrefixMapping(prefix)
handler.endDocument()
def write_2(glos, filename):
from xml.sax.saxutils import XMLGenerator
from xml.sax.xmlreader import AttributesNSImpl
xdbFp = open(filename, 'wb')
fp = XMLGenerator(xdbFp, 'utf-8')
attrs = AttributesNSImpl({}, {})
fp.startElement(u'xfardic', attrs)
for t in glos.info:
fp.startElement(unicode(t[0]), attrs)
fp.characters(unicode(t[1]))
fp.endElement(unicode(t[0]))
fp.endElement(u'xfardic')
fp.startElement(u'words', attrs)
for item in glos.data:
try:
tmpXmlFile.characters(item[1])
except:
log.exception('While writing xdb file, an error on word "%s":' %
item[0])
continue
fp.startElement(u'word', attrs)
fp.startElement(u'in', attrs)
fp.characters(unicode(item[0]))
fp.endElement(u'in')
fp.startElement(u'out', attrs)
fp.characters(unicode(item[1]))
fp.endElement(u'out')
fp.endElement(u'words')
fp.endDocument()
xdbFp.close()
def write_2(glos, filename):
from xml.sax.saxutils import XMLGenerator
from xml.sax.xmlreader import AttributesNSImpl
xdbFp = open(filename, 'wb')
fp = XMLGenerator(xdbFp, 'utf-8')
attrs = AttributesNSImpl({}, {})
fp.startElement('xfardic', attrs)
for key, value in glos.iterInfo():
fp.startElement(key, attrs)
fp.characters(value)
fp.endElement(key)
fp.endElement('xfardic')
fp.startElement('words', attrs)
for entry in glos:
word = entry.getWord()
defi = entry.getDefi()
try:
tmpXmlFile.characters(defi)
except:
log.exception('While writing xdb file, an error on word "%s":' %
word)
continue
fp.startElement('word', attrs)
fp.startElement('in', attrs)
fp.characters(str(word))
fp.endElement('in')
fp.startElement('out', attrs)
fp.characters(str(defi))
fp.endElement('out')
fp.endElement('words')
fp.endDocument()
xdbFp.close()
def to_sax(walker, handler):
"""Call SAX-like content handler based on treewalker walker"""
handler.startDocument()
for prefix, namespace in list(prefix_mapping.items()):
handler.startPrefixMapping(prefix, namespace)
for token in walker:
type = token["type"]
if type == "Doctype":
continue
elif type in ("StartTag", "EmptyTag"):
attrs = AttributesNSImpl(token["data"], unadjustForeignAttributes)
handler.startElementNS((token["namespace"], token["name"]),
token["name"], attrs)
if type == "EmptyTag":
handler.endElementNS((token["namespace"], token["name"]),
token["name"])
elif type == "EndTag":
handler.endElementNS((token["namespace"], token["name"]),
token["name"])
elif type in ("Characters", "SpaceCharacters"):
handler.characters(token["data"])
elif type == "Comment":
pass
else:
assert False, "Unknown token type"
for prefix, namespace in list(prefix_mapping.items()):
handler.endPrefixMapping(prefix)
handler.endDocument()
def start(self):
"""
Start to writer out the XML.
"""
self._writer.startDocument()
attrs = AttributesNSImpl({}, {})
self._writer.startElementNS((None, self._root), self._root, attrs)
def write_entity(self, entity):
"""
Write a entity out to the XML.
"""
# default value for None
type_default_values = {
'int': -1,
'decimal': -1.0,
'string': '',
'date': date.max.isoformat()
}
xmlattrs = AttributesNSImpl({}, {})
self._writer.startElementNS((None, self._type_class), self._type_class, xmlattrs)
field_list = entity.get_field_list()
for field_name, stype, doc in field_list:
self._writer.startElementNS((None, field_name), field_name, xmlattrs)
# same as entity_attr = entity.`field_name`
entity_attr = getattr(entity, field_name)
attr_type = entity.typeof(field_name)
if entity_attr == None:
self._writer.characters(str(type_default_values[attr_type]))
else:
if attr_type == 'date':
# isoformat is YYYY-MM-DD.
self._writer.characters(entity_attr.isoformat())
else:
self._writer.characters(str(entity_attr))
self._writer.endElementNS((None, field_name), field_name)
self._writer.endElementNS((None, self._type_class), self._type_class)
def edfg_attrs (self, attrs) :
ns_attrs = {}
qnames = {}
for k, v in attrs.items() :
ns_attrs[(NS_MAP['e'], k)] = v
return AttributesNSImpl(ns_attrs, qnames);
def write_meta (self, name, content) :
attrs = AttributesNSImpl({(NS_MAP['h'], 'name'):name,
(NS_MAP['h'], 'content'):content},
{});
self.xml.startElementNS((NS_MAP['h'], 'meta'), None, attrs)
self.xml.endElementNS((NS_MAP['e'], 'meta'), None)
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 write_style (self, src) :
attrs = AttributesNSImpl({(NS_MAP['h'], 'type'):'text/css',
(NS_MAP['h'], 'media'):'screen'},
{});
self.xml.startElementNS((NS_MAP['h'], 'style'), None, attrs)
self.xml.characters("@import \"%s\";" % src)
self.xml.endElementNS((NS_MAP['e'], 'style'), None)
def write_script (self, src) :
attrs = AttributesNSImpl({(NS_MAP['h'], 'type'):'application/x-javascript',
(NS_MAP['h'], 'src'):src},
{});
self.xml.startElementNS((NS_MAP['h'], 'script'), None, attrs)
self.xml.characters(" ")
self.xml.endElementNS((NS_MAP['e'], 'script'), None)
def write_header(self, allvarsL):
self.writer.startElementNS((SPARQL_XML_NAMESPACE, "head"), "head",
AttributesNSImpl({}, {}))
for i in range(0, len(allvarsL)):
attr_vals = {
(None, "name"): str(allvarsL[i]),
}
attr_qnames = {
(None, "name"): "name",
}
self.writer.startElementNS(
(SPARQL_XML_NAMESPACE, "variable"),
"variable",
AttributesNSImpl(attr_vals, attr_qnames),
)
self.writer.endElementNS((SPARQL_XML_NAMESPACE, "variable"),
"variable")
self.writer.endElementNS((SPARQL_XML_NAMESPACE, "head"), "head")
def _attributes(self, **attributes):
values, qnames = {}, {}
for name, value in attributes.iteritems():
name = unicode(name)
ns_name = (None, name)
qnames[ns_name] = name
values[ns_name] = value
return AttributesNSImpl(values, qnames)
def write_toolbar (self) :
tb_attrs = AttributesNSImpl({(NS_MAP['h'], 'class'):'toolbar'},
{});
title_attrs = AttributesNSImpl({(NS_MAP['h'], 'id'):'pageTitle'},
{});
back_attrs = AttributesNSImpl({(NS_MAP['h'], 'id'):'backButton',
(NS_MAP['h'], 'class'):'button',
(NS_MAP['h'], 'href'):'#'},
{});
self.xml.startElementNS((NS_MAP['h'], 'div'), None, tb_attrs)
self.xml.startElementNS((NS_MAP['h'], 'h1'), None, title_attrs)
self.xml.endElementNS((NS_MAP['h'], 'h1'), None)
self.xml.startElementNS((NS_MAP['h'], 'a'), None, back_attrs)
self.xml.endElementNS((NS_MAP['h'], 'a'), None)
self.xml.endElementNS((NS_MAP['h'], 'div'), None)
