Using Flask Cache

As a micro framework Flask does not have built-in cache functionality, however, there is werkzeug cache API and an excellent extension to provide its caching functionality to your Flask apps, that extension was created by @thadeusb and is very easy to implement and use.

installing

In your env install it via PyPI (recommended)

pip install Flask-Cache

You can also install it directly from source code if you need recent changes or bugfixes

pip install https://github.com/thadeusb/flask-cache/tarball/master

Configuring

There is a set of configuration keys you can put in your app settings, but the most important is the cache backend defined by the CACHE_TYPE key.

The cache type resolves to an import string which needs to be an object implementing the werkzeug cache api, but there is some aliases to the werkzeug.contrib.cache implementations

By default the CACHE_TYPE is Null which means that your app will have no cache, so you need to choose of the options below:

null | No Cache - NullCache

| No Cache - NullCache simple | Will use in memory pickle and is recommended only for single process development server

| Will use in memory pickle and is recommended only for single process development server memcached | Requires pylibmc or memcached and requires memcached configuration in settings

| Requires pylibmc or memcached and requires memcached configuration in settings redis | Requires redis, werkzeug 0.7 and redis configuration in settings

| Requires redis, werkzeug 0.7 and redis configuration in settings filesystem | The same as simple but stores the pickle in a cache_dir

| The same as but stores the pickle in a cache_dir gaememcached | For Google AppEngine

| For Google AppEngine saslmemcached | The same as memcached but for SASL - pylibmc required

Full options and config variables are in http://pythonhosted.org/Flask-Cache/#configuring-flask-cache

A Simple Flask app

a file named app.py

import time from flask import Flask app = Flask(__name__) @app.route("/") def view(): return time.ctime() if __name__ == "__main__": app.run(port=5000, debug=True, host='0.0.0.0')

Run the above with python app.py and open http://localhost:5000 in your browser and hit F5 (refresh) to see the current date and time.

Enabling Flask-Cache for views

Now we want to enable caching on that small application to avoid the refresh of the current time (for this example we are using current time as return but imagine that it could be a large dataset or huge calculations)

a file named cached_app.py

import time from flask import Flask # import the flask extension from flask.ext.cache import Cache app = Flask(__name__) # define the cache config keys, remember that it can be done in a settings file app.config['CACHE_TYPE'] = 'simple' # register the cache instance and binds it on to your app app.cache = Cache(app) @app.route("/") @app.cache.cached(timeout=300) # cache this view for 5 minutes def cached_view(): return time.ctime() if __name__ == "__main__": app.run(port=5000, debug=True, host='0.0.0.0')

Run the above with python cached_app.py and open http://localhost:5000 in your browser and hit F5 (refresh) to see that the current date and time is now cached for 5 minutes.

@cache.cached decorator takes the request.path for that view and use this as cache key, if for any reason you need a different key you can pass a key_prefix argument to the decorator. In this case if you pass a key_prefix containing the %s placeholder it will be replaced by the current request.path

The above is the simplest and regular example of Flask app and the use of cache, but, if your app is designed using application factories, blueprints, class based views or views located in different modules you will need to use advanced approach.

Caching regular functions

The same cached decorator can be used to cache regular functions, but in this case you will need to specify the key_prefix argument, otherwise it will use the request.path which can lead to conflicts if you have many cached functions.

For this example we are going to use the this module and extract a random quote from the Zen of Python.

A file named cached_function_app.py

