Cachey: Caching for Analytic Computations

0.2.1 · maintenance · verified Thu Apr 16

Cachey is a Python library from Dask designed for caching in analytic computations where the costs of recomputation and storage can vary significantly. Unlike traditional caching policies (e.g., LRU), Cachey is mindful of these varying costs. The latest PyPI version is 0.2.1, released in March 2020. The project README states it is 'new and not robust'.

Common errors

```
Unexpected cache misses or stale data when using @cache.memoize
```
cause The `key` parameter in `@cache.memoize` might not fully represent all differentiating inputs to the function, leading to cache collisions or incorrect retrieval. Alternatively, the cache eviction policy might be removing items prematurely due to incorrect `cost` estimation.

fix Ensure the `key` argument of `@cache.memoize` is a unique identifier derived from all relevant function inputs. For example, if a function takes multiple arguments, combine them into a tuple for the key. Re-evaluate the `cost` parameter to accurately reflect the relative expense (computation + storage) of recomputing and storing the function's output.
```
MemoryError: Cannot allocate memory for cache
```
cause The `Cache` object is initialized with a `nbytes` parameter (total memory limit) that is too large for the available system memory, or the `cost` attributed to cached items is underestimated, causing the cache to attempt to store more data than it can hold or than the system can provide.

fix Reduce the initial `nbytes` value passed to the `Cache` constructor. Profile the actual memory usage of the objects being cached and adjust the `cost` parameter in `@cache.memoize` to better reflect their true memory footprint. Monitor system memory usage to identify if other processes are competing for resources.

Warnings

gotcha The official GitHub README for Cachey explicitly states: 'Cachey is new and not robust.' Users should be aware that the library might have unaddressed issues or lack full stability, and it may not be suitable for critical production systems without thorough testing.
Fix: Thoroughly test `cachey` in your specific use case. Consider alternative, more mature caching libraries for robust production environments if stability is a primary concern.
deprecated The last release of Cachey (v0.2.1) was on March 11, 2020. This indicates a lack of active development and maintenance, which may lead to unpatched bugs, security vulnerabilities, or incompatibility with newer Python versions or related libraries.
Fix: Review the project's GitHub repository for any recent activity not reflected in PyPI releases. For new projects, evaluate more actively maintained caching solutions. If using Cachey, be prepared to address potential compatibility issues or maintain the code yourself.

Install

pip install cachey Install latest version

Imports

Cache
```
from cachey import Cache
```

Quickstart

This example demonstrates how to initialize `Cachey` with a memory limit and use the `@cache.memoize` decorator to cache the results of an expensive function. The `key` and `cost` parameters help Cachey manage its eviction policy effectively.

from cachey import Cache
from time import sleep

# Initialize a cache with a 2 GB limit
cache = Cache(2 * 10**9) 

@cache.memoize(key='my-expensive-function', cost=100) # Define key and estimated cost
def my_expensive_function(x):
    print(f"Computing for {x}...")
    sleep(0.1) # Simulate expensive computation
    return x + 1

# First call will compute and cache
result1 = my_expensive_function(1)
print(f"Result 1: {result1}")

# Second call with same arguments will retrieve from cache
result2 = my_expensive_function(1)
print(f"Result 2: {result2}")

# Call with different arguments will compute and cache separately
result3 = my_expensive_function(2)
print(f"Result 3: {result3}")

view raw JSON →