kpn/cachetory

Caching library with support for multiple cache backends

Cachetory

Documentation

Sneak peak

from cachetory import serializers
from cachetory.backends import async_ as async_backends
from cachetory.caches.async_ import Cache


cache = Cache[int, bytes](
    serializer=serializers.from_url("pickle://?pickle-protocol=4"),
    backend=async_backends.from_url("redis://localhost:6379"),
)

async def main() -> None:
    await cache.set("foo", 42)
    assert await cache.get("foo") == 42

cachetory's Issues

MkDocs

README.md was alright at the beginning but is now getting too big, MkDocs would serve it better.

Example:

• https://github.com/kpn/combadge/blob/main/mkdocs.yml
• https://github.com/kpn/combadge/blob/main/.github/workflows/docs.yml

Look at integration with FastAPI (decorator or middleware)

Implement JSON serializer

This may offer optional dependencies and maybe parameters to enable the non-standard serializers:

• ujson
• orjson

Maybe we'd want to implement them as different serializers since they may provide different sets of options.

Support setting a custom cache prefix

Shortcuts for common use cases

Implement MessagePack serializer

This should be as simple as calling msgpack.packb and msgpack.unpackb, maybe with a couple of optional parameters.

https://github.com/msgpack/msgpack-python

Improve the typing on `time_to_live` callable

Follow up for #33 to replace Callable[…, timedelta] with a more specific type.

Expose `clear()` method on the caches

Implement SQLite backend

It was originally requested in aiocache: aio-libs/aiocache#486. I'm not sure whether it's beneficial, but let's track the idea.

Keep in mind:

• Initializing of database schema, preferably idempotent
• Configuring of table name

Implement memcached backend

This one is not gonna be as straightforward as, for example, Redis. So I'm not sure if we want to implement it from scratch or just use something like aiomcache and adapt it to our backend protocol.

Action Required: Fix Renovate Configuration

There is an error with this repository's Renovate configuration that needs to be fixed. As a precaution, Renovate will stop PRs until it is resolved.

Error type: Cannot find preset's package (pinOnlyDevDependencies)

Implement `pydantic`-JSON serializer

That'd allow putting a model instance directly into a cache and get it stored as JSON.

Something like class PydanticJsonSerializer(Serializer[BaseModelT, bytes]), and the scheme like pydantic-json://.

Use:

• https://pydantic-docs.helpmanual.io/usage/exporting_models/#modeljson
• https://pydantic-docs.helpmanual.io/usage/models/#helper-functions

Perhaps, also forward some BaseModel.json parameters to the serializer parameters.

Implement `@cached_many`

Suggested use case:

@cached_many(cache)
def expensive_function(items: Iterable[K], …) -> Mapping[K, V]:
    …

expensive_function(["foo", "bar", "qux"], …)

Expected behaviour

expensive_function should get called only on items which aren't present in the cache. Pseudo-code:

cached_items = cache.get_many(*items)
new_items = wrapped_function(*(item for item in items if item not in cached_items), *args, **kwargs)
cache.set_many(new_items)
return {**cached_items, **new_items}

Discussion

• Should @cached_many allow specifying of the items parameter by index or keyword argument name?

Introduce stricter Mypy options and fix issues

https://mypy.readthedocs.io/en/stable/existing_code.html#introduce-stricter-options

Support sync callable in async `@cached(cache=…)`

It's been pointed out that one can't use a lambda expression in the async @cached decorator to return a Cache instance, because the decorator expects an async callable.

It should be easy to support either sync or async callable via e.g. inspect.iscoroutinefunction.

Implement a codec (?) serializer

For example, JsonSerializer would return a str, but ZstdCompressor expects a bytes. So, we'd need some layer in-between to encode/decode a string into/from bytes.

Support callable `time_to_live` for `@cached`

`Cache.__delitem__()` does not raise `KeyError` when the key is missing

Cache.__delitem__() should better conform with object.__delitem__().