fastapi-simple-cache 0.1.3

FastAPI Simple Cache

FastAPI Simple Cache

FastAPI Simple Cache will cache responses from a decorated endpoint if the response is JSON encodable or a FastAPI Response.

• Quick start
• Installation
• Backends
  • In memory
  • Redis
  • Firestore
• Features
  • Namespaces
  • Multi backends
  • Valid status codes
  • No cache
• License

Quick start

from fastapi import FastAPI, Request

app = FastAPI()

# Initialize in startup event
from fastapi_simple_cache import FastAPISimpleCache
from fastapi_simple_cache.backends.inmemory import InMemoryBackend
@app.on_event("startup")
async def startup():
    backend = InMemoryBackend()
    FastAPISimpleCache.init(backend=backend)
    pass

# Use the @cache decorator
from fastapi_simple_cache.decorator import cache
@app.get("/")
@cache(expire=3600)  # Set expiration in seconds
def root(request: Request):  # Add a Request typed parameter
    return {"datetime": datetime.utcnow()}

Check here for FastAPI application examples with different backends and features.

Installation

The installation depends on the backend.

• In memory: pip install fastapi-simple-cache
• Redis: pip install "fastapi-simple-cache[redis]"
• Firestore: pip install "fastapi-simple-cache[firestore]"

Backends

In memory

The InMemoryBackend class implements an in-memory backend.

from fastapi_simple_cache.backends.inmemory import InMemoryBackend

@app.on_event("startup")
async def startup():
    backend = InMemoryBackend()
    FastAPISimpleCache.init(backend=backend)

Redis

The RedisBackend class implements a Redis backend.

from redis.asyncio import ConnectionPool, client
from fastapi_simple_cache.backends.redis import RedisBackend


@app.on_event("startup")
async def startup():
    pool = ConnectionPool.from_url(url="redis://localhost:6379")
    backend = RedisBackend(redis=client.Redis(connection_pool=pool))
    FastAPISimpleCache.init(backend=backend)

Firestore

The FirestoreBackend class implements a Google Firestore backend.

import firebase_admin
from firebase_admin import firestore, credentials
from fastapi_simple_cache.backends.firestore import FirestoreBackend

@app.on_event("startup")
async def startup():
    cred = credentials.ApplicationDefault()
    firebase_admin.initialize_app(cred, {"projectId": "gcp_project"})
    db = firestore.client()
    collection = db.collection("cache_collection")
    backend = FirestoreBackend(collection=collection)
    FastAPISimpleCache.init(backend=backend)

Features

Namespaces

You can add the parameter namespace on cache initialization to modify the storage keys. Use this feature if you need to share same cache environment with other applications but with different keys.

@app.on_event("startup")
async def startup():
    backend = InMemoryBackend()
    FastAPISimpleCache.init(
        backend=backend,
        namespace="my-app"
    )
    pass

Multi backends

Use more than one backend to cache responses with the backend parameter on cache initialization. This feature is useful if you want to check an in-memory cache before an external cache.

from fastapi_simple_cache.backends.inmemory import InMemoryBackend
from fastapi_simple_cache.backends.redis import RedisBackend

@app.on_event("startup")
async def startup():
    inmem_backend = InMemoryBackend()
    redis_backend = RedisBackend(...)
    FastAPISimpleCache.init(
        backend=[inmem_backend, redis_backend]
    )
    pass

Valid status codes

Set valid status codes to cache responses in the @cache parameter status_codes (defaults to [200]).

@app.get("/")
@cache(expire=3600, status_codes=[200, 201])
def root(request: Request):
    return {"datetime": datetime.utcnow()}

No cache

Avoid storing a request/response by adding the header cache-control: no-cache to the request. This works both for the client and the server.

License

FastAPI Fire Cache is released under the GNU General Public License v3.0 or later, see here for a description of this license, or see the LICENSE file for the full text.