python - memoize - Cómo usar Flask-Cache con Flask-Restful

flask caching memoize

Question

¿Cómo uso Flask-Cache @ cache.cached () decorator con Flask-Restful? Por ejemplo, tengo una clase que Foo heredó de Resource, y Foo tiene los métodos de obtención, publicación, colocación y eliminación.

¿Cómo puedo invalidar los resultados en caché después de un POST ?

@api.resource(''/whatever'')
class Foo(Resource):
    @cache.cached(timeout=10)
    def get(self):
        return expensive_db_operation()

    def post(self):
        update_db_here()

        ## How do I invalidate the value cached in get()?
        return something_useful()

Answer 1

Como la implementación de Flask-Cache no le da acceso al objeto de cache subyacente, tendrá que crear una instancia explícita de un cliente Redis y usar su método de keys (enumerar todas las claves de caché).

• El método cache_key se usa para anular la generación de clave predeterminada en su decorador cache.cached .
• El método clear_cache borrará solo la parte del caché correspondiente al recurso actual.

Esta es una solución que se probó solo para Redis y la implementación probablemente diferirá un poco cuando se use un motor de caché diferente.

from app import cache # The Flask-Cache object
from config import CACHE_REDIS_HOST, CACHE_REDIS_PORT # The Flask-Cache config
from redis import Redis
from flask import request
import urllib

redis_client = Redis(CACHE_REDIS_HOST, CACHE_REDIS_PORT)

def cache_key():
   args = request.args
   key = request.path + ''?'' + urllib.urlencode([
     (k, v) for k in sorted(args) for v in sorted(args.getlist(k))
   ])
   return key

@api.resource(''/whatever'')
class Foo(Resource):

    @cache.cached(timeout=10, key_prefix=cache_key)
    def get(self):
        return expensive_db_operation()

    def post(self):
        update_db_here()
        self.clear_cache()
        return something_useful()

    def clear_cache(self):
        # Note: we have to use the Redis client to delete key by prefix,
        # so we can''t use the ''cache'' Flask extension for this one.
        key_prefix = request.path
        keys = [key for key in redis_client.keys() if key.startswith(key_prefix)]
        nkeys = len(keys)
        for key in keys:
            redis_client.delete(key)
        if nkeys > 0:
            log.info("Cleared %s cache keys" % nkeys)
            log.info(keys)

Answer 2

Puede invalidar el caché usando el método cache.clear() .
Para obtener más publicaciones, consulte: https://pythonhosted.org/Flask-Cache/#flask.ext.cache.Cache.clear y la sección de borrado de caché en https://pythonhosted.org/Flask-Cache/

Answer 3

Sí, puedes usar así.

Tal vez aún necesite leer: parámetros de cadena de consulta de URL memoize de flask-cache también

Answer 4

##create a decarator
from werkzeug.contrib.cache import SimpleCache
CACHE_TIMEOUT = 300
cache = SimpleCache()
class cached(object):

 def __init__(self, timeout=None):
    self.timeout = timeout or CACHE_TIMEOUT

 def __call__(self, f):
    def decorator(*args, **kwargs):
        response = cache.get(request.path)
        if response is None:
            response = f(*args, **kwargs)
            cache.set(request.path, response, self.timeout)
        return response
    return decorator


#add this decarator to your views like below
@app.route(''/buildingTotal'',endpoint=''buildingTotal'') 
@cached()
def eventAlert():
  return ''something''

@app.route(''/buildingTenants'',endpoint=''buildingTenants'')
@cached()
def buildingTenants():
  return ''something''