Overview¶

Pydantic models with Redis as the storage backend

🚀 Why Redis?¶

Redis is an in-memory key-value store designed for fast caching, queues, and real-time data processing. It offers high speed, atomic operations, and excellent scalability, making it ideal for low-latency applications.

Performance Benefits

Redis provides microsecond-level latency and can handle millions of operations per second, making it perfect for real-time applications.

⚡ The Power of Pydantic¶

Pydantic has revolutionized Python data validation and serialization. There are already many libraries that use Pydantic for ORM: Beanie (MongoDB), FastAPI (HTTP server), etc. However, the current packages to support Redis are somewhat lacking.

Type Safety

Pydantic's strength lies in its automatic validation, type safety, and developer-friendly API that makes working with complex data structures intuitive and safe.

🎯 Introducing Rapyer¶

Rapyer bridges the gap between Redis's performance and Pydantic's type safety, creating a powerful combination optimized for real-world applications.

🔧 Wide Variety of Field Support¶

Rapyer supports a wide variety of field types and offers users the ability to perform complex atomic actions on these fields:

Primitive TypesCollection TypesSpecialized Types

Strings - Optimized Redis string storage
Integers - Native Redis number handling
Floats - Precise decimal operations
Booleans - Efficient boolean storage

Lists - Full atomic list operations
Dictionaries - Atomic dict updates and lookups
Sets - Redis set operations with Python interface

RedisStr - Enhanced string type with IDE autocomplete
RedisList - List type with atomic operations
RedisDict - Dictionary type with atomic operations

Custom Types

You can also create your own custom types or decide how to save the data in Redis. Other types are also supported - essentially we support any type that can be serialized to pickle, however, they can be used to perform atomic operations.

⚛️ Atomic Operations for Race Condition Prevention¶

Every operation in Rapyer is designed to be atomic and safe in concurrent environments:

Atomic Operations Example

# All operations are atomic - no race conditions possible
await user.tags.aappend("python")          # Atomic list append
await user.metadata.aupdate(role="dev")    # Atomic dict update
user.score += 10
await user.score.asave()                   # Atomic increment

Concurrency Safe

For complex multi-field operations, Rapyer provides lock context managers and pipeline operations that ensure consistency across multiple changes.

🚀 Quick Example¶

Complete Rapyer Example

import asyncio
from rapyer import AtomicRedisModel
from typing import List, Dict


class User(AtomicRedisModel):
    name: str
    age: int
    tags: List[str] = []
    metadata: Dict[str, str] = {}


async def main():
    # Create and save
    user = User(name="Alice", age=25)
    await user.asave()

    # Atomic operations
    await user.tags.aappend("developer")                    # (1)!
    await user.tags.aextend(["python", "redis"])           # (2)!
    await user.metadata.aupdate(team="backend", level="senior")  # (3)!

    # Load and verify
    loaded = await User.aget(user.key)
    print(f"User: {loaded.name}, Tags: {loaded.tags}")     # (4)!


if __name__ == "__main__":
    asyncio.run(main())

Add a single tag atomically
Extend with multiple tags in one operation
Update multiple metadata fields atomically
Load the complete model from Redis

Core Philosophy

This example demonstrates Rapyer's core philosophy: combine Redis performance with Pydantic safety, all while maintaining atomic operations that prevent data corruption in concurrent applications.

Why Choose Rapyer?¶

Comparison with Other Redis ORMs¶

Feature	Rapyer	Redis OM	pydantic-redis	orredis
🚀 Atomic Operations	✅ Built-in for all operations	❌ Manual transactions only	❌ Manual transactions only	❌ Manual transactions only
🔒 Lock Context Manager	✅ Automatic with `async with model.alock()`	❌ Manual implementation required	❌ Manual implementation required	❌ Manual implementation required
⚡ Pipeline Operations	✅ True atomic batching with `model.apipeline()`	⚠️ Basic pipeline support	❌ No pipeline support	❌ No pipeline support
🌐 Universal Type Support	✅ Native + automatic serialization for any type	⚠️ HashModel vs JsonModel limitations	⚠️ Limited complex types	⚠️ Limited complex types
🔄 Race Condition Safe	✅ Built-in prevention with Lua scripts	❌ Manual implementation required	❌ Manual implementation required	❌ Manual implementation required
📦 Redis JSON Native	✅ Optimized JSON operations	✅ Via JsonModel only	❌ Hash-based	❌ Hash-based
⚙️ Pydantic v2 Support	✅ Full compatibility	✅ Recent support	⚠️ Limited support	⚠️ Basic support
🎯 Type Safety	✅ Complete validation	✅ Good validation	✅ Good validation	⚠️ Basic validation
⚡ Performance	✅ Optimized operations	✅ Good performance	✅ Standard	✅ Rust-optimized
🔧 Nested Model Support	✅ Full Redis functionality preserved	⚠️ Limited nesting	✅ Advanced relationships	⚠️ Basic support
🎛️ Custom Primary Keys	✅ Field annotations	❌ ULIDs only	✅ Custom fields	✅ Custom fields
🧪 Extensive Test Coverage	✅ 90%+ comprehensive tests with CI	⚠️ Basic testing with CI	⚠️ Limited test coverage	⚠️ Basic test suite