Warning
The new version v6 has incompatibilities with v5. For more info see Migration Guide.
You can easily perform powerful caching operations in Python as fast as possible. This can make your application a lot faster and it can be a good choice in complex applications. Ideal for optimizing large-scale applications with efficient, low-overhead caching.
Key Features:
- 🚀 Extremely fast (10-50x faster than other caching libraries - benchmarks)
- 📊 Minimal memory footprint
- 🔥 Full-featured and user-friendly
- 🧶 Completely thread-safe
- 🔧 Tested and correct
- [R] written in Rust for maximum performance
- 🤝 Compatible with Python 3.10+ (PyPy and CPython)
- 📦 Supports 7 advanced caching algorithms
📈 Frequent Data Access
If you need to access the same data multiple times, caching can help reduce the number of database queries or API calls, improving performance.💎 Expensive Operations
If you have operations that are computationally expensive, caching can help reduce the number of times these operations need to be performed.🚗 High Traffic Scenarios
If your application handles high traffic, caching can help reduce the load on your server by reducing the number of requests that need to be processed.#️⃣ Web Page Rendering
If you are rendering web pages, caching can help reduce the time it takes to generate the page by caching the results of expensive rendering operations. Caching HTML pages can speed up the delivery of static content.🚧 Rate Limiting
If you have a rate limiting system in place, caching can help reduce the number of requests that need to be processed by the rate limiter. Also, caching can help you to manage rate limits imposed by third-party APIs by reducing the number of requests sent.🤖 Machine Learning Models
If your application frequently makes predictions using the same input data, caching the results can save computation time.
⚡ Rust
It uses the Rust language for high-performance.🧮 SwissTable
It uses Google's high-performance SwissTable hash map. Thanks to hashbrown.✨ Low memory usage
It has very low memory usage.⭐ Zero Dependency
As we said,cacheboxis written in Rust so you don't have to install any other dependencies.🧶 Thread safe
It's completely thread-safe and uses Rust mutex to prevent problems.👌 Easy To Use
You only need to import it and choose a cache implementation to use.🚫 Avoids Cache Stampede
It avoids cache stampede by using a distributed lock system.
cachebox is installable via pip:
pip3 install -U cacheboxThe simplest example of cachebox could look like this:
importcachebox@cachebox.cached(cachebox.FIFOCache(maxsize=128))deffactorial(number: int) ->int:
fact=1fornuminrange(2, number+1):
fact*=numreturnfactassertfactorial(5) ==125# coroutines are also supported@cachebox.cached(cachebox.LRUCache(maxsize=128))asyncdefmake_request(method: str, url: str) ->dict:
response=awaitclient.request(method, url)
returnresponse.json()Unlike functools.lru_cache and other caching libraries, cachebox can copy dict, list, and set objects.
@cachebox.cached(cachebox.LRUCache(maxsize=128))defmake_dict(name: str, age: int) ->dict:
return {"name": name, "age": age}
>d=make_dict("cachebox", 10)
assertd== {"name": "cachebox", "age": 10}
d["new-key"] ="new-value"d2=make_dict("cachebox", 10)
# `d2` will be `{"name": "cachebox", "age": 10, "new-key": "new-value"}` if you use other librariesassertd2== {"name": "cachebox", "age": 10}You can use cache algorithms without the cached decorator -- just import the cache algorithm you want and use it like a dictionary.
fromcacheboximportFIFOCachecache=FIFOCache(maxsize=128)
cache["key"] ="value"assertcache["key"] =="value"# You can also use `cache.get(key, default)`assertcache.get("key") =="value"Read the documentation for full information and learn more: Documentation
This repository is licensed under the MIT License