- Now the cached function can accept a function as cache, allowing it to replace cachedmethod function.

  Also this can give you more control.
- `cachedmethod` decorator deprected due to [#35](#35)

Author: awolverp

CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v5.1.0 - 2025-10-31
+### Changed
+- Now the `cached` function can accept a function as `cache`, allowing it to replace `cachedmethod` function.
+  Also this can give you more control.
+
+### Deprecated
+- `cachedmethod` decorator deprected due to [#35](https://github.com/awolverp/cachebox/issues/35)
+
+### Thanks
+- Special thanks to [@liblaf](https://github.com/liblaf)
+
 ## v5.0.4 - 2025-10-20
 ### Changed
 - Support all platforms for Python 3.14, 3.14t and 3.13t (#34; thanks to @chirizxc)

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cachebox"
-version = "5.0.4"
+version = "5.1.0"
 edition = "2021"
 description = "The fastest memoizing and caching Python library written in Rust"
 readme = "README.md"

Cargo.toml

@@ -267,13 +267,14 @@ def make_typed_key(args: tuple, kwds: dict):
 
 def _cached_wrapper(
     func,
-    cache: BaseCacheImpl,
+    cache: typing.Union[BaseCacheImpl, typing.Callable],
     key_maker: typing.Callable[[tuple, dict], typing.Hashable],
     clear_reuse: bool,
     callback: typing.Optional[typing.Callable[[int, typing.Any, typing.Any], typing.Any]],
     copy_level: int,
     is_method: bool,
 ):
+    is_method = cache_is_function = inspect.isfunction(cache)
     _key_maker = (lambda args, kwds: key_maker(args[1:], kwds)) if is_method else key_maker
 
     hits = 0
@@ -287,11 +288,12 @@ def _wrapped(*args, **kwds):
         if kwds.pop("cachebox__ignore", False):
             return func(*args, **kwds)
 
+        _cache = cache(args[0]) if cache_is_function else cache
         key = _key_maker(args, kwds)
 
         # try to get result from cache
         try:
-            result = cache[key]
+            result = _cache[key]
         except KeyError:
             pass
         else:
@@ -310,7 +312,7 @@ def _wrapped(*args, **kwds):
                 raise cached_error
 
             try:
-                result = cache[key]
+                result = _cache[key]
                 hits += 1
                 event = EVENT_HIT
             except KeyError:
@@ -323,7 +325,7 @@ def _wrapped(*args, **kwds):
                     raise e
 
                 else:
-                    cache[key] = result
+                    _cache[key] = result
                     misses += 1
                     event = EVENT_MISS
 
@@ -332,34 +334,39 @@ def _wrapped(*args, **kwds):
 
         return _copy_if_need(result, level=copy_level)
 
-    _wrapped.cache = cache
+    if not cache_is_function:
+        _wrapped.cache = cache
+        _wrapped.cache_info = lambda: CacheInfo(
+            hits, misses, cache.maxsize, len(cache), cache.capacity()
+        )
+
     _wrapped.callback = callback
-    _wrapped.cache_info = lambda: CacheInfo(
-        hits, misses, cache.maxsize, len(cache), cache.capacity()
-    )
 
-    def cache_clear() -> None:
-        nonlocal misses, hits, locks, exceptions
-        cache.clear(reuse=clear_reuse)
-        misses = 0
-        hits = 0
-        locks.clear()
-        exceptions.clear()
+    if not cache_is_function:
+
+        def cache_clear() -> None:
+            nonlocal misses, hits, locks, exceptions
+            cache.clear(reuse=clear_reuse)
+            misses = 0
+            hits = 0
+            locks.clear()
+            exceptions.clear()
 
-    _wrapped.cache_clear = cache_clear
+        _wrapped.cache_clear = cache_clear
 
     return _wrapped
 
 
 def _async_cached_wrapper(
     func,
-    cache: BaseCacheImpl,
+    cache: typing.Union[BaseCacheImpl, typing.Callable],
     key_maker: typing.Callable[[tuple, dict], typing.Hashable],
     clear_reuse: bool,
     callback: typing.Optional[typing.Callable[[int, typing.Any, typing.Any], typing.Any]],
     copy_level: int,
     is_method: bool,
 ):
+    is_method = cache_is_function = inspect.isfunction(cache)
     _key_maker = (lambda args, kwds: key_maker(args[1:], kwds)) if is_method else key_maker
 
     hits = 0
@@ -375,11 +382,12 @@ async def _wrapped(*args, **kwds):
         if kwds.pop("cachebox__ignore", False):
             return await func(*args, **kwds)
 
+        _cache = cache(args[0]) if cache_is_function else cache
         key = _key_maker(args, kwds)
 
         # try to get result from cache
         try:
-            result = cache[key]
+            result = _cache[key]
         except KeyError:
             pass
         else:
@@ -400,7 +408,7 @@ async def _wrapped(*args, **kwds):
                 raise cached_error
 
             try:
-                result = cache[key]
+                result = _cache[key]
                 hits += 1
                 event = EVENT_HIT
             except KeyError:
@@ -413,7 +421,7 @@ async def _wrapped(*args, **kwds):
                     raise e
 
                 else:
-                    cache[key] = result
+                    _cache[key] = result
                     misses += 1
                     event = EVENT_MISS
 
@@ -424,21 +432,25 @@ async def _wrapped(*args, **kwds):
 
         return _copy_if_need(result, level=copy_level)
 
-    _wrapped.cache = cache
+    if not cache_is_function:
+        _wrapped.cache = cache
+        _wrapped.cache_info = lambda: CacheInfo(
+            hits, misses, cache.maxsize, len(cache), cache.capacity()
+        )
+
     _wrapped.callback = callback
-    _wrapped.cache_info = lambda: CacheInfo(
-        hits, misses, cache.maxsize, len(cache), cache.capacity()
-    )
 
-    def cache_clear() -> None:
-        nonlocal misses, hits, locks, exceptions
-        cache.clear(reuse=clear_reuse)
-        misses = 0
-        hits = 0
-        locks.clear()
-        exceptions.clear()
+    if not cache_is_function:
 
-    _wrapped.cache_clear = cache_clear
+        def cache_clear() -> None:
+            nonlocal misses, hits, locks, exceptions
+            cache.clear(reuse=clear_reuse)
+            misses = 0
+            hits = 0
+            locks.clear()
+            exceptions.clear()
+
+        _wrapped.cache_clear = cache_clear
 
     return _wrapped
 
@@ -456,7 +468,8 @@ def cached(
     Wraps a function to automatically cache and retrieve its results based on input parameters.
 
     Args:
-        cache (BaseCacheImpl, dict, optional): Cache implementation to store results. Defaults to FIFOCache.
+        cache (BaseCacheImpl, dict, callable): Cache implementation to store results. Defaults to FIFOCache.
+                                               Can be a function that got `self` and should return cache.
         key_maker (Callable, optional): Function to generate cache keys from function arguments. Defaults to make_key.
         clear_reuse (bool, optional): Whether to reuse cache during clearing. Defaults to False.
         callback (Callable, optional): Function called on cache hit/miss events. Defaults to None.
@@ -465,7 +478,7 @@ def cached(
     Returns:
         Callable: Decorated function with caching capabilities.
 
-    Example::
+    Example for functions::
 
         @cachebox.cached(cachebox.LRUCache(128))
         def sum_as_string(a, b):
@@ -476,15 +489,29 @@ def sum_as_string(a, b):
         assert len(sum_as_string.cache) == 1
         sum_as_string.cache_clear()
         assert len(sum_as_string.cache) == 0
+
+    Example for methods::
+
+        class A:
+            def __init__(self, num):
+                self.num = num
+                self._cache = cachebox.FIFOCache(0)
+
+            @cachebox.cached(lambda self: self._cache)
+            def method(self, n):
+                return self.num * n
+
+        instance = A(10)
+        assert A.method(2) == 20
     """
     if cache is None:
         cache = FIFOCache(0)
 
     if type(cache) is dict:
         cache = FIFOCache(0, cache)
 
-    if not isinstance(cache, BaseCacheImpl):
-        raise TypeError("we expected cachebox caches, got %r" % (cache,))
+    if not isinstance(cache, BaseCacheImpl) and not inspect.isfunction(cache):
+        raise TypeError("we expected cachebox caches or function, got %r" % (cache,))
 
     def decorator(func: FT) -> FT:
         if inspect.iscoroutinefunction(func):
@@ -509,6 +536,9 @@ def cachedmethod(
     copy_level: int = 1,
 ) -> typing.Callable[[FT], FT]:
     """
+    **This function is deperecated due to issue [#35](https://github.com/awolverp/cachebox/issues/35)**.
+    Use `cached` method instead.
+
     Decorator to create a method-specific memoized cache for function results.
 
     Similar to `cached()`, but ignores `self` parameter when generating cache keys.
@@ -523,6 +553,14 @@ def cachedmethod(
     Returns:
         Callable: Decorated method with method-specific caching capabilities.
     """
+    import warnings
+
+    warnings.warn(
+        "cachedmethod is deprecated, use cached instead. see issue https://github.com/awolverp/cachebox/issues/35",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
     if cache is None:
         cache = FIFOCache(0)
 

python/cachebox/utils.py

@@ -1,10 +1,10 @@
 from cachebox import (
     Frozen,
     LRUCache,
+    TTLCache,
     cached,
     make_typed_key,
     make_key,
-    cachedmethod,
     EVENT_HIT,
     EVENT_MISS,
     is_cached,
@@ -151,22 +151,25 @@ class TestCachedMethod:
         def __init__(self, num) -> None:
             self.num = num
 
-        @cachedmethod(None)
+        @cached(None)
         def method(self, char: str):
             assert type(self) is TestCachedMethod
             return char * self.num
 
     cls = TestCachedMethod(10)
     assert cls.method("a") == ("a" * 10)
 
+    cls = TestCachedMethod(2)
+    assert cls.method("a") == ("a" * 2)
+
 
 @pytest.mark.asyncio
 async def test_async_cachedmethod():
     class TestCachedMethod:
         def __init__(self, num) -> None:
             self.num = num
 
-        @cachedmethod(LRUCache(0))
+        @cached(LRUCache(0))
         async def method(self, char: str):
             assert type(self) is TestCachedMethod
             return char * self.num
@@ -302,3 +305,19 @@ def new(num: int):
 
     a = MyClass.new(1)
     assert isinstance(a, int) and a == 1
+
+
+def test_new_cached_method():
+    class Test:
+        def __init__(self, num) -> None:
+            self.num = num
+            self._cache = TTLCache(20, 10)
+
+        @cached(lambda self: self._cache)
+        def method(self, char: str):
+            assert type(self) is Test
+            return char * self.num
+
+    for i in range(10):
+        cls = Test(i)
+        assert cls.method("a") == ("a" * i)

python/tests/test_utils.py

@@ -3,7 +3,10 @@ use crate::common::ObservedIterator;
 use crate::common::PreHashObject;
 
 #[cfg_attr(Py_3_9, pyo3::pyclass(module = "cachebox._core", frozen))]
-#[cfg_attr(not(Py_3_9), pyo3::pyclass(module = "cachebox._core", frozen, immutable_type))]
+#[cfg_attr(
+    not(Py_3_9),
+    pyo3::pyclass(module = "cachebox._core", frozen, immutable_type)
+)]
 pub struct Cache {
     raw: crate::common::Mutex<crate::policies::nopolicy::NoPolicy>,
 }

src/bridge/cache.rs

@@ -3,7 +3,10 @@ use crate::common::ObservedIterator;
 use crate::common::PreHashObject;
 
 #[cfg_attr(Py_3_9, pyo3::pyclass(module = "cachebox._core", frozen))]
-#[cfg_attr(not(Py_3_9), pyo3::pyclass(module = "cachebox._core", frozen, immutable_type))]
+#[cfg_attr(
+    not(Py_3_9),
+    pyo3::pyclass(module = "cachebox._core", frozen, immutable_type)
+)]
 pub struct FIFOCache {
     raw: crate::common::Mutex<crate::policies::fifo::FIFOPolicy>,
 }

src/bridge/fifocache.rs

@@ -3,7 +3,10 @@ use crate::common::ObservedIterator;
 use crate::common::PreHashObject;
 
 #[cfg_attr(Py_3_9, pyo3::pyclass(module = "cachebox._core", frozen))]
-#[cfg_attr(not(Py_3_9), pyo3::pyclass(module = "cachebox._core", frozen, immutable_type))]
+#[cfg_attr(
+    not(Py_3_9),
+    pyo3::pyclass(module = "cachebox._core", frozen, immutable_type)
+)]
 pub struct LFUCache {
     raw: crate::common::Mutex<crate::policies::lfu::LFUPolicy>,
 }

src/bridge/lfucache.rs

@@ -3,7 +3,10 @@ use crate::common::ObservedIterator;
 use crate::common::PreHashObject;
 
 #[cfg_attr(Py_3_9, pyo3::pyclass(module = "cachebox._core", frozen))]
-#[cfg_attr(not(Py_3_9), pyo3::pyclass(module = "cachebox._core", frozen, immutable_type))]
+#[cfg_attr(
+    not(Py_3_9),
+    pyo3::pyclass(module = "cachebox._core", frozen, immutable_type)
+)]
 pub struct LRUCache {
     raw: crate::common::Mutex<crate::policies::lru::LRUPolicy>,
 }