https://github.com/gqylpy/funccache
True to its name, `funccache` implements the cache function. Cache the return value of a callable object or all methods defined in a class.
https://github.com/gqylpy/funccache
function-cache gqylpy python
Last synced: 6 days ago
JSON representation
True to its name, `funccache` implements the cache function. Cache the return value of a callable object or all methods defined in a class.
- Host: GitHub
- URL: https://github.com/gqylpy/funccache
- Owner: gqylpy
- License: apache-2.0
- Created: 2022-05-25T09:38:19.000Z (almost 4 years ago)
- Default Branch: master
- Last Pushed: 2024-10-10T01:13:35.000Z (over 1 year ago)
- Last Synced: 2026-01-13T17:25:25.404Z (3 months ago)
- Topics: function-cache, gqylpy, python
- Language: Python
- Homepage: http://gqylpy.com
- Size: 49.8 KB
- Stars: 91
- Watchers: 0
- Forks: 1
- Open Issues: 4
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
[
](http://gqylpy.com)
[![Release](https://img.shields.io/github/release/gqylpy/funccache.svg?style=flat-square")](https://github.com/gqylpy/funccache/releases/latest)
[](https://pypi.org/project/funccache)
[](https://github.com/gqylpy/funccache/blob/master/LICENSE)
[](https://pepy.tech/project/funccache)
# funccache
English | [中文](https://github.com/gqylpy/funccache/blob/master/README_CN.md)
`funccache`, as its name suggests, is a framework developed by the GQYLPY team that implements function caching. It can cache the return values of specific functions or all methods defined within a class.
> _What if you have a function in your program that gets called multiple times and always returns the same value? To improve code efficiency, you might call the function once, store the return value in a variable, and then use that variable instead of repeatedly calling the function. Sound familiar? That's great! But now, we're here to introduce a more elegant solution: using the `funccache` module to directly cache function return values._
`funccache` can be used in two ways: as a metaclass to cache the return values of all methods defined in its metaclass instances, or as a decorator to cache the return values of decorated functions.
pip3 install funccache
### Caching Return Values of Class Methods
```python
import funccache
class Alpha(metaclass=funccache):
...
```
In this case, all methods and `property` attributes defined in the `Alpha` class will have their return values cached in the `__cache_pool__` attribute after being called once by an instance of the class. Subsequent calls, as long as the parameters remain the same, will directly retrieve values from `__cache_pool__` without re-executing the related code, significantly reducing program overhead and improving code readability.
By default, this caching functionality only applies to individual instances, and each instance has its own `__cache_pool__` attribute. However, if you want all instances of `Alpha` to share the same cache, you can enable the `__shared_instance_cache__` attribute:
```python
class Alpha(metaclass=funccache):
__shared_instance_cache__ = True
```
Setting the class attribute `__shared_instance_cache__ = True` creates the `__cache_pool__` attribute in the `Alpha` class itself, rather than in each individual instance of `Alpha`.
The cache never expires by default, but you can set a time-to-live (TTL) for the cache using the class attribute `__ttl__`:
```python
class Alpha(metaclass=funccache):
__ttl__ = 60
```
If you want a specific method or `property` to not be cached, you can add it to the `__not_cache__` list:
```python
class Alpha(metaclass=funccache):
__not_cache__ = [method_obj_or_method_name, ...]
```
Additionally, subclasses of `Alpha` will also inherit the caching functionality.
### Caching Return Values of Functions
```python
import funccache
@funccache
def alpha():
...
```
In this case, the return value of the `alpha` function will be cached after it is called once. Subsequent calls, as long as the parameters remain the same, will directly retrieve the value from the cache without re-executing the `alpha` function.
The cache never expires by default, but if you want the cache to expire after a certain period, you can use `funccache.ttl`:
```python
@funccache.ttl(60)
def alpha():
...
```
You can even cache based on the number of calls using `funccache.count`:
```python
@funccache.count(3)
def alpha():
...
```
The decorator usage can also achieve singleton class behavior, as long as the instantiation parameters are consistent:
```python
@funccache
class Alpha:
...
```