Python saxutils.xml_escape函数代码示例

 def failureResult(err, targetService, pgt, request):
     log_cas_event("Failed to issue proxy ticket", [
         ('client_ip', request.getClientIP()),
         ('targetService', targetService),
         ('PGT', pgt),])
     if not err.check(InvalidTicket, InvalidService):
         log.err(err)
     code = "INTERNAL_ERROR"
     msg = "An internal error occured."
     if err.check(InvalidTicket):
         code = "BAD_PGT"
         msg = "PGT '%s' is invalid." % pgt
     elif err.check(InvalidService):
         code = "INVALID_SERVICE"
         msg = "Target service is not authorized."
     return dedent("""\
         <cas:serviceResponse xmlns:cas="http://www.yale.edu/tp/cas">
             <cas:proxyFailure code="%(code)s">
                 %(msg)s
             </cas:proxyFailure>
         </cas:serviceResponse>
         """) % {
             'code': xml_escape(code),
             'msg': xml_escape(msg),
         }

def export(request):
    start = request.GET.get('start')
    response = HttpResponse(mimetype='application/xml')
    query = Entry.all()
    if start:
        query.filter('word >=', start)
    query.filter('valid =', True)
    query.order('word')
    entries = query.fetch(EXPORT_CHUNK_SIZE)
    response.write('<exported-data>\n')
    for entry in entries:
        if not entry.valid:
            continue
        response.write('<Entry>\n')
        response.write('<word>%s</word>\n' % entry.word)
        response.write('<pos>%s</pos>\n' % entry.pos)
        if entry.props:
            response.write('<props>%s</props>\n' % xml_escape(entry.props))
        if entry.stem:
            response.write('<stem>%s</stem>\n' % entry.stem)
        if entry.etym:
            response.write('<etym>%s</etym>\n' % entry.etym)
        if entry.comment:
            response.write('<comment>%s</comment>\n' % xml_escape(entry.comment))
        response.write('<editors>')
        for ekey in entry.editors:
            editor = db.get(ekey)
            response.write('<name>%s</name>' % editor.username)
        response.write('</editors>\n')
        response.write('<editor>%s</editor>\n' % entry.editor.username)
        response.write('<date>%s</date>\n' % entry.date.strftime('%Y-%m-%d %H:%M:%S'))
        response.write('</Entry>\n')
    response.write('</exported-data>\n')
    return response

    def GET(self, env, start_response):
        """
        Handle GET Service request
        """
        env['QUERY_STRING'] = 'format=json'
        body_iter = self._app_call(env)
        status = self._get_status_int()

        if status != HTTP_OK:
            if status in (HTTP_UNAUTHORIZED, HTTP_FORBIDDEN):
                return get_err_response('AccessDenied')
            else:
                return get_err_response('InvalidURI')

        containers = loads(''.join(list(body_iter)))
        # we don't keep the creation time of a backet (s3cmd doesn't
        # work without that) so we use something bogus.
        if containers:
            owner = containers[0].get('owner', '')
        else:
            owner = ''
        body = '<?xml version="1.0" encoding="UTF-8"?>' \
               '<ListAllMyBucketsResult ' \
               'xmlns="http://doc.s3.amazonaws.com/2006-03-01">'\
               '<Owner><ID>%s</ID><DisplayName>%s</DisplayName></Owner>'\
               '<Buckets>%s</Buckets>' \
               '</ListAllMyBucketsResult>' \
               % (xml_escape(owner), xml_escape(owner),
                  "".join(['<Bucket><Name>%s</Name><CreationDate>'
                           '2009-02-03T16:45:09.000Z</CreationDate></Bucket>'
                           % xml_escape(i['name']) for i in containers]))
        resp = Response(status=HTTP_OK, content_type='application/xml',
                        body=body)
        return resp

    def to_text_html_resources(self, retval, raw):
        """Add the resources details to the HTML output.

        :param retval: The list of strings which is used to collect the HTML
                       response.
        :type retval: list
        :param raw: The original return value of this resources :func:`GET`
                    method.
        :type raw: Dictionary
        """
        for resource in raw:
            retval.append('<div class="resource_details">')
            retval.append('<h2 id="{0}">{0}</h2>'.format(
                xml_escape(resource['name'])))
            if resource['desc']:
                retval.append('<p class="desc">{0}</p>'.format(xml_escape(resource['desc'])))
            retval.append('<table class="config">')
            retval.append('<tr><th>Path</th><td>{0}</td>'.format(xml_escape(
                resource['path'])))
            representations = [value + ' (.' + key + ')' for key, value
                in resource['properties']['EXTENSION_MAP'].iteritems()]
            retval.append('<tr><th>Representations</th><td>{0}</td>'.format(
                xml_escape(', '.join(representations))))
            retval.append('</table>')
            self.to_text_html_methods(retval, resource)
            retval.append('</div>')

    def __init__(self, app, name, hotkey):
        self.app = app
        self.name = name
        self.hotkey = hotkey

        # configuration values
        self.examination_time = self.app.conf["examination_time"]

        # remove window from container
        builder = self.app.create_builder()
        self.window = builder.get_object("player_window")
        container = builder.get_object("player_window_container")
        container.remove(self.window)

        # set player name
        builder.get_object("player_name").set_markup(self.player_markup % xml_escape(name))

        # attach
        self.app.attach(self)
        builder.get_object("stop_button_label").set_markup(self.button_markup % xml_escape(button_name(self.hotkey)))

        # cache object refs
        self.time_label = builder.get_object("time_label")

        self.reset()

        builder.connect_signals(self)
        self.window.show()

	def saveXML(self):
		try:
			fp = file(self.filename, 'w')
			fp.write("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n")
			fp.write("<ci>\n")
			fp.write("\t<slot>\n")
			fp.write("\t\t<id>%s</id>\n" % self.ci_slot)
			for item in self.selectedcaid:
				if len(self.selectedcaid):
					fp.write("\t\t<caid id=\"%s\" />\n" % item[0])
			for item in self.servicelist:
				if len(self.servicelist):
					psname = xml_escape(item[0])
					psattr = xml_escape(item[3])
					if item[2]==1:
						fp.write("\t\t<provider name=\"%s\" dvbnamespace=\"%s\" />\n" % (psname, psattr))
					else:
						fp.write("\t\t<service name=\"%s\" ref=\"%s\" />\n"  % (psname, psattr))
			fp.write("\t</slot>\n")
			fp.write("</ci>\n")
			fp.flush()
			fsync(fp.fileno())
			fp.close()
		except:
			print "[CI_Config_CI%d] xml not written" %self.ci_slot
			os_unlink(self.filename)

    def _notifyServicesSLO(self, services):
        template = self._samlLogoutTemplate

        def logerr(err, service):
            log.msg("Error sending SLO to service '%s'." % service)
            log.err(err)
            errs = unwrap_failures(err)
            for error in errs:
                log.err(error)
            return err

        dlist = []
        for service, st in services.iteritems():
            dt = datetime.datetime.utcnow()
            issue_instant = dt.strftime("%Y-%m-%dT%H:%M:%S")
            identifier = str(uuid.uuid4())
            data = template % {
                'identifier': xml_escape(identifier),
                'issue_instant': xml_escape(issue_instant),
                'service_ticket': xml_escape(st)
            }
            httpClient = self.httpClientFactory(self.reactor)
            d = httpClient.post(
                    service.encode('utf-8'), 
                    headers=Headers({'Content-Type': ['application/xml']}),
                    data=data.encode('utf-8'), 
                    timeout=30).addCallback(
                treq.content).addErrback(
                logerr, service)
            dlist.append(d)
        return defer.DeferredList(dlist, consumeErrors=True)

        def upload_results(self, results, path, message=None):
            """ Upload query results CSV to Amazon S3

                :param tuple results: query results for upload
                :param str path: bucket path
                :param str message: text to display before download link
                :return: link text on successful upload, failure message if
                         s3 upload failed

            """
            timer = statsd.timer('bux_sql_grader.upload_results').start()
            if not message:
                message = "Download full results"

            # Convert result rows to CSV
            csv_results = self.csv_results(results)

            # Upload to S3
            s3_url = self.upload_to_s3(csv_results, path)
            if s3_url:
                context = {"url": xml_escape(s3_url), "message": xml_escape(message),
                           "icon_src": xml_escape(self.download_icon)}
                download_link = DOWNLOAD_LINK.substitute(context)
            else:
                download_link = UPLOAD_FAILED_MESSAGE

            timer.stop()
            return download_link

 def renderFailure(err, ticket, request):
     log_cas_event("Failed to validate ticket.", [
         ('client_ip', request.getClientIP()),
         ('ticket', ticket)])
     err.trap(InvalidTicket, InvalidProxyCallback, InvalidService)
     request.setResponseCode(403)
     code = "INVALID_TICKET"
     msg = "Validation failed for ticket '%s'." % ticket
     if err.check(InvalidTicketSpec):
         code = "INVALID_TICKET_SPEC"
     elif err.check(InvalidProxyCallback):
         code = "INVALID_PROXY_CALLBACK"
         msg = "Invalid proxy callback."
     elif err.check(InvalidService):
         code = "INVALID_SERVICE"
         msg = "Invalid service."
     doc_fail = dedent("""\
         <cas:serviceResponse xmlns:cas="http://www.yale.edu/tp/cas">
            <cas:authenticationFailure code="%(code)s">
               %(msg)s.    
            </cas:authenticationFailure>
         </cas:serviceResponse>
         """) % {
             'code': xml_escape(code),
             'msg': xml_escape(msg),}
     return doc_fail

 def create_xml(self):
     template = u'<attendees><person>%(first)s%(last)s%(email)s</person>%(session_key)s<joinStatus>ACCEPT</joinStatus><emailInvitations>TRUE</emailInvitations></attendees>'
     template_bits = {
             'first': self.first_name and '<firstName>%s</firstName>'%xml_escape(self.first_name) or '',
             'last': self.last_name and '<lastName>%s</lastName>'%xml_escape(self.last_name) or '',
             'email': '<email>%s</email>'%xml_escape(self.email),
             'session_key': '<sessionKey>%s</sessionKey>'%self.event.session_key }
     return template % template_bits

