def characters(self, content):
# TODO: figure out how to do this explicitly rather than implicitly
if any(c in content for c in CDATA_CHARS):
self._write('<![CDATA[' + content + ']]>')
else:
# can't use super, XMLGenerator is an old style class
SimplerXMLGenerator.characters(self, content)
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("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 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 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 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("django-objects", {"version": "1.0"})
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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 _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 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 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, 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, 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 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 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("django-objects", {"version": "1.0"})
def __unicode__(self):
"""Write out XML into a string buffer."""
sb = StringIO()
sb.write(u'<?xml version="1.0" encoding="utf-8"?>')
handler = SimplerXMLGenerator(out=sb)
self.write_items(handler)
return sb.getvalue()
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 _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 start_serialization(self, default_charset='utf-8'):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", default_charset))
self.xml.startDocument()
self.xml.startElement("django-objects", {"version" : "1.0"})
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, encoding=self.charset)
xml.startDocument()
self._to_xml(xml, data)
xml.endDocument()
return stream.getvalue()
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, 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, 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 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 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 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")
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 without the root tag
"""
if data is None:
return ''
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
#xml.startElement("root", {})
self._to_xml(xml, data)
#xml.endElement("root")
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("root", {})
self._to_xml(xml, data)
xml.endElement("root")
xml.endDocument()
return stream.getvalue()
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, 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 get(self, request, *args, **kwargs):
stream = StringIO()
xml = SimplerXMLGenerator(stream, self.charset)
xml.startDocument()
xml.startElement(self.root_name, self.get_root_attributes())
self.insert_children(xml)
xml.endElement(self.root_name)
xml.endDocument()
response = HttpResponse(stream.getvalue())
response["Content-Type"] = "text/xml; charset={}".format(self.charset)
return response
def create_entry_feed(title, link, description, author_name,
author_link, pubdate, parent_id):
feed = SalmonAtom1EntryFeed(title='', link='', description='')
feed.add_item(
title, link, description,
author_name=author_name, author_link=author_link, pubdate=pubdate,
parent_id=parent_id,
)
sb = StringIO()
sb.write(u'<?xml version="1.0" encoding="utf-8"?>')
handler = SimplerXMLGenerator(out=sb)
feed.write_items(handler)
return sb.getvalue()
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 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 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 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()
class Serializer(XMLSerializer):
"""
A test serializer which removes ``django-objects`` xml tag from default
Django's xml serializer, adapt it to your own usage.
"""
def start_serialization(self):
"""
Start serialization -- open the XML document and the root element.
"""
self.xml = SimplerXMLGenerator(
self.stream, self.options.get("encoding", DEFAULT_CHARSET))
self.xml.startDocument()
self.xml.startElement("django-test", {"version": "1.0"})
def end_serialization(self):
"""
End serialization -- end the document.
"""
self.indent(0)
self.xml.endElement("django-test")
self.xml.endDocument()
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):
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()
