cachetools 7.0.2__tar.gz → 7.0.4__tar.gz

{cachetools-7.0.2 → cachetools-7.0.4}/CHANGELOG.rst

@@ -1,3 +1,18 @@
+v7.0.4 (2026-03-08)
+===================
+
+- Fix and properly document ``@cachedmethod.cache_key`` behavior.
+
+- Minor documentation improvements.
+
+
+v7.0.3 (2026-03-05)
+===================
+
+- Fix ``DeprecationWarning`` when creating an autospec mock with
+  ``@cachedmethod`` decorations.
+
+
 v7.0.2 (2026-03-02)
 ===================
 

{cachetools-7.0.2/src/cachetools.egg-info → cachetools-7.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachetools
-Version: 7.0.2
+Version: 7.0.4
 Summary: Extensible memoizing collections and decorators
 Author-email: Thomas Kemmer <tkemmer@computer.org>
 Maintainer-email: Thomas Kemmer <tkemmer@computer.org>

{cachetools-7.0.2 → cachetools-7.0.4}/docs/index.rst

@@ -370,13 +370,10 @@ often called with the same arguments:
           with urllib.request.urlopen(url) as s:
               return s.read()
 
-      # make sure access to cache is synchronized
+      # remove (pop) an individual cached PEP from the cache
+      key = get_pep.cache_key(42)
       with get_pep.cache_lock:
-          get_pep.cache.clear()
-
-      # always use the key function for accessing cache items
-      with get_pep.cache_lock:
-          get_pep.cache.pop(get_pep.cache_key(42), None)
+          get_pep.cache.pop(key, None)
 
    For the common use case of clearing or invalidating the cache, the
    decorator also provides a :func:`cache_clear()` function which
@@ -582,6 +579,15 @@ often called with the same arguments:
       >>> peps.get.cache_info()
       CacheInfo(hits=3, misses=8, maxsize=32, currsize=8)
 
+      >>> # remove an individual cached PEP from the cache
+      >>> key = peps.get.cache_key(320)
+      >>> with peps.get.cache_lock:
+      ...    del peps.get.cache[key]
+
+      >>> peps.get.cache_info()
+      CacheInfo(hits=3, misses=8, maxsize=32, currsize=7)
+
+      >>> # remove all cached PEPs and clear cache info
       >>> peps.get.cache_clear()
 
       >>> peps.get.cache_info()
@@ -590,8 +596,9 @@ often called with the same arguments:
    The `key` function will be called as `key(self, *args, **kwargs)`
    to retrieve a suitable cache key.  Note that the default `key`
    function, :func:`cachetools.keys.methodkey`, ignores its first
-   argument, i.e. :const:`self`.  This has mostly historical reasons,
-   but also ensures that :const:`self` does not have to be hashable.
+   implicit argument, i.e. :const:`self`.  This has mostly historical
+   reasons, but also ensures that :const:`self` does not have to be
+   hashable.
 
    You may provide a different `key` function,
    e.g. :func:`cachetools.keys.hashkey`, if you need :const:`self` to

{cachetools-7.0.2 → cachetools-7.0.4}/src/cachetools/__init__.py

@@ -12,7 +12,7 @@ __all__ = (
     "cachedmethod",
 )
 
-__version__ = "7.0.2"
+__version__ = "7.0.4"
 
 import collections
 import collections.abc
@@ -748,8 +748,8 @@ def cached(cache, key=keys.hashkey, lock=None, condition=None, info=False):
 
 
 def cachedmethod(cache, key=keys.methodkey, lock=None, condition=None, info=False):
-    """Decorator to wrap a class or instance method with a memoizing
-    callable that saves results in a cache.
+    """Decorator to wrap a method with a memoizing callable that saves
+    results in a cache.
 
     """
     from ._cachedmethod import _wrapper

{cachetools-7.0.2 → cachetools-7.0.4}/src/cachetools/_cachedmethod.py

@@ -48,7 +48,7 @@ class _WrapperBase:
 
     @property
     def cache_key(self):
-        return self.__key
+        return functools.partial(self.__key, self._obj)
 
     @property
     def cache_lock(self):
@@ -77,7 +77,12 @@ class _DescriptorBase:
 
     def __get__(self, obj, objtype=None):
         wrapper = self.Wrapper(obj)
-        if self.__attrname is not None:
+        if obj is None:
+            # Return the wrapper itself without modification when accessed
+            # through the class to support class-level introspection, such
+            # as for mocking with autospec=True in unittest.mock.
+            pass
+        elif self.__attrname is not None:
             # replace descriptor instance with wrapper in instance dict
             try:
                 # In case of a race condition where another thread already replaced
@@ -148,7 +153,7 @@ def _condition_info(method, cache, key, lock, cond, info):
                 cache = self.cache
                 lock = self.cache_lock
                 cond = self.cache_condition
-                key = self.cache_key(self._obj, *args, **kwargs)
+                key = self.cache_key(*args, **kwargs)
 
                 with lock:
                     cond.wait_for(lambda: key not in self.__pending)
@@ -194,7 +199,7 @@ def _locked_info(method, cache, key, lock, info):
             def __call__(self, *args, **kwargs):
                 cache = self.cache
                 lock = self.cache_lock
-                key = self.cache_key(self._obj, *args, **kwargs)
+                key = self.cache_key(*args, **kwargs)
                 with lock:
                     try:
                         result = cache[key]
@@ -233,7 +238,7 @@ def _unlocked_info(method, cache, key, info):
 
             def __call__(self, *args, **kwargs):
                 cache = self.cache
-                key = self.cache_key(self._obj, *args, **kwargs)
+                key = self.cache_key(*args, **kwargs)
                 try:
                     result = cache[key]
                     self.__hits += 1

{cachetools-7.0.2 → cachetools-7.0.4/src/cachetools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachetools
-Version: 7.0.2
+Version: 7.0.4
 Summary: Extensible memoizing collections and decorators
 Author-email: Thomas Kemmer <tkemmer@computer.org>
 Maintainer-email: Thomas Kemmer <tkemmer@computer.org>

{cachetools-7.0.2 → cachetools-7.0.4}/tests/test_cachedmethod.py

@@ -1,4 +1,5 @@
 import unittest
+import unittest.mock
 import warnings
 
 
@@ -369,24 +370,26 @@ class MethodDecoratorTestMixin:
         cached = Cached(cache)
 
         self.assertIs(cached.get.cache, cache)
-        self.assertIs(cached.get.cache_key, keys.methodkey)
         self.assertIs(cached.get.cache_lock, None)
         self.assertIs(cached.get.cache_condition, None)
+        self.assertEqual(cached.get.cache_key(42), keys.methodkey(cached, 42))
 
         self.assertIs(cached.get_lock.cache, cache)
-        self.assertIs(cached.get_lock.cache_key, keys.methodkey)
         self.assertIs(cached.get_lock.cache_lock, cached.lock)
         self.assertIs(cached.get_lock.cache_condition, None)
+        self.assertEqual(cached.get_lock.cache_key(42), keys.methodkey(cached, 42))
 
         self.assertIs(cached.get_cond.cache, cache)
-        self.assertIs(cached.get_cond.cache_key, keys.methodkey)
         self.assertIs(cached.get_cond.cache_lock, cached.cond)
         self.assertIs(cached.get_cond.cache_condition, cached.cond)
+        self.assertEqual(cached.get_cond.cache_key(42), keys.methodkey(cached, 42))
 
         self.assertIs(cached.get_lock_cond_info.cache, cache)
-        self.assertIs(cached.get_lock_cond_info.cache_key, keys.methodkey)
         self.assertIs(cached.get_lock_cond_info.cache_lock, cached.lock)
         self.assertIs(cached.get_lock_cond_info.cache_condition, cached.cond)
+        self.assertEqual(
+            cached.get_lock_cond_info.cache_key(42), keys.methodkey(cached, 42)
+        )
 
     def test_decorator_clear(self):
         cache = self.cache(2)
@@ -602,15 +605,25 @@ class CacheMethodTest(unittest.TestCase, MethodDecoratorTestMixin):
         self.assertEqual(cached1.get_info.cache_info(), (0, 0, 2, 0))
         self.assertEqual(cached2.get_info.cache_info(), (0, 0, 2, 0))
 
+        # hits/misses are counted by instance
         self.assertEqual(cached1.get_info(0), 0)
-
         self.assertEqual(cached1.get_info.cache_info(), (0, 1, 2, 1))
         self.assertEqual(cached2.get_info.cache_info(), (0, 0, 2, 1))
 
+        # default methodkey discards "self", so results will be shared
+        # across instances
         self.assertEqual(cached2.get_info(0), 0)
-
         self.assertEqual(cached1.get_info.cache_info(), (0, 1, 2, 1))
         self.assertEqual(cached2.get_info.cache_info(), (1, 0, 2, 1))
+        self.assertEqual(cached1.get_info(0), 0)
+        self.assertEqual(cached1.get_info.cache_info(), (1, 1, 2, 1))
+        self.assertEqual(cached2.get_info.cache_info(), (1, 0, 2, 1))
+        self.assertEqual(cached1.get_info(1), 1)
+        self.assertEqual(cached1.get_info.cache_info(), (1, 2, 2, 2))
+        self.assertEqual(cached2.get_info.cache_info(), (1, 0, 2, 2))
+        self.assertEqual(cached2.get_info(1), 1)
+        self.assertEqual(cached1.get_info.cache_info(), (1, 2, 2, 2))
+        self.assertEqual(cached2.get_info.cache_info(), (2, 0, 2, 2))
 
     def test_value_too_large(self):
         cache = self.cache(1, getsizeof=lambda x: x)
@@ -673,3 +686,12 @@ class NoneMethodTest(unittest.TestCase):
 
         with self.assertRaises(TypeError):
             wrapper.cache_info()
+
+
+class AutospecTest(unittest.TestCase):
+    def test_autospec_no_warnings(self):
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            unittest.mock.create_autospec(Cached, instance=True)
+        self.assertEqual(len(w), 0)