cachebox 5.0.4__cp313-cp313t-macosx_11_0_arm64.whl → 5.2.1__cp313-cp313t-macosx_11_0_arm64.whl

cachebox/_cachebox.py

@@ -1,9 +1,9 @@
-from . import _core
-from ._core import BaseCacheImpl
-from datetime import timedelta, datetime
 import copy as _std_copy
 import typing
+from datetime import datetime, timedelta
 
+from . import _core
+from ._core import BaseCacheImpl
 
 KT = typing.TypeVar("KT")
 VT = typing.TypeVar("VT")
@@ -75,6 +75,7 @@ class Cache(BaseCacheImpl[KT, VT]):
         iterable: typing.Union[dict, typing.Iterable[tuple], None] = None,
         *,
         capacity: int = 0,
+        maxmemory: int = 0,
     ) -> None:
         """
         Initialize a new Cache instance.
@@ -83,11 +84,14 @@ class Cache(BaseCacheImpl[KT, VT]):
             maxsize (int): Maximum number of elements the cache can hold. Zero means unlimited.
             iterable (Union[Cache, dict, tuple, Generator, None], optional): Initial data to populate the cache. Defaults to None.
             capacity (int, optional): Pre-allocate hash table capacity to minimize reallocations. Defaults to 0.
+            maxmemory (int, optional): Maximum memory (bytes) allowed for cached entries. Zero means unlimited.
+                                       On PyPy, it works same as `maxsize` if objects do not support `__sizeof__`
+                                       method.
 
         Creates a new cache with specified size constraints and optional initial data. The cache can be pre-sized
         to improve performance when the number of expected elements is known in advance.
         """
-        self._raw = _core.Cache(maxsize, capacity=capacity)
+        self._raw = _core.Cache(maxsize, capacity=capacity, maxmemory=maxmemory)
 
         if iterable is not None:
             self.update(iterable)
@@ -96,10 +100,18 @@ class Cache(BaseCacheImpl[KT, VT]):
     def maxsize(self) -> int:
         return self._raw.maxsize()
 
+    @property
+    def maxmemory(self) -> int:
+        return self._raw.maxmemory()
+
     def capacity(self) -> int:
         """Returns the number of elements the map can hold without reallocating."""
         return self._raw.capacity()
 
+    def memory(self) -> int:
+        """Returns the total estimated memory usage of cached entries in bytes."""
+        return self._raw.memory()
+
     def __len__(self) -> int:
         return len(self._raw)
 
@@ -309,6 +321,7 @@ class FIFOCache(BaseCacheImpl[KT, VT]):
         iterable: typing.Union[typing.Union[dict, typing.Iterable[tuple]], None] = None,
         *,
         capacity: int = 0,
+        maxmemory: int = 0,
     ) -> None:
         """
         Initialize a new FIFOCache instance.
@@ -318,8 +331,11 @@ class FIFOCache(BaseCacheImpl[KT, VT]):
             iterable: Optional initial data to populate the cache. Can be another FIFOCache,
                       a dictionary, tuple, generator, or None.
             capacity: Optional initial capacity of the cache before resizing. Defaults to 0.
+            maxmemory: Maximum memory (bytes) allowed for cached entries. Zero means unlimited.
+                       When maxmemory is set, updating an existing key can evict the updated key
+                       if it is the oldest entry.
         """
-        self._raw = _core.FIFOCache(maxsize, capacity=capacity)
+        self._raw = _core.FIFOCache(maxsize, capacity=capacity, maxmemory=maxmemory)
 
         if iterable is not None:
             self.update(iterable)
@@ -328,10 +344,18 @@ class FIFOCache(BaseCacheImpl[KT, VT]):
     def maxsize(self) -> int:
         return self._raw.maxsize()
 
+    @property
+    def maxmemory(self) -> int:
+        return self._raw.maxmemory()
+
     def capacity(self) -> int:
         """Returns the number of elements the map can hold without reallocating."""
         return self._raw.capacity()
 
+    def memory(self) -> int:
+        """Returns the total estimated memory usage of cached entries in bytes."""
+        return self._raw.memory()
+
     def __len__(self) -> int:
         return len(self._raw)
 