def create_xml(cfg):
    """ convert config dict to xml """
    xml= "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>\n"
    xml += "<map>\n"
    for k,v in cfg.items():
        xml += "    <string name=\"%s\">%s</string>\n" % (xml_escape(k), xml_escape(v))
    xml += "</map>\n"

    return xml

        def build_response(self, correct, score, hints, student_results,
                           student_warnings=[], grader_results=None,
                           grader_warnings=[], row_limit=None,
                           download_link=""):
            """ Builds a grader response dict. """

            response = {"correct": correct, "score": score}

            # Response message template context
            context = {"download_link": download_link, "hints": ""}

            # Generate student response results table
            context["student_results"] = self.html_results(student_results,
                                                           row_limit)

            # Generate warning messages if queries had to be modified
            notices = ""
            if student_warnings:
                student_warnings = [xml_escape(notice) for notice in student_warnings]
                student_warning = "<strong>Warning</strong><p>"
                student_warning += "</p><p>".join(student_warnings) + "</p>"
                notices += WARNING_TMPL.substitute(msg=student_warning)

            if grader_warnings:
                grader_warnings = [xml_escape(notice) for notice in grader_warnings]
                grader_warning = "<strong>Warning</strong><p>"
                grader_warning += "</p><p>".join(grader_warnings) + "</p>"
                notices += WARNING_TMPL.substitute(msg=grader_warning)

            context["notices"] = notices

            if grader_results and not correct:

                # Generate grader response results table
                context["grader_results"] = self.html_results(grader_results,
                                                              row_limit)

                # Generate hints markup if hints were provided
                if hints:
                    # Ensure hint text is XML-safe
                    hints = [xml_escape(hint) for hint in hints]

                    hints_html = "<strong>Hints</strong>"
                    hints_html += "<ul><li>"
                    hints_html += "</li><li>".join(hints)
                    hints_html += "</li></ul>"

                    context["hints"] = hints_html

                # Incorrect response template
                response["msg"] = INCORRECT_QUERY.substitute(context)
            else:
                # Correct response template
                response["msg"] = CORRECT_QUERY.substitute(context)

            return response

 def __init__(self, code, message=None):
     assert isinstance(code, int) # Being a bit paranoid about the API
     self.code = code
     self.reason, self.message = http_responses[code]
     if message is not None:
         self.message = message
     self.text = ERROR_DOCUMENT_TEMPLATE % dict(code=self.code,
                                                reason=xml_escape(self.reason),
                                                message=xml_escape(self.message))
     self.headers = [("Content-Type", "text/html")]

