标签: flask-cache

我对.js我使用的其中一个文件进行了更改,无论我做什么,烧瓶都坚持要从内存缓存中获取文件的最后一个版本,而不进行更改.

为了澄清,我有以下结构.一切都始于foo.html

return render_template foo.html

foo.html有一个表单内部调用flask与一些数据,然后返回第二个模板bar.html:

return render_template bar.html

第二个模板调用.js放在static文件夹中的某个文件,但在代码更改时不会更新.

我提到了上面的结构,因为如果.js放置文件foo.html而不是bar.html然后Flask 会在文件上获取新的更改.但在bar.htmlFlask中完全忽略了它们.

怎么了？

唯一有效的方法是在浏览器上单击"禁用缓存"并重新加载.

我有一个烧瓶应用程序,它从Web表单中获取参数,查询DB w/SQL炼金术并返回一个jinja生成的模板,显示包含结果的表.我想缓存对DB的调用.我查看了redis,使用redis作为postgres的LRU缓存 - 这引导我到http://pythonhosted.org/Flask-Cache/

现在我尝试使用redis + flask-cache来缓存对数据库的调用.基于Flask-Cache文档,我似乎需要设置自定义redis缓存.

class RedisCache(BaseCache):
    def __init__(self, servers, default_timeout=500):
        pass

def redis(app, config, args, kwargs):
   args.append(app.config['REDIS_SERVERS'])
   return RedisCache(*args, **kwargs)

从那里我需要类似的东西

# not sure what to put for args or kwargs
cache = redis(app, config={'CACHE_TYPE': 'redis'})

app = Flask(__name__)
cache.init_app(app)

我有两个问题:

首先:我为args和kwargs做什么？这些是什么意思？如何使用flask缓存设置redis缓存？

第二:一旦设置了缓存,似乎我想以某种方式" 记住 "DB的调用,这样如果方法得到相同的查询,它就会缓存输出.我该怎么做呢？我最好的猜测是将SQL炼金术的调用包装在一个方法中,然后可以给memoize装饰器？这样,如果将两个相同的查询传递给方法,flask-cache将识别出这一点并返回相应的响应.我猜它会是这样的:

@cache.memoize(timeout=50)
def queryDB(q):
    return q.all()

这似乎是一个相当普遍的使用redis + flask + flask-cache + sql炼金术,但我无法找到一个完整的例子.如果有人可以发布一个,这将是非常有用的 - 但对我和其他人来说.

如何在Flask-Restful中使用Flask-Cache @ cache.cached()装饰器？例如,我有一个继承自Resource的Foo类,而Foo有get,post,put和delete方法.

如何在一个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()

我在使用Flask-Cache时遇到了问题.我需要在需要的基础上进行缓存,方法是定义一个配置变量,用户可以设置该变量来启用或禁用缓存.

我正在使用Flask-Cache进行缓存

cache = Cache(config = {'CACHE_TYPE':'redis'})

app = Flask(名字)

初始化缓存

cache.init_app(APP)

清除缓存

使用app.app_context():

 cache.clear()

Run Code Online (Sandbox Code Playgroud)

并使用缓存(在views.py中)作为

@ app.route('/',methods = ['GET'])

@validate_access(current_user,"read")

@要求登录

@ cache.memoize()

def get_values(id):

  return get_values()

Run Code Online (Sandbox Code Playgroud)

在使用Flask-Cache时,我没有获得正确的启用/禁用缓存的方法.是否有一种标准方式可以完全启用/禁用缓存行为.

在Flask-Cache文档中,所有示例都使用有限超时.

我想在应用程序运行时永远不刷新缓存.这是可能的,如果是这样,我该怎么做？

我在我的python Flask app中使用memcached模块AWS Elasticache(带Flask-Cache)

当我尝试设置一个小于1MB我需要重复访问缓存的文件时,我没有问题.但是当文件大小增加超过MB(文件可能是文本文件/ csv/xlsx等)时,我收到以下错误

错误:来自memcached_set的错误37:SUCCESS

我猜它是因为memcached项目的大小限制,上限为1MB.如何在AWS Elasticache中将此项目限制增加到5-6 MB？