@@ -567,6 +591,7 @@ class RRCache(BaseCacheImpl[KT, VT]):
         iterable: typing.Union[typing.Union[dict, typing.Iterable[tuple]], None] = None,
         *,
         capacity: int = 0,
+        maxmemory: int = 0,
     ) -> None:
         """
         Initialize a new RRCache instance.
@@ -575,12 +600,16 @@ class RRCache(BaseCacheImpl[KT, VT]):
             maxsize (int): Maximum size of the cache. A value of zero means unlimited capacity.
             iterable (dict or Iterable[tuple], optional): Initial data to populate the cache. Defaults to None.
             capacity (int, optional): Preallocated capacity for the cache to minimize reallocations. Defaults to 0.
+            maxmemory (int, optional): Maximum memory (bytes) allowed for cached entries. Zero means unlimited.
+                                       When maxmemory is set, updates can evict any key, including the updated key.
+                                       On PyPy. In PyPy, the size of each object is assumed to be 1 if the object
+                                       does not have a `__sizeof__` method.
 
         Note:
             - The cache size limit is immutable after initialization.
             - If an iterable is provided, the cache will be populated using the update method.
         """
-        self._raw = _core.RRCache(maxsize, capacity=capacity)
+        self._raw = _core.RRCache(maxsize, capacity=capacity, maxmemory=maxmemory)
 
         if iterable is not None:
             self.update(iterable)
@@ -589,10 +618,18 @@ class RRCache(BaseCacheImpl[KT, VT]):
     def maxsize(self) -> int:
         return self._raw.maxsize()
 
+    @property
+    def maxmemory(self) -> int:
+        return self._raw.maxmemory()
+
     def capacity(self) -> int:
         """Returns the number of elements the map can hold without reallocating."""
         return self._raw.capacity()
 
+    def memory(self) -> int:
+        """Returns the total estimated memory usage of cached entries in bytes."""
+        return self._raw.memory()
+
     def __len__(self) -> int:
         return len(self._raw)
 
@@ -828,6 +865,7 @@ class LRUCache(BaseCacheImpl[KT, VT]):
         iterable: typing.Union[typing.Union[dict, typing.Iterable[tuple]], None] = None,
         *,
         capacity: int = 0,
+        maxmemory: int = 0,
     ) -> None:
         """
         Initialize a new LRU Cache instance.
@@ -836,12 +874,15 @@ class LRUCache(BaseCacheImpl[KT, VT]):
             maxsize (int): Maximum size of the cache. Zero indicates unlimited size.
             iterable (dict | Iterable[tuple], optional): Initial data to populate the cache.
             capacity (int, optional): Pre-allocated capacity for the cache to minimize reallocations.
+            maxmemory (int, optional): Maximum memory (bytes) allowed for cached entries. Zero means unlimited.
+                                       On PyPy. In PyPy, the size of each object is assumed to be 1 if the object
+                                       does not have a `__sizeof__` method.
 
         Notes:
             - The cache size is immutable after initialization.
             - If an iterable is provided, it will be used to populate the cache.
         """
-        self._raw = _core.LRUCache(maxsize, capacity=capacity)
+        self._raw = _core.LRUCache(maxsize, capacity=capacity, maxmemory=maxmemory)
 
         if iterable is not None:
             self.update(iterable)
@@ -850,10 +891,18 @@ class LRUCache(BaseCacheImpl[KT, VT]):
     def maxsize(self) -> int:
         return self._raw.maxsize()
 
+    @property
+    def maxmemory(self) -> int:
+        return self._raw.maxmemory()
+
     def capacity(self) -> int:
         """Returns the number of elements the map can hold without reallocating."""
         return self._raw.capacity()
 
+    def memory(self) -> int:
+        """Returns the total estimated memory usage of cached entries in bytes."""
+        return self._raw.memory()
+
     def __len__(self) -> int:
         return len(self._raw)
 
@@ -1098,6 +1147,7 @@ class LFUCache(BaseCacheImpl[KT, VT]):
         iterable: typing.Union[typing.Union[dict, typing.Iterable[tuple]], None] = None,
         *,
         capacity: int = 0,
