def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(
self.stream, self.options.get("encoding",
settings.DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement(
"xliff", {
"version": "1.2",
"xmlns": "urn:oasis:names:tc:xliff:document:1.2",
"xmlns:d": "https://docs.djangoproject.com/"
})
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 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 get_xml_export(self, context):
results = self._get_objects(context)
stream = io.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 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 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):
"""
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 ''
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()
if isinstance(data, (list, tuple)):
self._render_list(data, xml, renderer_context)
elif isinstance(data, dict):
self._render_dict(data, xml, renderer_context)
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()
self._to_xml(xml, data)
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'])
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'])
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement(u"rss")
def render(self, data, accepted_media_type=None, renderer_context=None):
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, "utf-8")
xml.startDocument()
self._to_xml(xml, data)
xml.endDocument()
response = stream.getvalue()
if self.strip_declaration:
declaration = '<?xml version="1.0" encoding="utf-8"?>'
if response.startswith(declaration):
response = response[len(declaration):]
return response.strip()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders *obj* into serialized XML.
"""
if data is None:
return ''
stream = 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 write(self, outfile, encoding):
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 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)
if self.with_xml_declaration:
xml.startDocument()
xml.startElement(self.root_tag_name, {})
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("list", {
'last_update': str(date.today()),
'listing': '834'
})
self._to_xml(xml, data)
xml.endElement("list")
xml.endDocument()
return stream.getvalue()
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders *obj* into serialized XML.
"""
# if data is None:
# return ''
# elif isinstance(data, six.string_types):
# return data
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
xml.startElement(self.root_node, {'xmlns': self.xmlns})
self._to_xml(xml, data)
xml.endElement(self.root_node)
xml.endDocument()
return stream.getvalue()
def __init__(self, error_message=None, content='', mimetype=None,
status=None, content_type='text/xml; charset=utf-8'):
super(TrackBackResponse, self).__init__(content=content,
mimetype=mimetype,
status=status,
content_type=content_type)
response_content = StringIO()
generator = SimplerXMLGenerator(response_content, 'utf-8')
generator.startDocument()
generator.startElement('response', {})
if error_message:
generator.addQuickElement('error', '1')
generator.addQuickElement('message', error_message)
else:
generator.addQuickElement('error', '0')
generator.endElement('response')
self.content = response_content.getvalue()
response_content.close()
self['Content-Length'] = str(len(self.content))
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML.
"""
if data is None:
return ''
endpoint: Endpoint = renderer_context['view'].endpoint
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset, short_empty_elements=True)
xml.startDocument()
if self.is_error_response(data):
self.render_error_response(xml, data)
else:
self.render_response(xml, data, endpoint)
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(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['id'])
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, 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,
{"xmlns:soapenv": "http://schemas.xmlsoap.org/soap/envelope/"})
xml.startElement(self.second_tag_name, {})
xml.startElement(self.third_tag_name.format(method=data['method']),
{"xmlns:ns2": "http://uws.provider.com/"})
self._to_xml(xml, data['body'])
try:
for params in data['parameters']:
self._to_xml(
xml, {
"parameters": {
"paramKey": params[0],
"paramValue": params[1],
},
})
for statements in data['statements']:
self._to_xml(xml, {
"statements": statements,
})
except KeyError:
pass
xml.endElement(self.third_tag_name.format(method=data['method']))
xml.endElement(self.second_tag_name)
xml.endElement(self.root_tag_name)
xml.endDocument()
return stream.getvalue()
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
handler.startDocument()
handler.startElement("rss", {"version": self._version})
handler.startElement("channel", {})
handler.addQuickElement("title", self.feed['title'])
handler.addQuickElement("link", self.feed['link'])
handler.addQuickElement("description", self.feed['description'])
if self.feed['language'] is not None:
handler.addQuickElement("language", self.feed['language'])
for cat in self.feed['categories']:
handler.addQuickElement("category", cat)
if self.feed['feed_copyright'] is not None:
handler.addQuickElement("copyright", self.feed['feed_copyright'])
handler.addQuickElement(
"lastBuildDate",
rfc2822_date(self.latest_post_date()).decode('ascii'))
if self.feed['ttl'] is not None:
handler.addQuickElement("ttl", self.feed['ttl'])
self.write_items(handler)
self.endChannelElement(handler)
handler.endElement("rss")
def render(self, data, accepted_media_type=None, renderer_context=None):
"""
Renders `data` into serialized XML.
"""
if data is None:
return ''
print(data)
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
reactor_model_id = data[0]['composition'][0]['ibis']['reactor_model']
xml.startElement("base_component ", {
'basecore_ID':
ReactorModel.objects.get(pk=reactor_model_id).name
})
self._to_xml(xml, data)
xml.endElement("base_component ")
xml.endDocument()
return stream.getvalue()
def __init__(self, request, stream):
self.xml = SimplerXMLGenerator(stream, 'utf8')
self.request = request
self.stream = stream
def backup_objects(self):
models = [
Address, Contact, Contract, PhoneNumber, Project, Proposal,
ProposalRow, Invoice, InvoiceRow, Expense
]
self.xml = SimplerXMLGenerator(self.stream, settings.DEFAULT_CHARSET)
self.xml.startDocument()
self.xml.startElement("aemanager", {"version": common()['version']})
for model in models:
for object in model.objects.filter(owner=self.user):
# do not export address of user profile
if not (type(object) == Address
and object.userprofile_set.count()):
self.indent(1)
self.xml.startElement(object._meta.object_name,
{'uuid': object.uuid})
for field in object._meta.local_fields:
if field.name not in ['ownedobject_ptr']:
self.indent(2)
self.xml.startElement(field.name, {})
if getattr(object, field.name) is not None:
if type(field) == ForeignKey:
related = getattr(object, field.name)
if type(related) == Country:
self.xml.addQuickElement(
"object",
attrs={
'country_code':
smart_unicode(
related.country_code2)
})
else:
self.xml.addQuickElement(
"object",
attrs={
'uuid':
smart_unicode(related.uuid)
})
elif type(field) == OneToOneField:
related = getattr(object, field.name)
self.xml.addQuickElement(
"object",
attrs={
'uuid': smart_unicode(related.uuid)
})
else:
self.xml.characters(
field.value_to_string(object))
else:
self.xml.addQuickElement("None")
self.xml.endElement(field.name)
for field in object._meta.many_to_many:
self.indent(2)
self.xml.startElement(field.name, {})
for relobj in getattr(object, field.name).iterator():
self.indent(3)
self.xml.addQuickElement(
"object",
attrs={'uuid': smart_unicode(relobj.uuid)})
self.indent(2)
self.xml.endElement(field.name)
self.indent(1)
self.xml.endElement(smart_unicode(
object._meta.object_name))
self.indent(0)
self.xml.endElement("aemanager")
self.xml.endDocument()
def render(self, obj, stream, **opts):
xml = SimplerXMLGenerator(stream, 'utf-8')
xml.startDocument()
self._to_xml(xml, obj)
xml.endDocument()
def write(self, outfile, encoding):
handler = SimplerXMLGenerator(outfile, encoding)
def render(self, capabilities, prettyprint=False):
"""
parameters:
capabilities = queryset of voresource_capabilities
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_vosicap
nsattrs['xmlns:xsi'] = self.ns_xsi
nsattrs['xmlns:vs'] = self.ns_vs
nsattrs['xmlns:vr'] = self.ns_vr
# add root node
xml.startElement('vosi:capabilities', nsattrs)
# Add all the capabilities, including those for VOSI endpoint,
# extract them from the database using the provided queryset.
# The following lookup is not efficient, since there is a database
# call for each object, it would be more efficient to get a list of
# all capabilities, interfaces and accessurls and then match them here.
for capability in capabilities:
attrs = {}
if capability.standardID:
attrs['standardID'] = str(capability.standardID)
xml.startElement('capability', attrs)
interfaces = capability.voresource_interface_set.all()
for interface in interfaces:
attrs = {}
if interface.type:
attrs['xsi:type'] = interface.type
xml.startElement('interface', attrs)
accessurls = interface.voresource_accessurl_set.all()
for accessurl in accessurls:
attrs = {}
attrs[
'use'] = accessurl.use # throw error, if its not there?
xml.startElement('accessURL', attrs)
xml.characters(smart_unicode(accessurl.url))
xml.endElement('accessURL')
xml.endElement('interface')
xml.endElement('capability')
xml.endElement('vosi:capabilities')
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
