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.
pip install Flask-CachingVerified import paths — ran on the pinned version, not inferred.
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`).
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`).
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.
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.
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)`.
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.
Review and correct the f-string syntax in the test script (e.g., use single quotes for inner strings within a double-quoted f-string, or escape inner quotes). Example: change `strftime("%H:%M:%S")` to `strftime('%H:%M:%S')`.Ensure that the Flask application instance (`app`) is fully initialized before passing it to the `Cache` constructor or calling `cache.init_app(app)`. If using an application factory, pass the `app` instance to `init_app` *after* the `app` has been created. For Dash apps, remember to pass `app.server` to `init_app` instead of `app` directly.
```python
from flask import Flask
from flask_caching import Cache
# Method 1: Pass app during instantiation
app = Flask(__name__)
app.config.from_mapping({
"CACHE_TYPE": "SimpleCache",
"CACHE_DEFAULT_TIMEOUT": 300
})
cache = Cache(app=app) # or Cache(app)
# Method 2: Using init_app (recommended for app factories)
# cache = Cache()
# def create_app():
# app = Flask(__name__)
# app.config.from_mapping({
# "CACHE_TYPE": "SimpleCache",
# "CACHE_DEFAULT_TIMEOUT": 300
# })
# cache.init_app(app)
# return app
# For Dash applications:
# from dash import Dash
# app = Dash(__name__)
# cache = Cache()
# cache.init_app(app.server)
```First, ensure `flask-caching` is installed correctly in your environment using pip: `pip install Flask-Caching`. If it's installed but still not found, check your Python environment or virtual environment. If the error refers to `flask.ext.cache`, update your import statements to `from flask_caching import Cache` (for the main Cache class) or `from flask_caching import make_template_fragment_key` (for other utilities).
```python
# Incorrect (old/deprecated):
# from flask.ext.cache import Cache
# Correct:
from flask_caching import Cache
# Example usage:
# from flask import Flask
# app = Flask(__name__)
# cache = Cache(app=app, config={'CACHE_TYPE': 'SimpleCache'})
```For production environments or any setup using multiple worker processes, switch to a distributed caching backend like RedisCache or MemcachedCache. For local development or simple single-process applications, `FileSystemCache` can also be a viable alternative to `SimpleCache` to persist cache across restarts.
```python
# For RedisCache (requires 'redis' library and a running Redis server):
app.config.from_mapping({
"CACHE_TYPE": "RedisCache",
"CACHE_REDIS_URL": "redis://localhost:6379/0", # Adjust as needed
"CACHE_DEFAULT_TIMEOUT": 300
})
# For FileSystemCache (requires a directory for cache files):
# app.config.from_mapping({
# "CACHE_TYPE": "FileSystemCache",
# "CACHE_DIR": "/tmp/flask_cache", # Ensure this directory exists and is writable
# "CACHE_DEFAULT_TIMEOUT": 300
# })
# cache = Cache(app)
```Ensure the Redis server is running and accessible from your application's host and port. Verify the `CACHE_REDIS_HOST`, `CACHE_REDIS_PORT`, and `CACHE_REDIS_DB` configurations are correct. When using a password, it is best practice to include it directly within the `CACHE_REDIS_URL` or ensure `CACHE_REDIS_PASSWORD` is correctly configured *without* a conflicting `CACHE_REDIS_URL` that doesn't include the password.
```python
# If using separate host/port/password configs:
app.config.from_mapping({
"CACHE_TYPE": "RedisCache",
"CACHE_REDIS_HOST": "your_redis_host",
"CACHE_REDIS_PORT": 6379, # Default Redis port
"CACHE_REDIS_DB": 0,
"CACHE_REDIS_PASSWORD": "your_redis_password", # Only if required
"CACHE_DEFAULT_TIMEOUT": 300
})
# Preferred: Using CACHE_REDIS_URL with embedded password if applicable:
# app.config.from_mapping({
# "CACHE_TYPE": "RedisCache",
# "CACHE_REDIS_URL": "redis://:your_redis_password@your_redis_host:6379/0",
# "CACHE_DEFAULT_TIMEOUT": 300
# })
# Ensure 'redis' package is installed: pip install redis
```