def innerXML(node):
    if len(node) > 0:
        text = xml_escape(node.text or '')
        for child in node:
            text += outterXML(child)
            if child.tail:
                text += xml_escape(child.tail)
        return text or ''
    else:
        return xml_escape(node.text or '')

    def _delete_multi(self, keys, force=False):

        body = [ '<Delete>' ]
        esc_prefix = xml_escape(self.prefix)
        for key in keys:
            body.append('<Object><Key>%s%s</Key></Object>' % (esc_prefix, xml_escape(key)))
        body.append('</Delete>')
        body = '\n'.join(body).encode('utf-8')
        headers = { 'content-type': 'text/xml; charset=utf-8' }
        
        resp = self._do_request('POST', '/', subres='delete', body=body, headers=headers)
        try:
            root = self._parse_xml_response(resp)
            ns_p = self.xml_ns_prefix
            
            error_tags = root.findall(ns_p + 'Error')
            if not error_tags:
                # No errors occured, everything has been deleted
                del keys[:]
                return

            # Some errors occured, so we need to determine what has
            # been deleted and what hasn't
            offset = len(self.prefix)
            for tag in root.findall(ns_p + 'Deleted'):
                fullkey = tag.find(ns_p + 'Key').text
                assert fullkey.startswith(self.prefix)
                keys.remove(fullkey[offset:])

            if log.isEnabledFor(logging.DEBUG):
                for errtag in error_tags:
                    log.debug('Delete %s failed with %s', 
                              errtag.findtext(ns_p + 'Key')[offset:],
                              errtag.findtext(ns_p + 'Code'))
                
            # If *force*, just modify the passed list and return without
            # raising an exception, otherwise raise exception for the first error
            if force:
                return

            errcode = error_tags[0].findtext(ns_p + 'Code')
            errmsg = error_tags[0].findtext(ns_p + 'Message')
            errkey = error_tags[0].findtext(ns_p + 'Key')[offset:]

            if errcode == 'NoSuchKeyError':
                raise NoSuchObject(errkey)
            else:
                raise get_S3Error(errcode, 'Error deleting %s: %s' % (errkey, errmsg))

        finally:
            # Need to read rest of response
            while True:
                buf = resp.read(BUFSIZE)
                if buf == b'':
                    break