def xml_serialize(data):
def to_xml(self, xml, data):
if isinstance(data, (list, tuple)):
for item in data:
xml.startElement('resource', {})
to_xml(xml, item)
xml.endElement('resource')
elif isinstance(data, dict):
for key, value in data.iteritems():
xml.startElement(key, {})
to_xml(xml, value)
xml.endElement(key)
else:
xml.characters(smart_unicode(data))
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, 'utf-8')
xml.startDocument()
xml.startElement('response', {})
to_xml(xml, base_serialize(data))
xml.endElement('response')
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML.
"""
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
# If we do not have users or request_user then we have errors
if not data.get('users', False) and not data.get('request_user', False):
self._to_errors(data, xml)
xml.endDocument()
return stream.getvalue()
# If users are a list, deal with that
if type(data['users']) is QuerySet or type(data['users']) is list:
xml.startElement('people', {'type': 'array'})
self._to_xml(data['users'], data['request_user'], xml)
xml.endElement('people')
# Otherwise just render a person
else:
self.render_person(data['users'], data['request_user'], xml)
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML.
"""
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
# If we do not have users or request_user then we have errors
if not data.get('users', False) and not data.get(
'request_user', False):
self._to_errors(data, xml)
xml.endDocument()
return stream.getvalue()
# If users are a list, deal with that
if type(data['users']) is QuerySet or type(data['users']) is list:
xml.startElement('people', {'type': 'array'})
self._to_xml(data['users'], data['request_user'], xml)
xml.endElement('people')
# Otherwise just render a person
else:
self.render_person(data['users'], data['request_user'], xml)
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Duplicate `rest_framework_xml.renderers.XMLRenderer.render()` to add
the `xmlns` attribute to the root node
"""
if not hasattr(self, 'xmlns'):
raise NotImplemented('`xmlns` must be implemented!')
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
xml.startElement(
self.root_tag_name,
{'xmlns': f'http://openrosa.org/xforms/{self.xmlns}'},
)
self._to_xml(xml, data)
xml.endElement(self.root_tag_name)
xml.endDocument()
return stream.getvalue()
def render(self, request):
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
self._to_xml(xml, self.construct())
xml.endDocument()
return stream.getvalue()
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u'feed', self.root_attributes())
self.add_root_elements(handler)
self.write_items(handler)
handler.endElement(u"feed")
class XMLGenerator(BaseGenerator):
def __init__(self, pretty_print: bool = False):
self.pretty_print = pretty_print
self.renderer = XMLRenderer()
self.stream = StringIO()
self.xml = SimplerXMLGenerator(self.stream, XMLRenderer.charset)
def start(self):
self.xml.startDocument()
self.xml.startElement(XMLRenderer.root_tag_name, {})
def add_list_item(self, data: dict):
self.xml.startElement(XMLRenderer.item_tag_name, {})
self.renderer._to_xml(self.xml, data)
self.xml.endElement(XMLRenderer.item_tag_name)
def finish(self):
self.xml.endElement(XMLRenderer.root_tag_name)
self.xml.endDocument()
def get_data(self):
if not self.pretty_print:
return self.stream.getvalue()
else:
tree = etree.XML(self.stream.getvalue().encode('utf-8'))
string = etree.tostring(tree,
encoding='utf-8',
pretty_print=True,
xml_declaration=True)
return string.decode('utf-8')
def render(self, data, *args, **kwargs):
charset = 'utf-8'
root_node = 'xforms'
xmlns = "http://openrosa.org/xforms/xformsList"
if 'detail' in data.keys():
stream = StringIO()
xml = SimplerXMLGenerator(stream, charset)
xml.startDocument()
xml.startElement(root_node, {'xmlns': xmlns})
for key, value in six.iteritems(data):
xml.startElement(key, {})
xml.characters(smart_text(value))
xml.endElement(key)
xml.endElement(root_node)
xml.endDocument()
return stream.getvalue()
else:
json = self.transform_to_xform_json(data)
survey = create_survey_element_from_dict(json)
xml = survey.xml()
fix_languages(xml)
xml = xml.toxml()
xml = self.insert_version_attribute(xml,
data.get('id_string'),
data.get('version'))
xml = self.insert_uuid_bind(xml, data.get('id_string'))
return xml
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
if self.feed["language"] is not None:
handler.startElement(u"feed", {u"xmlns": self.ns, u"xml:lang": self.feed["language"]})
else:
handler.startElement(u"feed", {u"xmlns": self.ns})
handler.addQuickElement(u"title", self.feed["title"])
handler.addQuickElement(u"link", "", {u"rel": u"alternate", u"href": self.feed["link"]})
if self.feed["feed_url"] is not None:
handler.addQuickElement(u"link", "", {u"rel": u"self", u"href": self.feed["feed_url"]})
handler.addQuickElement(u"id", self.feed["link"])
handler.addQuickElement(u"updated", rfc3339_date(self.latest_post_date()).decode("ascii"))
if self.feed["author_name"] is not None:
handler.startElement(u"author", {})
handler.addQuickElement(u"name", self.feed["author_name"])
if self.feed["author_email"] is not None:
handler.addQuickElement(u"email", self.feed["author_email"])
if self.feed["author_link"] is not None:
handler.addQuickElement(u"uri", self.feed["author_link"])
handler.endElement(u"author")
if self.feed["subtitle"] is not None:
handler.addQuickElement(u"subtitle", self.feed["subtitle"])
for cat in self.feed["categories"]:
handler.addQuickElement(u"category", "", {u"term": cat})
if self.feed["feed_copyright"] is not None:
handler.addQuickElement(u"rights", self.feed["feed_copyright"])
self.write_items(handler)
handler.endElement(u"feed")
def xml_dumps(data):
def to_xml(xml, data):
if isinstance(data, (list, tuple)):
for item in data:
xml.startElement("resource", {})
to_xml(xml, item)
xml.endElement("resource")
elif isinstance(data, dict):
for key, value in data.iteritems():
xml.startElement(key, {})
to_xml(xml, value)
xml.endElement(key)
else:
xml.characters(smart_text(data))
stream = StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("response", {})
to_xml(xml, data)
xml.endElement("response")
xml.endDocument()
return stream.getvalue()
def render(self, data, *args, **kwargs):
charset = 'utf-8'
root_node = 'xforms'
xmlns = "http://openrosa.org/xforms/xformsList"
if 'detail' in data.keys():
stream = StringIO()
xml = SimplerXMLGenerator(stream, charset)
xml.startDocument()
xml.startElement(root_node, {'xmlns': xmlns})
for key, value in six.iteritems(data):
xml.startElement(key, {})
xml.characters(smart_text(value))
xml.endElement(key)
xml.endElement(root_node)
xml.endDocument()
return stream.getvalue()
else:
json = self.transform_to_xform_json(data)
survey = create_survey_element_from_dict(json)
xml = survey.xml()
fix_languages(xml)
xml = xml.toxml()
xml = self.insert_version_attribute(xml,
data.get('id_string'),
data.get('version'))
xml = self.insert_uuid_bind(xml, data.get('id_string'))
return xml
def error(self, request, status_code, error_dict=None):
"""
Return XML error response that includes a human readable error
message, application-specific errors and a machine readable
status code.
"""
from django.conf import settings
if not error_dict:
error_dict = ErrorDict()
response = HttpResponse(mimetype = self.mimetype)
response.status_code = status_code
xml = SimplerXMLGenerator(response, settings.DEFAULT_CHARSET)
xml.startDocument()
xml.startElement("django-error", {})
xml.addQuickElement(name="error-message", contents='%d %s' % (status_code, STATUS_CODE_TEXT[status_code]))
xml.addQuickElement(name="status-code", contents=str(status_code))
if error_dict:
xml.startElement("model-errors", {})
for (model_field, errors) in error_dict.items():
for error in errors:
xml.addQuickElement(name=model_field, contents=error)
xml.endElement("model-errors")
xml.endElement("django-error")
xml.endDocument()
return response
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement('feed', self.root_attributes())
self.add_root_elements(handler)
self.write_items(handler)
handler.endElement("feed")
def error(self, request, status_code, error_dict=None):
"""
Return XML error response that includes a human readable error
message, application-specific errors and a machine readable
status code.
"""
from django.conf import settings
if not error_dict:
error_dict = ErrorDict()
response = HttpResponse(mimetype = self.mimetype)
response.status_code = status_code
xml = SimplerXMLGenerator(response, settings.DEFAULT_CHARSET)
xml.startDocument()
xml.startElement("django-error", {})
xml.addQuickElement(name="error-message", contents='%d %s' % (status_code, STATUS_CODE_TEXT[status_code]))
xml.addQuickElement(name="status-code", contents=str(status_code))
if error_dict:
xml.startElement("model-errors", {})
for (model_field, errors) in error_dict.items():
for error in errors:
xml.addQuickElement(name=model_field, contents=error)
xml.endElement("model-errors")
xml.endElement("django-error")
xml.endDocument()
return response
def write(self, outfile, encoding):
"""Write feed date into given outfile using given encoding.
@param outfile: 'file' to write feed data into, e.g. Django response
@type outfile: File
@param encoding: feed's encoding
@type encoding: string
"""
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u"rss", {u"version": self._version, u"xmlns:wfw": u"http://wellformedweb.org/CommentAPI/"})
handler.startElement(u"channel", {})
handler.addQuickElement(u"title", self.feed['title'])
handler.addQuickElement(u"link", self.feed['link'])
handler.addQuickElement(u"description", self.feed['description'])
if self.feed['language'] is not None:
handler.addQuickElement(u"language", self.feed['language'])
for cat in self.feed['categories']:
handler.addQuickElement(u"category", cat)
if self.feed['feed_copyright'] is not None:
handler.addQuickElement(u"copyright", self.feed['feed_copyright'])
handler.addQuickElement(u"lastBuildDate", rfc2822_date(self.latest_post_date()).decode('ascii'))
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement(u"rss")
def place_kml(request, encoding='utf-8', mimetype='text/plain'):
"""
Write out all the known places to KML
"""
# mimetype = "application/vnd.google-earth.kml+xml"
# mimetype = "text/html"
places = Locality.objects.exclude(
latitude=None).annotate(Count('museumobject'))
response = HttpResponse(mimetype=mimetype)
handler = SimplerXMLGenerator(response, encoding)
handler.startDocument()
handler.startElement(u"kml",
{u"xmlns": u"http://www.opengis.net/kml/2.2"})
handler.startElement(u"Document", {})
for place in places:
place_url = request.build_absolute_uri(place.get_absolute_url())
handler.startElement(u"Placemark", {})
handler.addQuickElement(u"name",
"%s (%s)" % (place.name, place.museumobject__count))
handler.addQuickElement(u"description",
'<a href="%s">%s</a>' % (place_url, place.__unicode__()))
handler.startElement(u"Point", {})
handler.addQuickElement(u"coordinates", place.get_kml_coordinates())
handler.endElement(u"Point")
handler.endElement(u"Placemark")
handler.endElement(u"Document")
handler.endElement(u"kml")
return response
def dump_xml(data):
"""Simple function to convert python data structures to xml."""
def _to_xml(xml, data):
if isinstance(data, dict):
for key, value in data.iteritems():
key = force_unicode(key)
xml.startElement(key, {})
_to_xml(xml, value)
xml.endElement(key)
elif hasattr(data, '__iter__'):
for item in data:
xml.startElement("resource", {})
_to_xml(xml, item)
xml.endElement("resource")
else:
xml.characters(force_unicode(data))
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("response", {})
_to_xml(xml, data)
xml.endElement("response")
xml.endDocument()
return stream.getvalue()
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
if self.feed['language'] is not None:
handler.startElement("feed", {"xmlns": self.ns, "xml:lang": self.feed['language']})
else:
handler.startElement("feed", {"xmlns": self.ns})
handler.addQuickElement("title", self.feed['title'])
handler.addQuickElement("link", "", {"rel": "alternate", "href": self.feed['link']})
if self.feed['feed_url'] is not None:
handler.addQuickElement("link", "", {"rel": "self", "href": self.feed['feed_url']})
handler.addQuickElement("id", self.feed['id'])
handler.addQuickElement("updated", rfc3339_date(self.latest_post_date()).decode('ascii'))
if self.feed['author_name'] is not None:
handler.startElement("author", {})
handler.addQuickElement("name", self.feed['author_name'])
if self.feed['author_email'] is not None:
handler.addQuickElement("email", self.feed['author_email'])
if self.feed['author_link'] is not None:
handler.addQuickElement("uri", self.feed['author_link'])
handler.endElement("author")
if self.feed['subtitle'] is not None:
handler.addQuickElement("subtitle", self.feed['subtitle'])
for cat in self.feed['categories']:
handler.addQuickElement("category", "", {"term": cat})
if self.feed['feed_copyright'] is not None:
handler.addQuickElement("rights", self.feed['feed_copyright'])
self.write_items(handler)
handler.endElement("feed")
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
if self.feed['language'] is not None:
handler.startElement(u"feed", {u"xmlns": self.ns, u"xml:lang": self.feed['language']})
else:
handler.startElement(u"feed", {u"xmlns": self.ns})
handler.addQuickElement(u"title", self.feed['title'])
handler.addQuickElement(u"link", "", {u"rel": u"alternate", u"href": self.feed['link']})
if self.feed['feed_url'] is not None:
handler.addQuickElement(u"link", "", {u"rel": u"self", u"href": self.feed['feed_url']})
handler.addQuickElement(u"id", self.feed['link'])
handler.addQuickElement(u"updated", rfc3339_date(self.latest_post_date()).decode('ascii'))
if self.feed['author_name'] is not None:
handler.startElement(u"author", {})
handler.addQuickElement(u"name", self.feed['author_name'])
if self.feed['author_email'] is not None:
handler.addQuickElement(u"email", self.feed['author_email'])
if self.feed['author_link'] is not None:
handler.addQuickElement(u"uri", self.feed['author_link'])
handler.endElement(u"author")
if self.feed['subtitle'] is not None:
handler.addQuickElement(u"subtitle", self.feed['subtitle'])
for cat in self.feed['categories']:
handler.addQuickElement(u"category", "", {u"term": cat})
if self.feed['feed_copyright'] is not None:
handler.addQuickElement(u"rights", self.feed['feed_copyright'])
self.write_items(handler)
handler.endElement(u"feed")
def render(self, request):
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("Response", {})
self._to_xml(xml, self.construct())
xml.endElement("Response")
xml.endDocument()
return stream.getvalue()
def render(self, request, data, *, response_status):
stream = StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("data", {})
self._to_xml(xml, data)
xml.endElement("data")
xml.endDocument()
return stream.getvalue()
def xml(request, data):
stream = StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("response", {})
to_xml(xml, data)
xml.endElement("response")
xml.endDocument()
return stream.getvalue()
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u"rss", self.rss_attributes())
handler.startElement(u"channel", self.root_attributes())
self.add_root_elements(handler)
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement(u"rss")
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement("rss", self.rss_attributes())
handler.startElement("channel", self.root_attributes())
self.add_root_elements(handler)
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement("rss")
def WebFinger_HostMeta(request):
res = HttpResponse(content_type="application/xml")
xmlHandle = SimplerXMLGenerator(res, settings.DEFAULT_CHARSET)
xmlHandle.startDocument()
xmlHandle.startElement("XRD", {"xmlns": "http://docs.oasis-open.org/ns/xri/xrd-1.0"})
xmlHandle.addQuickElement("Link", attrs={"rel": "lrdd", "type": "application/xrd+xml", "template": "https://" + settings.CP_ENDPOINT + "/.well-known/webfinger?resource={uri}"})
xmlHandle.endElement("XRD")
xmlHandle.endDocument()
return res
def render(self, data, prettyprint=False):
"""
parameters:
data = dictionary of the things to be shown
prettyprint = flag for pretty printing the xml output (including whitespace and linebreaks)
"""
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
# add a comment
xml._write(self.comment)
# add namespace definitions
nsattrs = {}
nsattrs['version'] = self.version
#nsattrs['encoding'] = charser
nsattrs['xmlns:vosi'] = self.ns_vosiavail
#nsattrs['xmlns:xsi'] = self.ns_xsi
#nsattrs['xmlns:vs'] = self.ns_vs
# add root node
xml.startElement('vosi:availability', nsattrs)
# add mandatory node:
xml.startElement('vosi:available', {})
xml.characters(smart_unicode(data['available']))
xml.endElement('vosi:available')
# remove available from data dict
data.pop('available', None)
# add possible optional nodes:
for key in data.keys():
xml.startElement('vosi:' + key, {})
xml.characters(smart_unicode(data[key]))
xml.endElement('vosi:' + key)
xml.endElement('vosi:availability')
xml.endDocument()
xml_string = stream.getvalue()
# make the xml pretty, i.e. use linebreaks and indentation
# the sax XMLGenerator behind SimpleXMLGenerator does not seem to support this,
# thus need a library that can do it.
# TODO: since we use lxml anyway, maybe build the whole xml-tree with lxml.etree!
# NOTE: This removes any possibly existing comments from the xml output!
if prettyprint is True:
parsed = etree.fromstring(xml_string)
pretty_xml = etree.tostring(parsed, pretty_print=True)
xml_string = pretty_xml
return xml_string
def render(self,):
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement(self.root_element, {})
self._to_xml(xml, self.data_dict)
xml.endElement(self.root_element)
xml.endDocument()
return stream.getvalue()
def render(self, obj, stream, **opts):
xml = SimplerXMLGenerator(stream, 'utf-8')
xml.startDocument()
xml.startElement('django-objects', {'version': '1.0'})
if hasattr(obj, '__iter__'):
[self.model_to_xml(xml, item) for item in obj]
else:
self.model_to_xml(xml, obj)
xml.endElement('django-objects')
xml.endDocument()
def render(self, obj, stream, **opts):
xml = SimplerXMLGenerator(stream, 'utf-8')
xml.startDocument()
xml.startElement('django-objects', {'version': '1.0'})
if hasattr(obj, '__iter__'):
[self.model_to_xml(xml, item) for item in obj]
else:
self.model_to_xml(xml, obj)
xml.endElement('django-objects')
xml.endDocument()
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u"rdf:RDF", self.root_attributes())
handler.startElement(u"rss:channel", dict(tuple(self.rss_attributes().items())+((u"rdf:about", self.feed["link"]),)))
self.add_root_elements(handler)
self.endChannelElement(handler)
self.write_items(handler)
handler.endElement(u"rdf:RDF")
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u'kml', self.root_attributes())
handler.startElement(u'Document', {})
self.add_root_elements(handler)
self.write_styles(handler)
self.write_items(handler)
handler.endElement(u"Document")
handler.endElement(u"kml")
def to_xml(self, out, encoding=settings.DEFAULT_CHARSET):
"""Exports page data in a XML formated file. It stores
page info as first item and value data following it.
Files are base64 encoded and exported too.
Example:
<cms-page>
<page path="/path/" template="homepage" description="Homepage"
locale="en-gb" meta_title="Title" meta_description="Description"
meta_keywords="Keywords" search_image="base64 encoded image"
search_image_name="file name of search image"
search_text="Search text"></page>
<value name="heading" type="text" value="Page title"></value>
<value name="an_image" type="image" value="bas64 enconded"></value>
...
</cms-page>
"""
xml = SimplerXMLGenerator(out=out, encoding=encoding)
xml.startDocument()
xml.startElement("cms-page", {})
# store page info in first child
data = {
"path": self.path.path,
"template": self.template,
"description": self.description,
"locale": self.path.locale,
"meta_title": self.meta_title,
"meta_description": self.meta_description,
"meta_keywords": self.meta_keywords,
"search_text": self.search_text,
}
if self.search_image: # add image content if any
img = image_to_b64(self.search_image)
if img is not None:
name, content = img
data["search_image_name"] = name
data["search_image"] = content
xml.startElement("page", data)
xml.endElement("page")
# store values
values = self.values.values_list("name", "type", "value")
for name, value_type, value in values:
attrs = {"name": name, "type": value_type, "value": value}
if value_type in TYPES_MAP:
attrs.update(TYPES_MAP[value_type]().to_xml(value))
xml.startElement("value", attrs)
xml.endElement("value")
xml.endElement("cms-page")
xml.endDocument()
return out
def render(self):
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement('response', {'version':getattr(settings, 'API_VERSION', '1.0')})
xml.startElement('request', {'path':self.request.path})
xml.endElement('request')
self._xml(xml, self.construct(), resource_name=None)
xml.endElement('response')
xml.endDocument()
return stream.getvalue()
def get_xml(self, data, item_name):
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
xml.startElement(self.root_tag_name, {})
self._to_xml(xml, data, item_name, 0)
xml.endElement(self.root_tag_name)
xml.endDocument()
return stream.getvalue()
def render(self, response):
if self.format != XMLResponseEncoder.format:
return super(XMLResponseEncoder, self).render(response)
stream = StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("response", {})
self._to_xml(xml, response)
xml.endElement("response")
xml.endDocument()
content = stream.getvalue()
return HttpResponse(content, mimetype=XMLResponseEncoder.mimetype)
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u"rdf:RDF", self.root_attributes())
handler.startElement(
u"rss:channel", dict(tuple(self.rss_attributes().items()) + ((u"rdf:about", self.feed["link"]),))
)
self.add_root_elements(handler)
self.endChannelElement(handler)
self.write_items(handler)
handler.endElement(u"rdf:RDF")
def render(self, data):
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
self.render_document(xml, data)
xml.endDocument()
return stream.getvalue()
def sitemap_generator(request, maps, page, current_site):
output = StringIO()
protocol = request.is_secure() and 'https' or 'http'
xml = SimplerXMLGenerator(output, settings.DEFAULT_CHARSET)
xml.startDocument()
xml.startElement(
'urlset', {'xmlns': 'http://www.sitemaps.org/schemas/sitemap/0.9'})
yield output.getvalue()
pos = output.tell()
for site in maps:
if callable(site):
if issubclass(site, RequestSitemap):
site = site(request=request)
else:
site = site()
elif hasattr(site, 'request'):
site.request = request
try:
urls = site.get_urls(page=page, site=current_site,
protocol=protocol)
except InvalidPage:
raise Http404('Page not found')
for url in urls:
xml.startElement('url', {})
xml.addQuickElement('loc', url['location'])
try:
if url['lastmod']:
xml.addQuickElement(
'lastmod', url['lastmod'].strftime('%Y-%m-%d'))
except (KeyError, AttributeError):
pass
try:
if url['changefreq']:
xml.addQuickElement('changefreq', url['changefreq'])
except KeyError:
pass
try:
if url['priority']:
xml.addQuickElement('priority', url['priority'])
except KeyError:
pass
xml.endElement('url')
output.seek(pos)
yield output.read()
pos = output.tell()
xml.endElement('urlset')
xml.endDocument()
output.seek(pos)
last = output.read()
output.close()
yield last
def dict2xml(self, data):
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("root", {})
self._to_xml(xml, data)
xml.endElement("root")
xml.endDocument()
return stream.getvalue()
def render(self, response):
if self.format != XMLResponseEncoder.format:
return super(XMLResponseEncoder, self).render(response)
stream = StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("response", {})
self._to_xml(xml, response)
xml.endElement("response")
xml.endDocument()
content = stream.getvalue()
return HttpResponse(content, mimetype=XMLResponseEncoder.mimetype)
def dict2xml(self, data):
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("root", {})
self._to_xml(xml, data)
xml.endElement("root")
xml.endDocument()
return stream.getvalue()
def render(self, request):
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("op_content", {})
self._to_xml(xml, self.construct(), item_name = self._get_item_name())
xml.endElement("op_content")
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
if data is None:
return ''
view = (renderer_context.get("view") if renderer_context else None)
self.item_tag_name = getattr(view, "item_tag_name", self.item_tag_name)
self.root_tag_name = getattr(view, "root_tag_name", self.root_tag_name)
stream = io.StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
root_tag_name = (getattr(data, "xml_tag", None) or self.root_tag_name)
self._to_xml(xml, data, root_tag_name)
xml.endDocument()
return stream.getvalue()
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement(u"rss", {u"version": self._version})
handler.startElement(u"channel", {})
handler.addQuickElement(u"title", self.feed['title'])
handler.addQuickElement(u"link", self.feed['link'])
handler.addQuickElement(u"description", self.feed['description'])
if self.feed['language'] is not None:
handler.addQuickElement(u"language", self.feed['language'])
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement(u"rss")
def render(self, request):
stream = io.BytesIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("response", {})
self._to_xml(xml, self.construct())
xml.endElement("response")
xml.endDocument()
return stream.getvalue()
def encode(self, request, converted_data, resource, result, field_name_list):
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("response", {})
self._to_xml(xml, converted_data)
xml.endElement("response")
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML without the root tag. The root tag was added in the default
XMLRenderer. So this CustomXMLRenderer removes it by overriding XMLRenderer class.
"""
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
self._to_xml(xml, data)
xml.endDocument()
return stream.getvalue()
def render(self, request, post_processor=None):
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("response", {})
self._to_xml(xml, self.construct(post_processor=post_processor))
xml.endElement("response")
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML without the root tag. The root tag was added in the default
XMLRenderer. So this CustomXMLRenderer removes it by overriding XMLRenderer class.
"""
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
self._to_xml(xml, data)
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
if data is None:
return ''
view = (renderer_context.get("view") if renderer_context else None)
self.item_tag_name = getattr(view, "item_tag_name", self.item_tag_name)
self.root_tag_name = getattr(view, "root_tag_name", self.root_tag_name)
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
root_tag_name = (getattr(data, "xml_tag", None) or self.root_tag_name)
self._to_xml(xml, data, root_tag_name)
xml.endDocument()
return stream.getvalue()
def encode(self, data, **kwargs):
stream = cStringIO()
xml = SimplerXMLGenerator(stream, 'utf-8')
xml.startDocument()
xml.startElement('response', {})
self._to_xml(xml, data)
xml.endElement('response')
xml.endDocument()
return stream.getvalue()
def encode(self, request, converted_data, resource, result):
stream = cStringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("response", {})
self._to_xml(xml, converted_data)
xml.endElement("response")
xml.endDocument()
return stream.getvalue()
def get_xml_export(self, context):
results = self._get_objects(context)
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
xml.startElement("objects", {})
self._to_xml(xml, results)
xml.endElement("objects")
xml.endDocument()
return stream.getvalue().split('\n')[1]
def _format_data(self, data, charset):
""" Format data into XML. """
if data is None or data == '':
return u''
stream = StringIO.StringIO()
xml = SimplerXMLGenerator(stream, charset)
xml.startDocument()
xml.startElement(self._root_element_name(), {})
self._to_xml(xml, data)
xml.endElement(self._root_element_name())
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
In case a request is called on /api/v1/, we now redirect the call to DRF instead of
Tastypie. The differences between DRF and Tastypie are:
- Different names and values for several fields (see _rename_fields).
On paginated results:
- An additional 'meta' object containing the limit, next, previous and total_count;
- Next and previous links do not show the domain;
- The root tag name is 'response';
- The tag name of the results is 'objects';
- The tag name for each result is 'object'.
On non-paginated results:
- The tag name of the result is 'object'.
"""
request = renderer_context.get('request')
if '/api/v1/' in request.path:
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
if all(k in data.keys() for k in
['count', 'next', 'previous', 'offset', 'results']):
# Paginated result
xml.startElement("response", {})
data = _convert_data_for_tastypie(request,
renderer_context['view'],
data)
self._to_xml(xml, data)
xml.endElement("response")
else:
# Non-paginated result
xml.startElement("object", {})
self._to_xml(xml, _rename_fields([data])[0])
xml.endElement("object")
xml.endDocument()
return stream.getvalue()
elif isinstance(data, dict) and 'offset' in data.keys():
data.pop('offset')
return XMLRenderer().render(data, accepted_media_type,
renderer_context)
def get_xml_export(self, context):
results = self._get_objects(context)
stream = six.BytesIO()
xml = SimplerXMLGenerator(stream, self.export_unicode_encoding)
xml.startDocument()
xml.startElement("objects", {})
self._to_xml(xml, results)
xml.endElement("objects")
xml.endDocument()
return stream.getvalue().split((b'\n'))[1]
def render(self, data, accepted_media_type=None, renderer_context=None):
if data is None:
return ""
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
xml.startElement(self.root_tag_name, attributes)
self._to_xml(xml, data)
xml.endElement(self.root_tag_name)
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML.
"""
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
xml.startElement(self.root_tag_name, {})
self._to_xml(xml, data)
xml.endElement(self.root_tag_name)
xml.endDocument()
#raise AssertionError(type(stream.getvalue()));
generic_xml = stream.getvalue()
if data.get('count') != None and data.get('list') != None:
# deal with multiple tools
xmlfile = 'multiple.xslt'
else:
# deal with a single tool
xmlfile = 'framework_XML_to_biotoolsSchema_3.3.0_XML_xslt1.0.xslt'
try:
xslt1 = lxmletree.parse(
'/elixir/application/backend/elixir/biotoolsSchema/' + xmlfile)
transform1 = lxmletree.XSLT(xslt1)
dom = lxmletree.fromstring(generic_xml)
newdom = transform1(dom)
# removing empty elements
xslt2 = lxmletree.parse(
"/elixir/application/backend/elixir/biotoolsSchema/removeEmptyElements.xslt"
)
transform2 = lxmletree.XSLT(xslt2)
newdom2 = transform2(newdom)
except (lxmletree.XMLSyntaxError, Exception) as e:
raise ParseError(
'XML error - %s. Please notify [email protected] if you see this error. '
% e)
return lxmletree.tostring(newdom2)
def _encode(self, data, **kwargs):
if data is not None:
stream = StringIO()
xml = SimplerXMLGenerator(stream, 'utf-8')
xml.startDocument()
xml.startElement('response', {})
self._to_xml(xml, data)
xml.endElement('response')
xml.endDocument()
return stream.getvalue()
else:
return ''