+        maxmemory: int = 0,
     ) -> None:
         """
         Initialize a new Least Frequently Used (LFU) cache.
@@ -1106,10 +1156,13 @@ class LFUCache(BaseCacheImpl[KT, VT]):
             maxsize (int): Maximum size of the cache. A value of zero means unlimited size.
             iterable (dict or Iterable[tuple], optional): Initial data to populate the cache.
             capacity (int, optional): Initial hash table capacity to minimize reallocations. Defaults to 0.
+            maxmemory (int, optional): Maximum memory (bytes) allowed for cached entries. Zero means unlimited.
+                                       On PyPy. In PyPy, the size of each object is assumed to be 1 if the object
+                                       does not have a `__sizeof__` method.
 
         The cache uses a thread-safe LFU eviction policy, removing least frequently accessed items when the cache reaches its maximum size.
         """
-        self._raw = _core.LFUCache(maxsize, capacity=capacity)
+        self._raw = _core.LFUCache(maxsize, capacity=capacity, maxmemory=maxmemory)
 
         if iterable is not None:
             self.update(iterable)
@@ -1118,10 +1171,18 @@ class LFUCache(BaseCacheImpl[KT, VT]):
     def maxsize(self) -> int:
         return self._raw.maxsize()
 
+    @property
+    def maxmemory(self) -> int:
+        return self._raw.maxmemory()
+
     def capacity(self) -> int:
         """Returns the number of elements the map can hold without reallocating."""
         return self._raw.capacity()
 
+    def memory(self) -> int:
+        """Returns the total estimated memory usage of cached entries in bytes."""
+        return self._raw.memory()
+
     def __len__(self) -> int:
         return len(self._raw)
 
@@ -1378,6 +1439,7 @@ class TTLCache(BaseCacheImpl[KT, VT]):
         iterable: typing.Union[typing.Union[dict, typing.Iterable[tuple]], None] = None,
         *,
         capacity: int = 0,
+        maxmemory: int = 0,
     ) -> None:
         """
         Initialize a new TTL cache instance.
@@ -1387,6 +1449,9 @@ class TTLCache(BaseCacheImpl[KT, VT]):
             ttl: Time-to-live for cache entries, either as seconds or a timedelta.
             iterable: Optional initial items to populate the cache, can be a dict or iterable of tuples.
             capacity: Optional initial capacity for the underlying cache storage. Defaults to 0.
+            maxmemory: Maximum memory (bytes) allowed for cached entries. Zero means unlimited.
+                       On PyPy. In PyPy, the size of each object is assumed to be 1 if the object
+                       does not have a `__sizeof__` method.
 
         Raises:
             ValueError: If the time-to-live (ttl) is not a positive number.
@@ -1397,7 +1462,7 @@ class TTLCache(BaseCacheImpl[KT, VT]):
         if ttl <= 0:
             raise ValueError("ttl must be a positive number and non-zero")
 
-        self._raw = _core.TTLCache(maxsize, ttl, capacity=capacity)
+        self._raw = _core.TTLCache(maxsize, ttl, capacity=capacity, maxmemory=maxmemory)
 
         if iterable is not None:
             self.update(iterable)
@@ -1406,6 +1471,10 @@ class TTLCache(BaseCacheImpl[KT, VT]):
     def maxsize(self) -> int:
         return self._raw.maxsize()
 
+    @property
+    def maxmemory(self) -> int:
+        return self._raw.maxmemory()
+
     @property
     def ttl(self) -> float:
         return self._raw.ttl()
@@ -1414,6 +1483,10 @@ class TTLCache(BaseCacheImpl[KT, VT]):
         """Returns the number of elements the map can hold without reallocating."""
         return self._raw.capacity()
 
+    def memory(self) -> int:
+        """Returns the total estimated memory usage of cached entries in bytes."""
+        return self._raw.memory()
+
     def __len__(self) -> int:
         return len(self._raw)
 
@@ -1744,6 +1817,7 @@ class VTTLCache(BaseCacheImpl[KT, VT]):
         ttl: typing.Union[float, timedelta, datetime, None] = None,  # This is not a global TTL!
         *,
         capacity: int = 0,
+        maxmemory: int = 0,
     ) -> None:
         """
         Initialize a new VTTLCache instance.
