Python quixote.get_request函数代码示例

 def delete(self):
     current_user = quixote.get_request().get_cookie('user')
     if (current_user is not None):
         request = quixote.get_request()
         key = request.form['key']
         if (current_user == image.get_owner(key)[0]):
             image.delete_image(key)
     return quixote.redirect('./')

    def _q_index(self):
        url_path = quixote.get_request().get_path()

        url_qs = quixote.get_request().get_query()

        txt = 'Quixote: |{}{}|'.format(url_path, '?'+url_qs if url_qs else '')

        return txt

    def search_results(self):
        request = quixote.get_request()
        query = request.form['query']
        data = {'image_keys':image.search_metadata(query)}
        current_user = quixote.get_request().get_cookie('user')
        if (current_user is not None):
            data['user'] = current_user

        return html.render('search_results.html', values = data)

    def image_with_key(self):
        request = quixote.get_request()
        key = request.form['key']
        data = image.get_image(key).metadata
        data['key'] = key
        data['image_comments'] = image.get_comments(key)
        current_user = quixote.get_request().get_cookie('user')
        if (current_user is not None):
            data['user'] = current_user
            if (current_user == image.get_owner(key)[0]):
                data['can_delete'] = True

        return html.render('image_with_key.html', values = data)

 def _render_finish(self):
     r = TemplateIO(html=True)
     r += htmltext('</form><br class="quixoteform" />')
     code = get_request().response.javascript_code
     if code:
         r += self._render_javascript(code)
     return r.getvalue()

 def _get_default_action_url(self):
     request = get_request()
     action_url = url_quote(request.get_path())
     query = request.get_environ("QUERY_STRING")
     if query:
         action_url += "?" + query
     return action_url

 def result(self):
 	response = quixote.get_request()
 	
 	info = response.form['query']
 	
 	results = image.search(info)
 	return html.render('result.html', results)

 def upload_file(self):
     request = get_request()
     if request.form:
         contents = request.form['upload'].fp.read()
         return contents
     else:
         return "<form enctype=multipart/form-data method=POST> <input type=file name=upload> <input type=submit value=submit> </form>"

    def multisubmitform(self):
        request = get_request()
        
        submit1 = widget.SubmitWidget('sub_a', value='sub_a')
        submit2 = widget.SubmitWidget('sub_b', value='sub_b')

        s = ""
        if request.form:
            used = False
            if submit1.parse(request):
                used = True
                s += "used_sub_a"
            if submit2.parse(request):
                used = True
                s += "used_sub_b"

            if not used:
                assert 0

            # print out the referer, too.
            referer = request.environ.get('HTTP_REFERER')
            if referer:
                s += "<p>referer: %s" % (referer,)

        return "<form method=POST>%s %s %s</form>" % (s,
                                                      submit1.render(),
                                                      submit2.render())

    def do_blast(self):
        request = quixote.get_request()
        form = request.form

        seq = form['seq']
        seq_type = sequtil.guess_seqtype(seq)
        db_type = self.db._seqtype
        prog = blast.blast_program(seq_type, db_type)
        
        do_translate = form.get('do_translate', 0)
        if do_translate:
            do_translate = int(do_translate)
        
        if prog == 'blastn' and do_translate:
            prog = 'tblastx'

        cmd = ['blastall', '-p', prog, '-d', self.db.filepath, '-e', '1']
        p = subprocess.Popen(cmd, stdin=subprocess.PIPE,
                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        (stdout, stderr) = p.communicate(">query\n" + seq)

        try:
            record = blastparser.parse_string(stdout).next()
        except StopIteration:
            template = env.get_template('BlastView/no-results.html')
            return template.render(locals())
            
        genome_name = self.genome_name
        filepath = self.db.filepath
        
        template = env.get_template('BlastView/results.html')
        return template.render(locals())

    def _set_cookie(self, value, **attrs):
        """(session_id : string)

        Ensure that a session cookie with value 'session_id' will be
        returned to the client via the response object.

        Since Mod_Python has its own Cookie management system, we use it.
        """
        config = get_publisher().config
        name = config.session_cookie_name
        domain = config.session_cookie_domain

        if config.session_cookie_path:
            path = config.session_cookie_path
        else:
            path = get_request().get_environ('SCRIPT_NAME')
            if not path.endswith("/"):
                path += "/"

        expires = -1

        options = {'expires': expires,
                   'path': path }

        if domain is not None:
            options.update({'domain':domain})

        if value:
            Cookie.add_cookie(self.modpython_request, name, value, **options)

        return name

 def parse(self, request=None):
     if not self._parsed:
         if request is None:
             request = get_request()
         self._parse(request)
         self._parsed = True
     return self.value

    def _q_traverse(self, path):
        # Initialize the publisher's namespace_stack
        del self.namespace_stack[:]

        request = get_request()

        # Traverse package to a (hopefully-) callable object
        object = _traverse_url(self.root_namespace, path, request, self.namespace_stack)

        # None means no output -- traverse_url() just issued a redirect.
        if object is None:
            return None

        # Anything else must be either a string...
        if isstring(object):
            output = object

        # ...or a callable.
        elif hasattr(object, "__call__"):
            output = object(request)
            if output is None:
                raise RuntimeError, "callable %s returned None" % repr(object)

        # Uh-oh: 'object' is neither a string nor a callable.
        else:
            raise RuntimeError("object is neither callable nor a string: %s" % repr(object))

        return output

 def image_raw(self):
     response = quixote.get_response()
     request = quixote.get_request()
     i = request.form['i']
     img = image.get_image(int(i))
     response.set_content_type('image/%s' % img[1])
     return img[0]

 def image(self):
     request = quixote.get_request()
     i = request.form['i']
     img = image.get_image(int(i))
     metadata = img[2]
     metadata['index'] = int(i)
     return html.render('image.html', values = metadata)