Python Response.make_conditional方法代码示例

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import make_conditional [as 别名]
	def get_favicon(self, request):
		f = path.join(self.www_dp, 'icons', 'loris-icon.png')
		r = Response(file(f), content_type='image/x-icon')
		if self.enable_caching:
			r.add_etag()
			r.make_conditional(request)
		return r

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import make_conditional [as 别名]
 def create_response(self, request, tile_data, format):
     response = Response(
         tile_data,
         mimetype=format.mimetype,
         headers=[('Access-Control-Allow-Origin', '*')])
     response.add_etag()
     response.make_conditional(request)
     return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import make_conditional [as 别名]
	def get_index(self, request):
		'''
		Just so there's something at /.
		'''
		f = file(path.join(self.www_dp, 'index.txt'))
		r = Response(f, content_type='text/plain')
		if self.enable_caching:
			r.add_etag()
			r.make_conditional(request)
		return r

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import make_conditional [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.

        """
        original_response = Response.from_app(self.wrapped_app, environ)
        # We send relative locations to play nice with reverse proxies
        # but Werkzeug by default turns them into absolute ones.
        original_response.autocorrect_location_header = False

        if self.DIGEST_HEADER not in original_response.headers:
            return original_response

        digest = original_response.headers.pop(self.DIGEST_HEADER)
        filename = original_response.headers.pop(self.FILENAME_HEADER, None)
        mimetype = original_response.mimetype

        try:
            fobj = self.file_cacher.get_file(digest)
            size = self.file_cacher.get_size(digest)
        except KeyError:
            return NotFound()
        except TombstoneError:
            return ServiceUnavailable()

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

        response = Response()
        response.status_code = 200
        response.mimetype = mimetype
        if filename is not None:
            response.headers.add(
                "Content-Disposition", "attachment", filename=filename)
        response.set_etag(digest)
        response.cache_control.max_age = SECONDS_IN_A_YEAR
        response.cache_control.private = True
        response.response = \
            wrap_file(environ, fobj, buffer_size=FileCacher.CHUNK_SIZE)
        response.direct_passthrough = True

        try:
            # This takes care of conditional and partial requests.
            response.make_conditional(
                request, accept_ranges=True, complete_length=size)
        except HTTPException as exc:
            return exc

        return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import make_conditional [as 别名]
    def create_response(self, request, status, body, mimetype):
        response_args = dict(
            status=status,
            mimetype=mimetype,
        )
        if self.add_cors_headers:
            response_args['headers'] = [('Access-Control-Allow-Origin', '*')]
        response = Response(body, **response_args)

        if status == 200:
            response.add_etag()
            response.make_conditional(request)

        return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import make_conditional [as 别名]
 def handle_request(self, request):
     if not request.path.endswith('.png'):
         return self.generate_404()
     vector_tile_service_path = request.path.replace('.png', '.json')
     fetch_result = self.fetcher(vector_tile_service_path)
     if fetch_result.is_error:
         return self.error_fetch_response(self, fetch_result)
     json_data = fetch_result.content
     feature_layers = transform_to_feature_layers(json_data)
     gif_content = self.mapnik_formatter(feature_layers)
     response = Response(gif_content, mimetype='image/png',
                         headers=[('Access-Control-Allow-Origin', '*')])
     response.add_etag()
     response.make_conditional(request)
     return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import make_conditional [as 别名]
    def render_static(self, request, fileobj):
        if request.method != 'GET':
            raise http.MethodNotAllowed(['GET'])

        content_type, _ = mimetypes.guess_type(fileobj.name)

        stat = os.stat(fileobj.name)
        etag = hashlib.md5(str(stat.st_mtime)).hexdigest()

        response = Response(fileobj, mimetype=content_type)
        response.content_length = stat.st_size
        response.add_etag(etag)
        response.last_modified = datetime.utcfromtimestamp(stat.st_mtime)
        response.expires = datetime.utcfromtimestamp(stat.st_mtime + self.static_expires)

        response.make_conditional(request)
        return response

# 需要导入模块: from werkzeug.wrappers import Response [as 别名]
# 或者: from werkzeug.wrappers.Response import make_conditional [as 别名]
    def images(self, slug, max_width=None, max_height=None, *args, **kwargs):
        cr, context = request.cr, request.context

        # buscamos imagen por slug
        img, model = self._get_image_gallery(slug)
        if not img:
            return request.not_found()

        # leemos imagen
        [record] = model.read(
            cr, SUPERUSER_ID, [img[0]],
            ['name', 'last_update_img'], context=context)

        path_file = os.path.join(_filestorage(cr), record.get('name'))
        if not path_file:
            return request.not_found()

        # generamos respuesta
        server_format = misc.DEFAULT_SERVER_DATETIME_FORMAT
        response = Response(mimetype='image/jpg')
        response.last_modified = datetime.datetime.strptime(
            record.get('last_update_img'), server_format)
        response.make_conditional(request.httprequest)
        if response.status_code == 304:
            return response

        # si no hay tamaño la original
        if (not max_width) and (not max_height):
            data = self._read_image_data(path_file)
            response.set_etag(hashlib.sha1(data).hexdigest())
            response.data = data
            return response

        # creamos thumb si no existe
        path, file_name = os.path.split(path_file)
        path_file_thumb = os.path.join(path,
                                       '{}x{}'.format(max_width, max_height))
        if not os.path.exists(path_file_thumb):
            try:
                os.makedirs(path_file_thumb)
            except:
                _log.error(u"ERROR creando directorio para galerias <{}>"
                    .format(slug))
                return response

        path_file_thumb = os.path.join(path_file_thumb, file_name)
        if os.path.exists(path_file_thumb):
            data = self._read_image_data(path_file_thumb)
            response.set_etag(hashlib.sha1(data).hexdigest())
            response.data = data
            return response

        # creamos thumb
        data = self._read_image_data(path_file)
        response.set_etag(hashlib.sha1(data).hexdigest())
        image = Image.open(cStringIO.StringIO(data))
        response.mimetype = Image.MIME[image.format]

        w, h = image.size
        max_w = int(max_width) if max_width else maxint
        max_h = int(max_height) if max_height else maxint

        # guardamos en disco
        image.thumbnail((max_w, max_h), Image.ANTIALIAS)
        image.save(path_file_thumb, image.format)

        response.data = self._read_image_data(path_file_thumb)

        return response