@@ -1753,11 +1827,14 @@ class VTTLCache(BaseCacheImpl[KT, VT]):
             iterable (dict or Iterable[tuple], optional): Initial data to populate the cache.
             ttl (float or timedelta or datetime, optional): Time-to-live duration for `iterable` items.
             capacity (int, optional): Preallocated capacity for the cache to minimize reallocations.
+            maxmemory (int, optional): Maximum memory (bytes) allowed for cached entries. Zero means unlimited.
+                                       On PyPy. In PyPy, the size of each object is assumed to be 1 if the object
+                                       does not have a `__sizeof__` method.
 
         Raises:
             ValueError: If provided TTL is zero or negative.
         """
-        self._raw = _core.VTTLCache(maxsize, capacity=capacity)
+        self._raw = _core.VTTLCache(maxsize, capacity=capacity, maxmemory=maxmemory)
 
         if iterable is not None:
             self.update(iterable, ttl)
@@ -1766,10 +1843,18 @@ class VTTLCache(BaseCacheImpl[KT, VT]):
     def maxsize(self) -> int:
         return self._raw.maxsize()
 
+    @property
+    def maxmemory(self) -> int:
+        return self._raw.maxmemory()
+
     def capacity(self) -> int:
         """Returns the number of elements the map can hold without reallocating."""
         return self._raw.capacity()
 
+    def memory(self) -> int:
+        """Returns the total estimated memory usage of cached entries in bytes."""
+        return self._raw.memory()
+
     def __len__(self) -> int:
         return len(self._raw)
 
@@ -1789,7 +1874,10 @@ class VTTLCache(BaseCacheImpl[KT, VT]):
         return self._raw.is_full()
 
     def insert(
-        self, key: KT, value: VT, ttl: typing.Union[float, timedelta, datetime, None] = None
+        self,
+        key: KT,
+        value: VT,
+        ttl: typing.Union[float, timedelta, datetime, None] = None,
     ) -> typing.Optional[VT]:
         """
         Insert a key-value pair into the cache with an optional time-to-live (TTL).

cachebox/_core.pyi

@@ -30,11 +30,14 @@ class BaseCacheImpl(typing.Generic[KT, VT]):
         iterable: typing.Union[typing.Iterable[typing.Tuple[KT, VT]], typing.Dict[KT, VT]] = ...,
         *,
         capacity: int = ...,
+        maxmemory: int = ...,
     ) -> None: ...
     @staticmethod
     def __class_getitem__(*args: typing.Any) -> None: ...
     @property
     def maxsize(self) -> int: ...
+    @property
+    def maxmemory(self) -> int: ...
     def __len__(self) -> int: ...
     def __sizeof__(self) -> int: ...
     def __bool__(self) -> bool: ...
@@ -47,6 +50,7 @@ class BaseCacheImpl(typing.Generic[KT, VT]):
     def __eq__(self, other: typing.Any) -> bool: ...
     def __ne__(self, other: typing.Any) -> bool: ...
     def capacity(self) -> int: ...
