FastAPI Redis Utils
Fast and easy Redis integration for FastAPI applications.
This library provides everything you need to quickly integrate Redis with FastAPI:
- RedisManager - Async Redis manager with connection pooling
- FastAPI Dependencies - Ready-to-use dependencies for Redis injection into your endpoints
- BaseRepository - CRUD operations with Pydantic models for rapid development
Perfect for caching, session storage, and data persistence in FastAPI applications.
Features
- FastAPI Integration - Ready-to-use dependencies for Redis injection
- Async Support - Full async/await capabilities
- Connection Management - Efficient connection pooling
- Monitoring - Built-in connection health checks
- Type Hints - Complete typing support
- Pydantic Models - Base repository with Pydantic support
Documentation
- Usage Guide
- FastAPI Integration Example - Complete FastAPI application with Redis integration
Installation
From PyPI
uv add fastapi-redis-utils
From Git repository
uv add git+https://github.com/serafinovsky/fastapi-redis-utils.git
Quick Start
FastAPI Integration
from contextlib import asynccontextmanager
from fastapi import FastAPI, Depends
from fastapi_redis_utils import RedisManager, create_redis_client_dependencies
import redis.asyncio as redis
# Create Redis manager
redis_manager = RedisManager(
dsn="redis://localhost:6379"
)
# Create FastAPI dependency
get_redis_client = create_redis_client_dependencies(redis_manager)
@asynccontextmanager
async def lifespan(app: FastAPI):
await redis_manager.connect()
try:
yield
finally:
await redis_manager.close()
app = FastAPI(lifespan=lifespan)
@app.get("/cache/{key}")
async def get_cached_data(key: str, redis_client: redis.Redis = Depends(get_redis_client)):
"""Get data from cache"""
value = await redis_client.get(key)
return {"key": key, "value": value}
@app.post("/cache/{key}")
async def set_cached_data(
key: str,
value: str,
redis_client: redis.Redis = Depends(get_redis_client)
):
"""Save data to cache"""
await redis_client.set(key, value)
return {"key": key, "value": value, "status": "saved"}
@app.get("/health")
async def health_check():
"""Check Redis connection status"""
is_healthy = await redis_manager.health_check()
return {"redis_healthy": is_healthy}
Using BaseRepository with Separate Create and Update Schemas
import uuid
from contextlib import asynccontextmanager
from uuid import UUID
from fastapi import HTTPException, status
from fastapi_redis_utils import BaseRepository, BaseResultModel
from fastapi import FastAPI
from fastapi_redis_utils import RedisManager
from pydantic import BaseModel
# Create Redis manager
redis_manager = RedisManager(
dsn="redis://localhost:6379"
)
@asynccontextmanager
async def lifespan(app: FastAPI):
await redis_manager.connect()
try:
yield
finally:
await redis_manager.close()
app = FastAPI(lifespan=lifespan)
class CreateDemoSchema(BaseModel):
field1: str
field2: str
class UpdateDemoSchema(BaseModel):
field1: str | None = None
field2: str | None = None
class DemoSchema(BaseResultModel):
key: str | None = None
field1: str
field2: str
def set_key(self, key: str) -> None:
self.key = key
class DemoRepository(BaseRepository[CreateDemoSchema, UpdateDemoSchema, DemoSchema]):
pass
demo_crud = DemoRepository(redis_manager, CreateDemoSchema, UpdateDemoSchema, DemoSchema)
@app.post("/repo/", response_model=DemoSchema, status_code=status.HTTP_201_CREATED)
async def create_demo(demo_model: CreateDemoSchema) -> DemoSchema:
"""Create a new demo record."""
demo_id = str(uuid.uuid4())
return await demo_crud.create(demo_id, demo_model)
@app.get("/repo/{demo_id}", response_model=DemoSchema)
async def get_demo(demo_id: UUID) -> DemoSchema:
"""Get a demo record by ID."""
demo = await demo_crud.get(str(demo_id))
if demo is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Demo record with ID '{demo_id}' not found",
)
return demo
@app.get("/repo/", response_model=list[DemoSchema])
async def list_demos(limit: int = 100) -> list[DemoSchema]:
"""List all demo records"""
return await demo_crud.list(limit=limit)
@app.put("/repo/{demo_id}", response_model=DemoSchema)
async def update_demo(demo_id: UUID, demo_update: UpdateDemoSchema) -> DemoSchema:
"""Update a demo record."""
updated_demo = await demo_crud.update(str(demo_id), demo_update)
if updated_demo is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Demo record with ID '{demo_id}' not found",
)
return updated_demo
@app.delete("/repo/{demo_id}")
async def delete_demo(demo_id: UUID) -> dict[str, UUID]:
"""Delete a demo record."""
deleted = await demo_crud.delete(str(demo_id))
if not deleted:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Demo record with ID '{demo_id}' not found",
)
return {"id": demo_id}
@app.get("/repo/{demo_id}/exists")
async def check_demo_exists(demo_id: UUID) -> dict[str, UUID | bool]:
"""Check if a demo record exists."""
exists = await demo_crud.exists(str(demo_id))
return {"id": demo_id, "exists": exists}
Configuration
RedisManager Parameters
| Parameter | Type | Default | Description |
|---|---|---|---|
dsn |
str | - |
DSN for Redis connection |
max_connections |
int | 20 |
Maximum number of connections in pool |
socket_connect_timeout |
int | 5 |
Socket connection timeout (seconds) |
socket_timeout |
int | 5 |
Socket operation timeout (seconds) |
API Reference
RedisManager
Main class for managing Redis connections.
Methods
connect()- Connect to Redisclose()- Close connection and cleanup resourceshealth_check()- Check connection statusget_client()- Get Redis client
create_redis_client_dependencies
Creates FastAPI dependency for getting Redis client.
BaseRepository
Base repository class for working with Pydantic models in Redis. Supports separate schemas for create, update, and result operations with partial updates.
Generic Parameters
CreateSchemaType- Pydantic model for create operationsUpdateSchemaType- Pydantic model for update operations (all fields optional)ResultSchemaType- Pydantic model for result operations (must inherit from BaseResultModel)
Core Methods
create(key, data: CreateSchemaType, ttl=None)- Create recordget(key)- Get record (returns ResultSchemaType)update(key, data: UpdateSchemaType, ttl=None)- Update record with partial update (only set fields)delete(key)- Delete recordexists(key)- Check record existencelist(pattern="*", limit=None)- Get list of recordscount(pattern="*")- Count recordsset_ttl(key, ttl)- Set TTLget_ttl(key)- Get TTLclear(pattern="*")- Clear records
Partial Update Feature
The update method performs partial updates - only fields that are set in the update schema will be modified. Fields with None values are ignored.
Repository initiated with serafinovsky/cookiecutter-python-package
Metadata
Release files for fastapi-redis-utils 2.0.17
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| fastapi_redis_utils-2.0.17.tar.gz | 105.3 kB | With provenance | Details for fastapi_redis_utils-2.0.17.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| fastapi_redis_utils-2.0.17-py3-none-any.whl | Python 3 | none | any | Details for fastapi_redis_utils-2.0.17-py3-none-any.whl |
Total release size: 116.5 kB
Release files / fastapi_redis_utils-2.0.17.tar.gz
| Download URL | fastapi_redis_utils-2.0.17.tar.gz |
|---|---|
| Size | 105.3 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
8d5915727d90be0c620acd976a9bee050fc987660675d9e02d90aeea64a4152e
|
|
BLAKE2b-256 checksum How to use checksums |
c21b8cc49f37c30f79417aa4093e61c61864136335d94acebad10554596a6862
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.14
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Sep 2, 2026.
Transparency logRelease files / fastapi_redis_utils-2.0.17-py3-none-any.whl
| Download URL | fastapi_redis_utils-2.0.17-py3-none-any.whl |
|---|---|
| Size | 11.3 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
bc4fa56a1c9f2e91bba1c53f554aabad8939601e5edcd77c8abf10210ddc1029
|
|
BLAKE2b-256 checksum How to use checksums |
130aec13cc8575c7b9a28e6219ebb4276e0c63585c4fde465c3f3421ecbc32cc
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.14
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Sep 2, 2026.
Transparency logSecurity for fastapi-redis-utils 2.0.17
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
Full provenance
Both files in this release have been uploaded with provenance metadata.
Attestation for fastapi_redis_utils-2.0.17.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Sep 2, 2026.
Transparency logA note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.