AioCache

0.12.3 · active · verified Thu Apr 09

aiocache is a multi-backend asynchronous cache library for Python, providing support for Redis, Memcached, and in-memory caching. It integrates well with asyncio applications. The current version is 0.12.3, and it receives regular patch updates, with minor versions released periodically.

Warnings

breaking Breaking change: aiocache migrated from `aioredis` to the official `redis` Python library. Existing code using `aioredis` specific APIs or directly importing `aioredis` backend classes will break.
Fix: Ensure `pip install aiocache[redis]` is used. Update any imports or direct usage of `aioredis` client methods to align with the `redis` library's API. For `Cache` factory, connection parameters might need review.
breaking Breaking change: The `SimpleMemoryBackend` (and `SimpleMemoryCache`) is no longer a global singleton. Each instance now has its own isolated cache.
Fix: If your application relied on `SimpleMemoryBackend` instances sharing a global state, you will need to refactor to pass a single `SimpleMemoryCache` instance around or adapt to its new instance-scoped behavior.
deprecated Deprecated `loop` parameters have been removed from most methods and constructors, including `Cache.create()`. Passing an explicit `loop` will now raise an error.
Fix: Remove the `loop` parameter from all `aiocache` calls. `aiocache` now relies on `asyncio`'s default event loop mechanisms.
gotcha Typing support was removed in `v0.12.1` due to issues and is planned to be re-introduced in `v1.0`. Users expecting comprehensive type hints will find them missing or causing unresolvable errors.
Fix: Do not rely on `aiocache` for strict type checking until `v1.0`. Temporarily, you might need to use `# type: ignore` for specific `aiocache` related lines if your linter complains.

Install

pip install aiocache[redis,memcached] Install with Redis and Memcached backends
pip install aiocache Install base (in-memory cache only)

Imports

Cache
```
from aiocache import Cache
```
cached
```
from aiocache.cached import cached
```
RedisCache
```
from aiocache.backends.redis import RedisCache
```
As of v0.12.0, aiocache migrated from aioredis to the official redis library.

MemcachedCache

from aiocache.backends.memcached import MemcachedCache

SimpleMemoryCache

from aiocache.backends.memory import SimpleMemoryCache

Quickstart

This quickstart demonstrates how to initialize and use the Redis backend with `aiocache` using the `Cache` factory. It leverages `async with` for automatic connection management and shows setting and getting a key-value pair. Ensure a Redis server is running and accessible.

import asyncio
import os
from aiocache import Cache

async def main():
    # Configure Redis cache using environment variables or fallbacks
    redis_endpoint = os.environ.get('REDIS_ENDPOINT', 'localhost')
    redis_port = int(os.environ.get('REDIS_PORT', '6379'))

    # Use async with for proper resource management (auto-closes connection)
    async with Cache(Cache.REDIS, endpoint=redis_endpoint, port=redis_port) as cache:
        key = "my_async_key"
        value = "hello from aiocache"
        ttl_seconds = 60

        print(f"Setting '{key}' = '{value}' with TTL {ttl_seconds}s")
        await cache.set(key, value, ttl=ttl_seconds)

        retrieved_value = await cache.get(key)
        print(f"Retrieved value for '{key}': {retrieved_value}")

        if retrieved_value == value:
            print("Value successfully cached and retrieved!")
        else:
            print("Cache retrieval failed.")

if __name__ == '__main__':
    # Ensure Redis server is running at REDIS_ENDPOINT:REDIS_PORT
    # e.g., docker run --name some-redis -p 6379:6379 -d redis
    asyncio.run(main())

view raw JSON →