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 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 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 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, 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): 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 ''