Python Response.set_data方法代码示例

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_data [as 别名]
def application(request):
    root_dir = os.getcwd()
    path = request.path  # todo: make sure path is sandboxed!
    if path in ('', '/'):
        path = '/index.html'
    # todo: if path is a directory, append index.html to template name
    env = Environment(loader=FileSystemLoader(root_dir))

    response = Response()
    response.status_code = 200
    response.content_type = 'text/html; charset=utf-8'

    ## Try to get the template
    try:
        template = env.get_template(path)
    except TemplateNotFound:
        response.status_code = 404
        try:
            template = env.get_template('404.html')
        except TemplateNotFound:
            response.content_type = 'text/plain'
            template = Template("PAGE NOT FOUND")

    ## Prepare and send the response
    rendered = template.render(request=request, response=response)
    response.set_data(rendered)
    return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_data [as 别名]
 def serve_himself(self, environ, start_response, file_name):
     response = Response()
     response.headers["Content-Type"] = "text/html"
     if file_name == "admin.html":
         file_name = os.path.join(self.jam_dir, file_name)
     with open(file_name, "r") as f:
         response.set_data(f.read())
     return response(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_data [as 别名]
 def create_post_response(self, request, result):
     response = Response()
     accepts_gzip = 0
     try:
         if request.environ.get("HTTP_ACCEPT_ENCODING").find("gzip") != -1:
             accepts_gzip = 1
     except:
         pass
     buff = json.dumps(result, default=common.json_defaul_handler)
     response.headers['Content-Type'] = 'application/json'
     if accepts_gzip:
         buff = common.compressBuf(buff)
         response.headers['Content-encoding'] = 'gzip'
         response.headers['Content-Length'] = str(len(buff))
     response.set_data(buff)
     return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_data [as 别名]
async def jsonify(ctx, response: Response):
    """
    JSONify the response.
    """
    if not isinstance(response.response, dict):
        return response

    # json.dump the body.
    status_code = response.status_code
    if not any(response.response.values()):
        status_code = 404
    if ctx.request.args.get("format", "json") == "json_pretty":
        d = json.dumps(response.response, sort_keys=True, indent=4, separators=(',', ': '))
    else:
        d = json.dumps(response.response)
    response.set_data(d)
    response.headers["Content-Type"] = "application/json"
    response.status_code = status_code
    return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_data [as 别名]
    def test_wrapper_internals(self):
        req = Request.from_values(data={'foo': 'bar'}, method='POST')
        req._load_form_data()
        assert req.form.to_dict() == {'foo': 'bar'}

        # second call does not break
        req._load_form_data()
        assert req.form.to_dict() == {'foo': 'bar'}

        # check reprs
        assert repr(req) == "<Request 'http://localhost/' [POST]>"
        resp = Response()
        assert repr(resp) == '<Response 0 bytes [200 OK]>'
        resp.set_data('Hello World!')
        assert repr(resp) == '<Response 12 bytes [200 OK]>'
        resp.response = iter(['Test'])
        assert repr(resp) == '<Response streamed [200 OK]>'

        # unicode data does not set content length
        response = Response([u'Hällo Wörld'])
        headers = response.get_wsgi_headers(create_environ())
        assert u'Content-Length' not in headers

        response = Response([u'Hällo Wörld'.encode('utf-8')])
        headers = response.get_wsgi_headers(create_environ())
        assert u'Content-Length' in headers

        # check for internal warnings
        filterwarnings('error', category=Warning)
        response = Response()
        environ = create_environ()
        response.response = 'What the...?'
        self.assert_raises(Warning, lambda: list(response.iter_encoded()))
        self.assert_raises(Warning, lambda: list(response.get_app_iter(environ)))
        response.direct_passthrough = True
        self.assert_raises(Warning, lambda: list(response.iter_encoded()))
        self.assert_raises(Warning, lambda: list(response.get_app_iter(environ)))
        resetwarnings()

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_data [as 别名]
def test_wrapper_internals():
    req = Request.from_values(data={"foo": "bar"}, method="POST")
    req._load_form_data()
    assert req.form.to_dict() == {"foo": "bar"}

    # second call does not break
    req._load_form_data()
    assert req.form.to_dict() == {"foo": "bar"}

    # check reprs
    assert repr(req) == "<Request 'http://localhost/' [POST]>"
    resp = Response()
    assert repr(resp) == "<Response 0 bytes [200 OK]>"
    resp.set_data("Hello World!")
    assert repr(resp) == "<Response 12 bytes [200 OK]>"
    resp.response = iter(["Test"])
    assert repr(resp) == "<Response streamed [200 OK]>"

    # unicode data does not set content length
    response = Response([u"Hällo Wörld"])
    headers = response.get_wsgi_headers(create_environ())
    assert u"Content-Length" not in headers

    response = Response([u"Hällo Wörld".encode("utf-8")])
    headers = response.get_wsgi_headers(create_environ())
    assert u"Content-Length" in headers

    # check for internal warnings
    filterwarnings("error", category=Warning)
    response = Response()
    environ = create_environ()
    response.response = "What the...?"
    pytest.raises(Warning, lambda: list(response.iter_encoded()))
    pytest.raises(Warning, lambda: list(response.get_app_iter(environ)))
    response.direct_passthrough = True
    pytest.raises(Warning, lambda: list(response.iter_encoded()))
    pytest.raises(Warning, lambda: list(response.get_app_iter(environ)))
    resetwarnings()

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_data [as 别名]
    def _try_serve_page(self, app, environ, request):
        # Try to find what matches the requested URL.
        req_path, page_num = split_sub_uri(app, request.path)

        routes = find_routes(app.routes, req_path)
        if len(routes) == 0:
            raise RouteNotFoundError("Can't find route for: %s" % req_path)

        rendered_page = None
        first_not_found = None
        for route, route_metadata in routes:
            try:
                logger.debug("Trying to render match from source '%s'." %
                             route.source_name)
                rendered_page = self._try_render_page(
                        app, route, route_metadata, page_num, req_path)
                if rendered_page is not None:
                    break
            except NotFound as nfe:
                if first_not_found is None:
                    first_not_found = nfe
        else:
            raise SourceNotFoundError(
                    "Can't find path for: %s (looked in: %s)" %
                    (req_path, [r.source_name for r, _ in routes]))

        # If we haven't found any good match, raise whatever exception we
        # first got. Otherwise, raise a generic exception.
        if rendered_page is None:
            first_not_found = first_not_found or NotFound(
                    "This page couldn't be found.")
            raise first_not_found

        # Start doing stuff.
        page = rendered_page.page
        rp_content = rendered_page.content

        # Profiling.
        if app.config.get('site/show_debug_info'):
            now_time = time.clock()
            timing_info = (
                    '%8.1f ms' %
                    ((now_time - app.env.start_time) * 1000.0))
            rp_content = rp_content.replace(
                    '__PIECRUST_TIMING_INFORMATION__', timing_info)

        # Build the response.
        response = Response()

        etag = hashlib.md5(rp_content.encode('utf8')).hexdigest()
        if not app.debug and etag in request.if_none_match:
            response.status_code = 304
            return response

        response.set_etag(etag)
        response.content_md5 = etag

        cache_control = response.cache_control
        if app.debug:
            cache_control.no_cache = True
            cache_control.must_revalidate = True
        else:
            cache_time = (page.config.get('cache_time') or
                          app.config.get('site/cache_time'))
            if cache_time:
                cache_control.public = True
                cache_control.max_age = cache_time

        content_type = page.config.get('content_type')
        if content_type and '/' not in content_type:
            mimetype = content_type_map.get(content_type, content_type)
        else:
            mimetype = content_type
        if mimetype:
            response.mimetype = mimetype

        if ('gzip' in request.accept_encodings and
                app.config.get('site/enable_gzip')):
            try:
                with io.BytesIO() as gzip_buffer:
                    with gzip.open(gzip_buffer, mode='wt',
                                   encoding='utf8') as gzip_file:
                        gzip_file.write(rp_content)
                    rp_content = gzip_buffer.getvalue()
                    response.content_encoding = 'gzip'
            except Exception:
                logger.exception("Error compressing response, "
                                 "falling back to uncompressed.")
        response.set_data(rp_content)

        return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_data [as 别名]
###############################################################################

# construct #######################################################
# For most mime types mimetype and content_type work the same, but
# the charset. If the mimetype passed and starting with text/, the
# charset is set. In contrast the content_type parameter is always
#  added as header unmodified.
response = Response('Hello World', status=200)

# inspect #########################################################
# headers
response.headers['Content-Encoding'] = 'gzip'

# request body
response.get_data()
response.set_data()

# cookies
response.set_cookie('username', 'John')

# get (app_iter, status, headers)
response.get_wsig_response()


###############################################################################
#                            Request
#     The request object is immutable. Modifications are not supported by
# default, you may however replace the immutable attributes with mutable
# attributes if you need to modify it.
#     The request object may be shared in the same thread, but is not thread
# safe itself.

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_data [as 别名]
 def serve_index(self, environ, start_response):
     response = Response()
     response.headers['Content-Type'] = 'text/html'
     with open('index.html', 'r') as f:
         response.set_data(f.read())
     return response(environ, start_response)

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_data [as 别名]
    def _try_serve_page(self, app, environ, request):
        # Find a matching page.
        req_page = get_requested_page(app, request.path)

        # If we haven't found any good match, report all the places we didn't
        # find it at.
        qp = req_page.qualified_page
        if qp is None:
            msg = "Can't find path for '%s':" % request.path
            raise MultipleNotFound(msg, req_page.not_found_errors)

        # We have a page, let's try to render it.
        render_ctx = PageRenderingContext(qp,
                                          page_num=req_page.page_num,
                                          force_render=True,
                                          is_from_request=True)
        if qp.route.is_generator_route:
            qp.route.generator.prepareRenderContext(render_ctx)

        # See if this page is known to use sources. If that's the case,
        # just don't use cached rendered segments for that page (but still
        # use them for pages that are included in it).
        uri = qp.getUri()
        entry = self._page_record.getEntry(uri, req_page.page_num)
        if (qp.route.is_generator_route or entry is None or
                entry.used_source_names):
            cache_key = '%s:%s' % (uri, req_page.page_num)
            app.env.rendered_segments_repository.invalidate(cache_key)

        # Render the page.
        rendered_page = render_page(render_ctx)

        # Remember stuff for next time.
        if entry is None:
            entry = ServeRecordPageEntry(req_page.req_path, req_page.page_num)
            self._page_record.addEntry(entry)
        for pinfo in render_ctx.render_passes:
            entry.used_source_names |= pinfo.used_source_names

        # Start doing stuff.
        page = rendered_page.page
        rp_content = rendered_page.content

        # Profiling.
        if app.config.get('site/show_debug_info'):
            now_time = time.perf_counter()
            timing_info = (
                    '%8.1f ms' %
                    ((now_time - app.env.start_time) * 1000.0))
            rp_content = rp_content.replace(
                    '__PIECRUST_TIMING_INFORMATION__', timing_info)

        # Build the response.
        response = Response()

        etag = hashlib.md5(rp_content.encode('utf8')).hexdigest()
        if not app.debug and etag in request.if_none_match:
            response.status_code = 304
            return response

        response.set_etag(etag)
        response.content_md5 = etag

        cache_control = response.cache_control
        if app.debug:
            cache_control.no_cache = True
            cache_control.must_revalidate = True
        else:
            cache_time = (page.config.get('cache_time') or
                          app.config.get('site/cache_time'))
            if cache_time:
                cache_control.public = True
                cache_control.max_age = cache_time

        content_type = page.config.get('content_type')
        if content_type and '/' not in content_type:
            mimetype = content_type_map.get(content_type, content_type)
        else:
            mimetype = content_type
        if mimetype:
            response.mimetype = mimetype

        if ('gzip' in request.accept_encodings and
                app.config.get('site/enable_gzip')):
            try:
                with io.BytesIO() as gzip_buffer:
                    with gzip.open(gzip_buffer, mode='wt',
                                   encoding='utf8') as gzip_file:
                        gzip_file.write(rp_content)
                    rp_content = gzip_buffer.getvalue()
                    response.content_encoding = 'gzip'
            except Exception:
                logger.error("Error compressing response, "
                             "falling back to uncompressed.")
        response.set_data(rp_content)

        return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import set_data [as 别名]
    def _try_serve_page(self, app, environ, request):
        # Find a matching page.
        req_pages, not_founds = get_requested_pages(app, request.path)

        rendered_page = None

        for req_page in req_pages:
            # We have a page, let's try to render it.
            render_ctx = RenderingContext(req_page.page,
                                          sub_num=req_page.sub_num,
                                          force_render=True)
            req_page.page.source.prepareRenderContext(render_ctx)

            # Render the page.
            this_rendered_page = render_page(render_ctx)

            # We might have rendered a page that technically exists, but
            # has no interesting content, like a tag page for a tag that
            # isn't used by any page. To eliminate these false positives,
            # we check if there was pagination used, and if so, if it had
            # anything in it.
            # TODO: we might need a more generic system for other cases.
            render_info = this_rendered_page.render_info
            if (render_info['used_pagination'] and
                    not render_info['pagination_has_items']):
                not_founds.append(PageNotFoundError(
                    ("Rendered '%s' (page %d) in source '%s' "
                     "but got empty content:\n\n%s\n\n") %
                    (req_page.req_path, req_page.sub_num,
                     req_page.page.source.name, this_rendered_page.content)))
                continue

            rendered_page = this_rendered_page
            break

        # If we haven't found any good match, report all the places we didn't
        # find it at.
        if rendered_page is None:
            msg = "Can't find path for '%s':" % request.path
            raise MultipleNotFound(msg, not_founds)

        # Start doing stuff.
        page = rendered_page.page
        rp_content = rendered_page.content

        # Profiling.
        if app.config.get('site/show_debug_info'):
            now_time = time.perf_counter()
            timing_info = (
                '%8.1f ms' %
                ((now_time - app.env.start_time) * 1000.0))
            rp_content = rp_content.replace(
                '__PIECRUST_TIMING_INFORMATION__', timing_info)

        # Build the response.
        response = Response()

        etag = hashlib.md5(rp_content.encode('utf8')).hexdigest()
        if not app.debug and etag in request.if_none_match:
            response.status_code = 304
            return response

        response.set_etag(etag)
        response.content_md5 = etag

        cache_control = response.cache_control
        if app.debug:
            cache_control.no_cache = True
            cache_control.must_revalidate = True
        else:
            cache_time = (page.config.get('cache_time') or
                          app.config.get('site/cache_time'))
            if cache_time:
                cache_control.public = True
                cache_control.max_age = cache_time

        content_type = page.config.get('content_type')
        if content_type and '/' not in content_type:
            mimetype = content_type_map.get(content_type, content_type)
        else:
            mimetype = content_type
        if mimetype:
            response.mimetype = mimetype

        if ('gzip' in request.accept_encodings and
                app.config.get('site/enable_gzip')):
            try:
                with io.BytesIO() as gzip_buffer:
                    with gzip.open(gzip_buffer, mode='wt',
                                   encoding='utf8') as gzip_file:
                        gzip_file.write(rp_content)
                    rp_content = gzip_buffer.getvalue()
                    response.content_encoding = 'gzip'
            except Exception:
                logger.error("Error compressing response, "
                             "falling back to uncompressed.")
        response.set_data(rp_content)

        return response