Flask-Caching

2.3.1 · active · verified Thu Apr 09

Flask-Caching adds comprehensive caching support to Flask applications, providing various backend options such as SimpleCache, RedisCache, MemcachedCache, FileSystemCache, and others. It integrates seamlessly with Flask applications to cache view functions or parts of templates. The current version is 2.3.1, and the library maintains an active release cadence with regular updates and patches.

Warnings

breaking Flask-Caching v2.0.0 and newer versions require Flask 2.0 or higher. Applications running older Flask versions (e.g., Flask 1.x) must either upgrade Flask or stick to Flask-Caching v1.x to maintain compatibility.
Fix: Upgrade Flask to 2.0+ (e.g., `pip install Flask>=2.0`) or keep Flask-Caching at v1.x or earlier (e.g., `pip install Flask-Caching==1.11.1`).
breaking Starting with v2.0.0, the import paths for many cache backends have changed. Previously, backends like `RedisCache` were often imported from `flask_caching.ext.redis`. The `ext` module has been removed, and all backends are now located under `flask_caching.backends.<backend_name_module>`. This is a significant change requiring update of import statements.
Fix: Update import statements. For example, change `from flask_caching.ext.redis import RedisCache` to `from flask_caching.backends.rediscache import RedisCache`. Consult the documentation for specific backend import paths.
breaking The `uwsgicache` backend was deprecated in Flask-Caching v1.10.0 and completely removed in v2.0.0. If your application relies on this backend, it will break when upgrading to v2.0.0 or later.
Fix: Migrate to an officially supported caching backend such as RedisCache, MemcachedCache, or FileSystemCache. If migration is not feasible, pin Flask-Caching to v1.9.x or older.
gotcha When caching dynamic routes (e.g., `/user/<int:user_id>`), the default cache key generation might not always produce unique keys for different parameters, potentially leading to stale or incorrect data being served. It's crucial to explicitly define a custom `make_cache_key`.
Fix: Use the `make_cache_key` argument with the `@cache.cached` decorator. Provide a function that generates a unique key based on relevant request attributes, such as `request.path`, `request.args`, or a combination of them. Example: `@cache.cached(timeout=30, make_cache_key=lambda: request.path)`.
gotcha Incorrectly configuring the `CACHE_TYPE` or its associated parameters (e.g., `CACHE_REDIS_HOST`, `CACHE_MEMCACHED_SERVERS`) is a common source of errors. Ensure the chosen backend library is installed and its configuration matches the chosen `CACHE_TYPE`.
Fix: Carefully review your `app.config` settings for Flask-Caching. Verify that `CACHE_TYPE` corresponds to the desired backend, that the necessary Python packages are installed (e.g., `redis` for RedisCache), and that all required backend-specific configuration variables are correctly set according to the Flask-Caching documentation.

Install

pip install Flask-Caching Base installation
pip install Flask-Caching[redis] With Redis backend
pip install Flask-Caching[memcached] With Memcached backend

Imports

Cache
```
from flask_caching import Cache
```

Quickstart

This quickstart demonstrates setting up Flask-Caching with a `SimpleCache` backend, caching a simple view function (`/`), and using a custom `make_cache_key` for a dynamic route (`/user/<username>`). It also includes an endpoint to clear the cache. For external backends like Redis or Memcached, ensure the respective `CACHE_TYPE` and configuration variables are set in `app.config` and the necessary dependencies are installed (e.g., `pip install Flask-Caching[redis]` and `pip install redis`).

from flask import Flask, request
from flask_caching import Cache
import datetime

app = Flask(__name__)

# Example Configuration (using SimpleCache, good for development)
# For production, consider 'RedisCache', 'MemcachedCache', etc.
app.config.from_mapping({
    "CACHE_TYPE": "SimpleCache", # Type of cache to use (e.g., SimpleCache, RedisCache, MemcachedCache)
    "CACHE_DEFAULT_TIMEOUT": 300 # Default timeout in seconds for cached items
    # For RedisCache: "CACHE_REDIS_HOST": "localhost", "CACHE_REDIS_PORT": 6379
})

cache = Cache(app)

@app.route("/")
@cache.cached(timeout=60) # Cache this view for 60 seconds
def index():
    # This part will only execute once every 60 seconds
    current_time = datetime.datetime.now().strftime("%H:%M:%S")
    return f"<h1>Hello, Flask-Caching!</h1><p>The time is: {current_time}</p><p>This page is cached.</p>"

@app.route("/reset_cache")
def reset_cache():
    cache.clear()
    return "Cache cleared!"

# Example with dynamic URL and custom cache key
@app.route("/user/<username>")
@cache.cached(timeout=30, make_cache_key=lambda: request.path)
def user_profile(username):
    # Simulate a database lookup
    import time
    time.sleep(2) 
    return f"<h2>Profile for {username}</h2><p>Data fetched at {datetime.datetime.now().strftime("%H:%M:%S")}</p>"

if __name__ == '__main__':
    app.run(debug=True)

view raw JSON →