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 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, 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 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()
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, "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()