在memcached中增加此项目大小限制是否有任何问题？

我遵循了Flask-Cache 的教程,并尝试自己实现它.鉴于以下示例,为什么Flask不会缓存时间？

from flask import Flask
import time

app = Flask(__name__)
cache = Cache(config={'CACHE_TYPE': 'simple'})
cache.init_app(app)

@app.route('/time')
@cache.cached(timeout=50, key_prefix='test')
def test():
   return time.ctime()

输出始终是当前时间.

看起来每个请求都会重新创建缓存.我究竟做错了什么？

编辑:我用Python 2.7.6执行以下python文件:

def runserver():
    port = int(os.environ.get('PORT', 5000))
    Triangle(app)
    app.run(host='0.0.0.0', port=port, processes=5)


if __name__ == '__main__':
    runserver()

我在这个问题上挠头。

我有一个带有 Flask-Cache 和 SqlAlchemy 的 Flask 应用程序：

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql+pg8000://[Redacted]
cache = Cache(app, config={'CACHE_TYPE':'redis', 'CACHE_REDIS_URL':'[Redacted]'})
db = SQLAlchemy(app)

芹菜工人：

@worker_process_init.connect
def init_worker(**kwargs):
    global db_session
    print('Initializing database connection for worker.')
    db_session = database.get_session()


@worker_process_shutdown.connect
def shutdown_worker(**kwargs):
    global db_session
    if db_session.is_active:
        print('Closing database connectionn for worker.')
        db_session.close()

还有一个通用的 get_or_create def：

@cache.cached(timeout=200, key_prefix="get_or_create")
def get_or_create(model, **kwargs):
    instance = model.query.filter_by(**kwargs).first()
    if instance:
        return instance
    else:
        instance = model(**kwargs)
        db_session.add(instance)
        return instance

我正在尝试使用缓存来解决导致 UniqueConstraint 违规的多处理（即，当两个工作人员同时插入非唯一对象时，应该在第一个插入后更新）

工人在喷

InvalidRequestError: 实例 '<[Redacted]>' 在此会话中不是持久的

我能弄清楚的是我需要扩大会议的范围吗？

UWSGI 通过 UNIX 套接字连接到 Flask 应用程序：

NGINX（监听端口 80）<-> UWSGI（每个 UNIX-SOCKER 的列表）<-> FLASK-APP

我已经初始化了一个 uwsgi 缓存来处理全局数据。我想使用 python 包 Flask-caching 来处理缓存。

我正在尝试使用正确的缓存地址初始化缓存实例。似乎有什么不对劲。我认为 app.run() 的参数与 uwsgi 无关。

如果我设置缓存条目，它总是返回 None：

app.route("/")
def test():
    cache.set("test", "OK", timeout=0)
    a = cache.get("test")
    return a

主要.py

from flask import Flask
from flask_caching import Cache

app = Flask(__name__)
# Check Configuring Flask-Caching section for more details
cache = Cache(app, config={'CACHE_TYPE': 'uwsgi', 'CACHE_UWSGI_NAME':'mycache@localhost'})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

uwsgi.ini

[uwsgi]
module = main
callable = app
cache2 = name=mycache,items=100 …

flask_cache.Cache.memoize不与flask_restful.Resource

这是示例代码：

from flask import Flask, request, jsonify
from flask_restful import Resource, Api
from flask_cache import Cache

app = Flask(__name__)
api = Api(app)
cache = Cache(app, config={'CACHE_TYPE': 'simple'})


class MyResource(Resource):
    JSONIFY = True
    PATH = None
    ENDPOINT = None

    def dispatch_request(self, *args, **kwargs):
        kw = dict(**kwargs)
        kw.update(request.args.items())
        r = super().dispatch_request(*args, **kw)
        if self.JSONIFY:
            return jsonify(r)
        else:
            return r


class DebugResource(MyResource):
    PATH = '/debug'
    ENDPOINT = 'debug'

    @cache.memoize(timeout=30)
    def get(self, **kwargs):
        print('cache is not used!')
        return kwargs

for r …