Python Response.data方法代码示例

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
    def wsgi_app(self, environ, start_response):
        """Execute this instance as a WSGI application.

        See the PEP for the meaning of parameters. The separation of
        __call__ and wsgi_app eases the insertion of middlewares.

        """
        urls = self._url_map.bind_to_environ(environ)
        try:
            endpoint, args = urls.match()
        except HTTPException as exc:
            return exc

        assert endpoint == "rpc"

        response = Response()

        if self._auth is not None and not self._auth(environ):
            response.status_code = 403
            response.mimetype = "plain/text"
            response.data = "Request not allowed."
            return response

        request = Request(environ)
        request.encoding_errors = "strict"

        remote_service = ServiceCoord(args['service'], args['shard'])

        if remote_service not in self._service.remote_services:
            return NotFound()

        # TODO Check content_encoding and content_md5.

        if request.mimetype != "application/json":
            return UnsupportedMediaType()

        if request.accept_mimetypes.quality("application/json") <= 0:
            return NotAcceptable()

        try:
            data = json.load(request.stream, encoding='utf-8')
        except ValueError:
            return BadRequest()

        if not self._service.remote_services[remote_service].connected:
            return ServiceUnavailable()

        result = self._service.remote_services[remote_service].execute_rpc(
            args['method'], data)

        # XXX We could set a timeout on the .wait().
        result.wait()

        response.status_code = 200
        response.mimetype = "application/json"
        response.data = json.dumps({
            "data": result.value,
            "error": None if result.successful() else "%s" % result.exception})

        return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
 def flag_status(self, request, flag):
     response = Response(content_type='application/json')
     response.headers.add_header(
         'Cache-Control', 'no-cache, no-store, must-revalidate')
     try:
         active = self._backend.is_active(flag)
         response.data = json.dumps({
             'active': bool(active), 'known': True})
         response.status_code = 200
         return response
     except UnknownFeatureError:
         response.data = json.dumps({
             'active': False, 'known': False})
         response.status_code = 404
         return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
    def __call__(self, environ, start_response):
        request = Request(environ)
        response = Response('')
        self._get_session(request)
        request_method = environ['REQUEST_METHOD']
        form = parse_form_data(environ)[1]
        path = environ.get('PATH_INFO','')
        request_url = request.url
        params = request.args
        resp = self._process_request(request_method, request_url, path, params, form)
        logging.debug(str(resp))
        if resp:
            if 'set_values' in resp:
                self._set_values(environ)
                return self._application(environ, start_response)
            if 'ignore_callback' in resp and resp['ignore_callback'] == True:
                  return self._ignored_callback(environ, start_response)

            if 'status' in resp:
                response.status = resp['status']
            for name in ['Location', 'Content-Type', 'WWW-Authenticate']:
                if name in resp['headers']:
                    response.headers[name] = resp['headers'][name]
            if 'data' in resp:
                response.data = resp['data']
            response.set_cookie(self.CAS_COOKIE_NAME, value = self._session.sid, max_age = None, expires = None)
            return response(environ, start_response)
        else:
            return self._application(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
    def wsgi_app(self, environ, start_response):
        """Execute this instance as a WSGI application.

        See the PEP for the meaning of parameters. The separation of
        __call__ and wsgi_app eases the insertion of middlewares.

        """
        urls = self._url_map.bind_to_environ(environ)
        try:
            endpoint, args = urls.match()
        except HTTPException as exc:
            return exc

        assert endpoint == "get"

        request = Request(environ)
        request.encoding_errors = "strict"

        response = Response()

        result = dict()
        for task_type in self._task_types:
            result[task_type.__name__] = \
                list(p.describe() for p in task_type.ACCEPTED_PARAMETERS)

        response.status_code = 200
        response.mimetype = "application/json"
        response.data = json.dumps(result)

        return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
    def wsgi_app(self, environ, start_response):
        """
        Main WSGI Interface
        """
        request = Request(environ)
        for route in self._routes:
            log.debug("Attempting route: %s", route)
            method = route.match(request.path, request.method)
            if method is None:
                continue

            ### EEW. Not sure I like this.
            extra_params = self._extract_params_from_request(method, request)

            value_map = method(**extra_params)
            if value_map is not None:
                # for now, we're doing dict only
                response = Response(mimetype="application/json")

                # EEW. It doesn't get any better on the response.
                self.apply_consumer_mutations(value_map, response)
                json_dump = json.dumps(value_map)
                response.data = json_dump
                return response(environ, start_response)
        raise NotFound()

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
    def wsgi_app(self, environ, start_response):
        route = self.router.bind_to_environ(environ)
        try:
            endpoint, args = route.match()
        except HTTPException as exc:
            return exc(environ, start_response)

        assert endpoint == "sublist"

        request = Request(environ)
        request.encoding_errors = "strict"

        if request.accept_mimetypes.quality("application/json") <= 0:
            raise NotAcceptable()

        result = list()
        for task_id in self.task_store._store.keys():
            result.extend(
                self.scoring_store.get_submissions(
                    args["user_id"], task_id
                ).values()
            )
        result.sort(key=lambda x: (x.task, x.time))
        result = list(a.__dict__ for a in result)

        response = Response()
        response.status_code = 200
        response.mimetype = "application/json"
        response.data = json.dumps(result)

        return response(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
def as_binary():
    response = Response()
    response.mimetype = 'application/octet-stream'
    response.headers[b"Content-Disposition"] = (
        "filename=\"%s\"" % frappe.response['filename'].replace(' ', '_')).encode("utf-8")
    response.data = frappe.response['filecontent']
    return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
def as_txt():
	response = Response()
	response.mimetype = 'text'
	response.charset = 'utf-8'
	response.headers["Content-Disposition"] = ("attachment; filename=\"%s.txt\"" % frappe.response['doctype'].replace(' ', '_')).encode("utf-8")
	response.data = frappe.response['result']
	return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
def as_raw():
    response = Response()
    response.mimetype = frappe.response.get("content_type") or mimetypes.guess_type(
        frappe.response['filename'])[0] or b"application/unknown"
    response.headers[b"Content-Disposition"] = (
        "filename=\"%s\"" % frappe.response['filename'].replace(' ', '_')).encode("utf-8")
    response.data = frappe.response['filecontent']
    return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
def build_response(path, data, http_status_code):
	# build response
	response = Response()
	response.data = set_content_type(response, data, path)
	response.status_code = http_status_code
	response.headers[b"X-Page-Name"] = path.encode("utf-8")
	response.headers[b"X-From-Cache"] = frappe.local.response.from_cache or False
	return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
 def validation(errors, code=400):
   response = Response()
   response.status_code = code
   grouped = {field: tuple(e[1] for e in errors)
              for field, errors in groupby(sorted(errors), lambda e: e[0])}
   body = dict(description="Validation Error", details=dict(fields=grouped))
   response.data = json.dumps(body)
   return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
def as_csv():
    response = Response()
    response.headers[b"Content-Type"] = b"text/csv; charset: utf-8"
    response.headers[b"Content-Disposition"] = (
        'attachment; filename="%s.csv"' % frappe.response["doctype"].replace(" ", "_")
    ).encode("utf-8")
    response.data = frappe.response["result"]
    return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
    def wsgi_app(self, environ, start_response):
        """Execute this instance as a WSGI application.

        See the PEP for the meaning of parameters. The separation of
        __call__ and wsgi_app eases the insertion of middlewares.

        """
        urls = self._url_map.bind_to_environ(environ)
        try:
            endpoint, args = urls.match()
        except HTTPException as exc:
            return exc

        assert endpoint == "rpc"

        request = Request(environ)
        request.encoding_errors = "strict"

        response = Response()

        remote_service = ServiceCoord(args['service'], args['shard'])

        if remote_service not in self._service.remote_services:
            return NotFound()

        # TODO Check content_encoding and content_md5.

        if request.mimetype != "application/json":
            return UnsupportedMediaType()

        if request.accept_mimetypes.quality("application/json") <= 0:
            return NotAcceptable()

        try:
            data = json.load(request.stream, encoding='utf-8')
        except ValueError:
            return BadRequest()

        if not self._service.remote_services[remote_service].connected:
            return ServiceUnavailable()

        value = AsyncResult()

        @rpc_callback
        def callback(service, data, plus=None, error=None):
            value.set({'data': data, 'error': error})

        self._service.remote_services[remote_service].execute_rpc(
            args['method'], data, callback)

        response.status_code = 200
        response.mimetype = "application/json"
        # XXX We could set a timeout on the .get().
        response.data = json.dumps(value.get())

        return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
def as_xml():
	make_logs()
	response = Response()
	if frappe.local.response.status_code:
		response.status_code = frappe.local.response['status_code']
		del frappe.local.response['status_code']

	response.headers[b"Content-Type"] = b"application/xml; charset: utf-8"
	response.data = json_to_xml(frappe.local.response, as_str=True)
	return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import data [as 别名]
def as_json():
	make_logs()
	response = Response()
	if frappe.local.response.http_status_code:
		response.status_code = frappe.local.response['http_status_code']
		del frappe.local.response['http_status_code']

	response.headers[b"Content-Type"] = b"application/json; charset: utf-8"
	response.data = json.dumps(frappe.local.response, default=json_handler, separators=(',',':'))
	return response