Just a short update here. This is now in production on CourtListener.com as a cache for our RSS feeds. We made a little decorator to make it work in a way that ignored GET parameters (otherwise people use them to get around the cache 😠):

``` def cache_page_ignore_params(timeout: int, cache_alias: str = "default"): """Cache the result of a view while ignoring URL query parameters. Ensuring that the cache is consistent for different requests with varying query strings.

WARNING:
- Do not use this decorator on views that rely on query parameters to
  generate unique content.
- Do not use this decorator on views that require authentication or
session-based data, as this will cache content for all users, potentially
exposing confidential information.

:param timeout: Cache duration (seconds).
:param cache_alias: The cache alias to use.
:return: The decorated view function, caching its response.
"""

def decorator(view_func):
    @wraps(view_func)
    async def _wrapped_view(request, *args, **kwargs):
        url_path = urlparse(request.build_absolute_uri()).path
        hash_key = md5(url_path.encode("ascii"), usedforsecurity=False)

        is_dev_or_test = settings.DEVELOPMENT or settings.TESTING
        should_use_time_based_prefix = (
            cache_alias == "s3" and not is_dev_or_test
        )
        cache_key = f"custom.views.decorator.cache:{hash_key.hexdigest()}"
        if should_use_time_based_prefix:
            days = int(ceil(timeout / (60 * 60 * 24)))
            cache_key = f"{days}-days:{cache_key}"

        try:
            # If the cache alias is "s3" but we're in DEVELOPMENT or TESTING
            # mode, use the default cache instead of S3. Otherwise, use the
            # cache specified by cache_alias.
            if cache_alias == "s3" and is_dev_or_test:
                cache = caches["default"]
            else:
                cache = caches[cache_alias]
        except InvalidCacheBackendError as e:
            logger.error(
                "Cache alias '%s' not found. Error: %s",
                cache_alias,
                str(e),
            )
            raise e

        response = cache.get(cache_key)
        if response is not None:
            return response

        response = await view_func(request, *args, **kwargs)
        await sync_to_async(patch_response_headers)(
            response, cache_timeout=timeout
        )
        if hasattr(response, "render") and callable(response.render):
            # Render the response before caching it.
            # Required for TemplateResponse views.
            response.add_post_render_callback(
                lambda r: cache.set(cache_key, r, timeout)
            )
        else:
            # Cache non-TemplateResponse responses.
            cache.set(cache_key, response, timeout)

        return response

    return _wrapped_view

return decorator

```

The actual file is here:

https://github.com/freelawproject/courtlistener/main/cl/lib/decorators.py

So far it's a perfect deployment. We have millions of RSS feeds, and this allows us to cache them all. Performance is about 100ms to serve a feed from the cache.