Python Request.query_string方法代码示例

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import query_string [as 别名]
 def __call__(self, environ, start_response):
     pretty = False
     indent = 0
     req = Request(environ)
     if self.parm in req.GET:
         pretty = True
         try:
             indent = int(req.GET.get(self.parm, 0))
         except:
             pass
         # Rewrite the query_string removing parm.
         parms = []
         for parm in req.query_string.split('&'):
             name = parm.split('=')[0]
             if name != self.parm:
                 parms.append(parm)
         req.query_string = '&'.join(parms)
     resp = req.get_response(self.app)
     if pretty:
         resp.content_type = 'text/plain'
         if indent > 0:
             resp.body = json.dumps(json.loads(resp.body),
                                    indent=indent,
                                    sort_keys=True)
     return resp(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import query_string [as 别名]
    def __call__(self, environ, start_response):
        req = Request(environ)
        path, response = req.path.rsplit('.', 1)
        if response == 'das':
            req.query_string = ''
        projection, selection = parse_ce(req.query_string)
        buffer_size = environ.get('pydap.buffer_size', BUFFER_SIZE)

        try:
            # build the dataset and pass it to the proper response, returning a
            # WSGI app
            dataset = self.parse(projection, selection, buffer_size)
            app = self.responses[response](dataset)
            app.close = self.close

            # now build a Response and set additional headers
            res = req.get_response(app)
            for key, value in self.additional_headers:
                res.headers.add(key, value)

            # CORS for Javascript requests
            if response in CORS_RESPONSES:
                res.headers.add('Access-Control-Allow-Origin', '*')
                res.headers.add(
                    'Access-Control-Allow-Headers',
                    'Origin, X-Requested-With, Content-Type')

            return res(environ, start_response)
        except:
            # should the exception be catched?
            if environ.get('x-wsgiorg.throw_errors'):
                raise
            else:
                res = ErrorResponse(info=sys.exc_info())
                return res(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import query_string [as 别名]
    def __call__(self, environ, start_response):
        req = Request(environ)
        path, response = req.path.rsplit('.', 1)
        if response == 'das':
            req.query_string = ''
        projection, selection = parse_ce(req.query_string)

        try:
            # build the dataset and pass it to the proper response, returning a 
            # WSGI app
            dataset = self.parse(projection, selection)
            app = self.responses[response](dataset)
            app.close = self.close

            # now build a Response and set additional headers
            res = req.get_response(app)
            for key, value in self.additional_headers:
                res.headers.add(key, value)

            return res(environ, start_response)
        except HTTPException, exc:
            # HTTP exceptions are used to redirect the user
            return exc(environ, start_response)

# 需要导入模块: from webob import Request [as 别名]
# 或者: from webob.Request import query_string [as 别名]
    def __call__(self, environ, start_response):
        # specify that we want the parsed dataset
        environ['x-wsgiorg.want_parsed_response'] = True
        req = Request(environ)
        original_query = req.query_string
        projection, selection = parse_ce(req.query_string)

        # apply selection without any function calls
        req.query_string = '&'.join(expr for expr in selection if not FUNCTION.match(expr))
        res = req.get_response(self.app)

        # ignore DAS requests
        path, response = req.path.rsplit('.', 1)
        if response == 'das':
            return self.app(environ, start_response)

        # get the dataset
        method = getattr(res.app_iter, 'x_wsgiorg_parsed_response', False)
        if not method:
            environ['QUERY_STRING'] = original_query
            return self.app(environ, start_response)
        dataset = method(DatasetType)

        # apply selection containing server-side functions
        selection = (expr for expr in selection if FUNCTION.match(expr))
        for expr in selection:
            if RELOP.search(expr):
                call, op, other = RELOP.split(expr)
                op = {
                        '<' : operator.lt,
                        '>' : operator.gt,
                        '!=': operator.ne,
                        '=' : operator.eq,
                        '>=': operator.ge,
                        '<=': operator.le,
                        '=~': lambda a, b: re.match(b, a),
                }[op]
                other = ast.literal_eval(other)
            else:
                call, op, other = expr, operator.eq, 1

            # evaluate the function call
            sequence = eval_function(dataset, call, self.functions)

            # is this an inplace call?
            for var in walk(dataset, SequenceType):
                if sequence is var:
                    break
            else:
                # get the data from the resulting variable, and use it to 
                # constrain the original dataset
                data = np.fromiter(sequence)
                print data.shape
                valid = op(data, other)

                for sequence in walk(dataset, SequenceType):
                    data = np.asarray(list(sequence), 'O')[valid]
                    sequence.data = np.asarray(list(sequence), 'O')[valid]
                dataset = out

        # now apply projection
        if projection:
            projection = fix_shorthand(projection, dataset)
            base = [p for p in projection if not isinstance(p, basestring)] 
            func = [p for p in projection if isinstance(p, basestring)] 

            # apply non-function projection
            out = apply_projection(base, dataset)

            # apply function projection
            for call in func:
                var = eval_function(dataset, call, self.functions)
                for child in walk(var):
                    parent = reduce(operator.getitem, [out] + child.id.split('.')[:-1])
                    if child.name not in parent.keys():
                        parent[child.name] = child
                        break
            dataset = out

        # Return the original response (DDS, DAS, etc.)
        path, response = req.path.rsplit('.', 1)
        res = BaseHandler.responses[response](dataset)

        return res(environ, start_response)