+    def memory(self) -> int: ...
     def is_full(self) -> bool: ...
     def is_empty(self) -> bool: ...
     def insert(
@@ -55,7 +59,11 @@ class BaseCacheImpl(typing.Generic[KT, VT]):
     def get(self, key: KT, default: typing.Optional[DT] = None) -> typing.Union[VT, DT]: ...
     def pop(self, key: KT, default: typing.Optional[DT] = None) -> typing.Union[VT, DT]: ...
     def setdefault(
-        self, key: KT, default: typing.Optional[DT] = None, *args: typing.Any, **kwargs: typing.Any
+        self,
+        key: KT,
+        default: typing.Optional[DT] = None,
+        *args: typing.Any,
+        **kwargs: typing.Any,
     ) -> typing.Optional[VT | DT]: ...
     def popitem(self) -> typing.Tuple[KT, VT]: ...
     def drain(self, n: int) -> int: ...

cachebox/utils.py

@@ -1,11 +1,11 @@
-from ._cachebox import BaseCacheImpl, FIFOCache
-from collections import namedtuple, defaultdict
-import functools
-import asyncio
 import _thread
+import asyncio
+import functools
 import inspect
 import typing
+from collections import defaultdict, namedtuple
 
+from ._cachebox import BaseCacheImpl, FIFOCache
 
 KT = typing.TypeVar("KT")
 VT = typing.TypeVar("VT")
@@ -46,6 +46,10 @@ class Frozen(BaseCacheImpl[KT, VT]):  # pragma: no cover
     def maxsize(self) -> int:
         return self.__cache.maxsize
 
+    @property
+    def maxmemory(self) -> int:
+        return self.__cache.maxmemory
+
     def __len__(self) -> int:
         return len(self.__cache)
 
@@ -85,6 +89,9 @@ class Frozen(BaseCacheImpl[KT, VT]):  # pragma: no cover
     def capacity(self) -> int:
         return self.__cache.capacity()
 
+    def memory(self) -> int:
+        return self.__cache.memory()
+
     def is_full(self) -> bool:
         return self.__cache.is_full()
 
@@ -267,13 +274,14 @@ EVENT_HIT = 2
 
 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 +295,12 @@ def _cached_wrapper(
         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 +319,7 @@ def _cached_wrapper(
                 raise cached_error
 
             try:
-                result = cache[key]
+                result = _cache[key]
                 hits += 1
                 event = EVENT_HIT
             except KeyError:
@@ -323,7 +332,7 @@ def _cached_wrapper(
                     raise e
 
                 else:
-                    cache[key] = result
+                    _cache[key] = result
                     misses += 1
                     event = EVENT_MISS
 
@@ -332,34 +341,39 @@ def _cached_wrapper(
 
         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.memory()
+        )
+
     _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 +389,12 @@ def _async_cached_wrapper(
         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 +415,7 @@ def _async_cached_wrapper(
                 raise cached_error
 
             try:
-                result = cache[key]
+                result = _cache[key]
                 hits += 1
                 event = EVENT_HIT
             except KeyError:
@@ -413,7 +428,7 @@ def _async_cached_wrapper(
                     raise e
 
                 else:
-                    cache[key] = result
+                    _cache[key] = result
                     misses += 1
                     event = EVENT_MISS
 
@@ -424,21 +439,25 @@ def _async_cached_wrapper(
 
         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.memory()
+        )
+
     _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
 
@@ -456,7 +475,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 +485,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,6 +496,20 @@ def cached(
         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)
@@ -483,8 +517,8 @@ def cached(
     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 +543,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 +560,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)
 

{cachebox-5.0.4.dist-info → cachebox-5.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachebox
-Version: 5.0.4
+Version: 5.2.1
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Programming Language :: Python :: 3
@@ -176,7 +176,6 @@ assert cache.get("key") == "value"
 ## Getting started
 There are 3 useful functions:
 - [**cached**](#cached--decorator): a decorator that helps you to cache your functions and calculations with a lot of options.
-- [**cachedmethod**](#cachedmethod--decorator): this is excatly works like `cached()`, but ignores `self` parameters in hashing and key making.
 - [**is_cached**](#is_cached--function): check if a function/method cached by cachebox or not
 
 And 9 classes:
@@ -282,6 +281,23 @@ print(sum_as_string.cache_info())
 sum_as_string.cache_clear()
 ```
 
+method example: *(Added in v5.1.0)*
+```python
+import cachebox
+
+class Example:
+    def __init__(self, num) -> None:
+        self.num = num
+        self._cache = cachebox.TTLCache(20, 10)
+
+    @cachebox.cached(lambda self: self._cache)
+    def method(self, char: str):
+        return char * self.num
+
+ex = Example(10)
+assert ex.method("a") == "a" * 10
+```
+
 callback example: *(Added in v4.2.0)*
 ```python
 import cachebox
@@ -314,26 +330,6 @@ assert func(5, 4) == 9
 
 </details>
 
-
-> [!NOTE]\
-> Recommended use `cached` method for **@staticmethod**s and use [`cachedmethod`](#function-cachedmethod) for **@classmethod**s;
-> And set `copy_level` parameter to `2` on **@classmethod**s.
-> ```python
-> class MyClass:
->   def __init__(self, num: int) -> None:
->       self.num = num
->
->   @classmethod
->   @cachedmethod({}, copy_level=2)
->   def class_func(cls, num: int):
->       return cls(num)
->
->   @staticmethod
->   @cached({})
->   def static_func(num: int):
->       return num * 5
-> ```
-
 > [!TIP]\
 > There's a new feature **since `v4.1.0`** that you can tell to a cached function that don't use cache for a call:
 > ```python
@@ -346,6 +342,9 @@ assert func(5, 4) == 9
 ### `cachedmethod` (🎀 decorator)
 this is excatly works like `cached()`, but ignores `self` parameters in hashing and key making.
 
+> [!WARNING]\
+> This function has been deprecated since `v5.1.0`, use `cached` function instead.
+
 <details>
 <summary><b>Example</b></summary>
 

cachebox-5.2.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+cachebox-5.2.1.dist-info/METADATA,sha256=nIqCXmu4yObt_6PLJ-ZvdTH0qHwCXnoVMiX-wA1fa64,26991
+cachebox-5.2.1.dist-info/WHEEL,sha256=xu7xe7fX0mDsrlObmIPY9Qu5_8dib97e5863-7t3qqk,106
+cachebox-5.2.1.dist-info/licenses/LICENSE,sha256=4oH8nU-rNZ9h5tbh6MoPVPFgtYDqsPXlAr2QnhnxQ4Q,1064
+cachebox/__init__.py,sha256=I93y-hLQKXsEIlmd0KAZ6CVfDqKqcWFvyiJdDsMUcvI,647
+cachebox/_cachebox.py,sha256=6cRVHpBJ52o4BrEAoY6v8EOWzxDoduTY4beeJy1eb9o,74601
+cachebox/_core.cpython-313t-darwin.so,sha256=2jrSNYGlhfiRPYopMJnbyUtLdvTKsPH36Ty3wChE2ME,758704
+cachebox/_core.pyi,sha256=-FtdVb0huB_VmetHum_d8x9b2VYzVOEIKey5DonzCcQ,2988
+cachebox/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cachebox/utils.py,sha256=jacdATe_7XYkUt3OuSc1W1VnZlmCTHb7lOiQVCuANJA,18359
+cachebox-5.2.1.dist-info/RECORD,,

{cachebox-5.0.4.dist-info → cachebox-5.2.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.9.6)
+Generator: maturin (1.10.2)
 Root-Is-Purelib: false
 Tag: cp313-cp313t-macosx_11_0_arm64

cachebox-5.0.4.dist-info/RECORD

@@ -1,10 +0,0 @@
-cachebox-5.0.4.dist-info/METADATA,sha256=vx5tWzBq0cdk0_0alFRm_R_1KquIHOixh3vzMgi00LY,27190
-cachebox-5.0.4.dist-info/WHEEL,sha256=lArrl3UZ7hqAytPo_RGBIshTDVGiR3UckOq0Rt8pOAA,105
-cachebox-5.0.4.dist-info/licenses/LICENSE,sha256=4oH8nU-rNZ9h5tbh6MoPVPFgtYDqsPXlAr2QnhnxQ4Q,1064
-cachebox/__init__.py,sha256=I93y-hLQKXsEIlmd0KAZ6CVfDqKqcWFvyiJdDsMUcvI,647
-cachebox/_cachebox.py,sha256=hCZLh1DRMHvD5Crqcrsffy0pFRmc9fToTxHmUJDFK5Q,70522
-cachebox/_core.cpython-313t-darwin.so,sha256=eMLSReJRNLhuXE_JMBYxXH7vhGxu5K8Ntdvg9SC-wLk,675024
-cachebox/_core.pyi,sha256=qVl1rXUfzAzxy5FrH35Bv7RTp4gvXbaoZ-oMTDe4zTY,2842
-cachebox/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cachebox/utils.py,sha256=tHl21N5dW1HDpscwfkvre3-LeBJo8GiZ9ixYBn9KkGk,16804
-cachebox-5.0.4.dist-info/RECORD,,