import time import random from this import s, d from string import translate, maketrans from flask.ext.cache import Cache from flask import Flask app = Flask(__name__) app.config['CACHE_TYPE'] = 'simple' app.cache = Cache(app) @app.cache.cached(timeout=10, key_prefix="current_time") def get_current_time(): return time.ctime() def random_zen_quote(): """Pick a random quote from the Zen of Python""" transtable = maketrans("".join(d.keys()), "".join(d.values())) return random.choice(translate(s, transtable).split("

")[2:]) @app.route("/") def zen(): return """ <ul> <li><strong>It is cached:</strong> {cached}</li> <li><strong>It is not cached:</strong> {not_cached}</li> </ul> """.format( cached=get_current_time(), not_cached=random_zen_quote() ) if __name__ == "__main__": app.run(debug=True, port=5000, host='0.0.0.0')

Now running python cached_function_app.py and opening http://localhost:5000 when hitting F5 to refresh you will see the current time cached for 5 minutes and the random quote updated, you can switch the cache just to see the efect.

def get_current_time(): return time.ctime() @app.cache.cached(timeout=10, key_prefix="zen_quote") def random_zen_quote(): transtable = maketrans("".join(d.keys()), "".join(d.values())) return random.choice(translate(s, transtable).split("

")[2:]) @app.route("/") def zen(): return """ <ul> <li><strong>It is not cached:</strong> {cached}</li> <li><strong>It is cached:</strong> {not_cached}</li> </ul> """.format( cached=get_current_time(), not_cached=random_zen_quote() )

NOTE: Because we are importing the this module for the example, you will see the Zen quotes in your flask terminal, but there is no problem with this.

Caching modular views

Now an example when you have your app splitted in two or more files for better organization

in a folder called app put 3 files __init__.py , app.py and views.py

app/__init__.py is an empty file

app/views.py

import time import random from this import s, d from string import translate, maketrans def get_current_time(): return time.ctime() def random_zen_quote(): transtable = maketrans("".join(d.keys()), "".join(d.values())) return random.choice(translate(s, transtable).split("

")[2:]) def zen_view(): return """ <h1>Cached for 10 seconds!</h1> <ul> <li>{time}</li> <li>{quote}</li> </ul> """.format( time=get_current_time(), quote=random_zen_quote() )

as you can see the above file defined view functions, as it it a separated file, to avoid circular imports we are not recommended to use @app.route neither @app.cache so this views will be app agnostic and we are going to register its url rules and caching in the main app file.

That kind of structure is needed when your app has too many views and want a better organization.

NOTE: For better organization the mostly recommended pattern is Blueprints which I will explain further.

app/app.py

Now in the main app we need to import our views, explicitly decorate for caching and also register its urls.

from flask import Flask from flask.ext.cache import Cache from views import zen_view app = Flask(__name__) app.config['CACHE_TYPE'] = 'simple' app.cache = Cache(app) # explicitly apply the cache in the old-style decoration way cached_zen_view = app.cache.cached(timeout=10)(zen_view) # explicitly register the cached view url mapping app.add_url_rule("/", view_func=cached_zen_view) if __name__ == "__main__": app.run(debug=True, port=5000, host='0.0.0.0')

NOTE: You can also separate the cache instance in a different file for lazy initialization as we are going to see in the next example

Caching Blueprint views

As mentioned before, the best pattern to follow in Flask applications is the Blueprint pattern which is a way to create separated 'meta-apps' that will be connected to your main application in the time of initialization, the problem here is that Blueprints are meant to be reusable by many different applications, so the delegation of cache control should be dynamized.

In order to avoid circular imports you will want to create your cache instance separate from your application instance (you may want to consider switching to the app factory module if you are building something more complex).

Create a folder called blueprint_app with the following structure

cached_blueprint_app/ ├── app.py ├── cache.py ├── blueprints │ ├── __init__.py │ └── zen_blueprint.py └── __init__.py

The cache.py

from flask.ext.cache import Cache cache = Cache()

we can create a dummy lazy cache instance, that will be initialized in the future when the view will be called. For that in the app we are going to reimport the same cache instance and call init_app method.

The basic blueprints/zen_blueprint.py

import time import random from this import s, d from string import translate, maketrans from flask import Blueprint from cache import cache zen = Blueprint('zen', __name__) def get_current_time(): return time.ctime() def random_zen_quote(): transtable = maketrans("".join(d.keys()), "".join(d.values())) return random.choice(translate(s, transtable).split("

")[2:]) @zen.route("/") @cache.cached(timeout=20) def zen_view(): return """ <h1>Cached for 20 seconds!</h1> <ul> <li>{time}</li> <li>{quote}</li> </ul> """.format( time=get_current_time(), quote=random_zen_quote() )

NOTE: In a real application you will want to modularize it separating the views, helpers etc and promoting your blueprint to a Python package.

The main app.py

from flask import Flask from blueprints.zen_blueprint import zen from cache import cache app = Flask(__name__) app.config['CACHE_TYPE'] = 'simple' cache.init_app(app) app.register_blueprint(zen) if __name__ == "__main__": app.run(debug=True, port=5000, host='0.0.0.0')

Notice that we created a dummy instance of cache in cache.py and then used that instance to decorate the blueprints views, then the cache was initialized in app.py with init_app method. That is possible because of the Flask initialization cycle and the excellent implementation in Flask-Cache extension that takes care of this case, if you plan to write yor own Flask extension take a look at the Flask-Cache source code.

Run the application by calling python cached_blueprint_app/app.py and open http://localhost:5000 to see the blueprint view cached for 20 seconds.

Caching MethodView

Lets use the same cached_blueprint_app example but turning the zen_view in to a MethodView

Change your zen_blueprint.py to:

import time import random from this import s, d from string import translate, maketrans from flask import Blueprint from flask.views import MethodView from cache import cache zen = Blueprint('zen', __name__) class ZenView(MethodView): @cache.cached(30) def get(self): return """ <h1>Cached for 30 seconds!</h1> <ul> <li>{time}</li> <li>{quote}</li> </ul> """.format( time=self.get_current_time(), quote=self.random_zen_quote() ) @staticmethod def get_current_time(): return time.ctime() @staticmethod def random_zen_quote(): transtable = maketrans("".join(d.keys()), "".join(d.values())) return random.choice(translate(s, transtable).split("

")[2:]) zen.add_url_rule("/", view_func=ZenView.as_view('zen'))

Method views maps HTTP method names as GET, POST, DELETE to the view methos as get, post, delete etc, So all we needed to do is to create a method called get and decorate it with @cache.cached decorator.

NOTE: Due to the implicit self from the caller’s perspective you cannot use regular view decorators on the individual methods of the view however, Flask-Cache is one exception because its implementation allow the use of cached decorator in individual methods. Keep this in mind.

Alternativelly you may want to cache all the methods in a view, for that you can cache the dispatch_request method or even better you can decorate the whole view.

Caching the dispatcher

class ZenView(MethodView): @cache.cached(timeout=30) def dispatch_request(self): return super(ZenView, self).dispatch_request() ...

Caching the whole view (recommended)

zen = Blueprint('zen', __name__) class ZenView(MethodView): ... cached_zen_view = cache.cached(timeout=50)(ZenView.as_view('zen')) zen.add_url_rule("/", view_func=cached_zen_view)

Caching template blocks

Flask cache comes with a template tag able to cache template blocks, lets change our ZenView to use a Jinja2 template

in zen_blueprint.py

import time import random from this import s, d from string import translate, maketrans from flask import Blueprint, render_template from flask.views import MethodView zen = Blueprint('zen', __name__) class ZenView(MethodView): def get(self): return render_template( 'zen.html', get_random_quote=self.random_zen_quote ) @staticmethod def get_current_time(): return time.ctime() @staticmethod def random_zen_quote(): transtable = maketrans("".join(d.keys()), "".join(d.values())) return random.choice(translate(s, transtable).split("

")[2:]) zen.add_url_rule("/", view_func=ZenView.as_view('zen'))

Now we need to create a template file in cached_blueprint_app/templates/zen.html

<h3> Random Zen of Python </h3> <strong>{{get_random_quote()}}</strong>

Running the application with python cached_blueprint_app/app.py and opening http://localhost:5000 you will see a random quote refreshed every time you push F5, lets cache it for 30 second.

Change the zen.html template

{% cache 30 %} <h3> Random Zen of Python </h3> <strong>{{get_random_quote()}}</strong> {% endcache %}

Now save the file and refresh to see the content cached for 30 seconds.

Caching functions and views with variant arguments using memoize decorator

Sometimes yout views and functions receives arguments which can come from url mapping or directly to the function call, yiou may want to cache the view or funtion and use the arguments as keys to cache its different results, Flask-Cache has a different decorator for doing that.

NOTE: With functions that do not receive arguments, cached() and memoize() are effectively the same.

Now with a simple application memoize_app.py

import time from flask.ext.cache import Cache from flask import Flask app = Flask(__name__) app.config['CACHE_TYPE'] = 'simple' app.cache = Cache(app) @app.cache.memoize(timeout=5) def get_current_time_and_name(name): return "%s - %s" % (name, time.ctime()) @app.route("/<name>") def view(name): return get_current_time_and_name(name) if __name__ == "__main__": app.run(debug=True, port=5000, host='0.0.0.0')

Now run python memoize_app.py and open http://localhost:5000/yourname and note that the function will be cached for each different name you pass as argument in the url.

Caching arbitrary objects

There are some times when decorators cannot be used and you need to explicitly set or get some thing on the cache.

Inside a view or a blueprint you can use current_app

from flask import current_app def some_function(): cached = current_app.cache.get('a_key') if cached: return cached result = do_some_stuff() current_app.cache.set('a_key', result, timeout=300) return result

Or if using a separete cache instance you can do this directly

from cache import cache def function(): cached = cache.get('a_key') if cached: return cached result = do_some_stuff() cache.set('a_key', result, timeout=300) return result

Clearing the cache

You can create a script to clear the cache, or a function to use it when needed

from flask.ext.cache import Cache from yourapp import app cache = Cache() def main(): cache.init_app(app) with app.app_context(): cache.clear() if __name__ == '__main__': main()

WARNING: Some backend implementation do not support completely clearing the case. Also, if you’re not using key prefix, some implementation (e.g. Redis) will flush the whole database. Make sure you’re not storing any other data in your caching database.

There is a lot of examples and well documented API in flask-Cache website http://pythonhosted.org/Flask-Cache/ you can also create your own cache backend following the examples in the Flask-Cache docs.

Please enable JavaScript to view the comments powered by Disqus.

Disqus