cachetools 7.2.3__tar.gz → 7.2.4__tar.gz

{cachetools-7.2.3 → cachetools-7.2.4}/CHANGELOG.rst

@@ -1,3 +1,13 @@
+v7.2.4 (2026-10-19)
+===================
+
+- Restore autospec calls to ``@cachedmethod`` decorated methods.
+
+- Improve branch coverage of unit tests.
+
+- Minor type stub improvements.
+
+
 v7.2.3 (2026-10-17)
 ===================
 

{cachetools-7.2.3/src/cachetools.egg-info → cachetools-7.2.4}/PKG-INFO

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

{cachetools-7.2.3 → cachetools-7.2.4}/src/cachetools/__init__.py

@@ -12,7 +12,7 @@ __all__ = (
     "cachedmethod",
 )
 
-__version__ = "7.2.3"
+__version__ = "7.2.4"
 
 import collections
 import collections.abc

{cachetools-7.2.3 → cachetools-7.2.4}/src/cachetools/__init__.pyi

@@ -143,7 +143,8 @@ class _CacheInfo(NamedTuple):
 
 @type_check_only
 class _AbstractCondition(AbstractContextManager[Any], Protocol):
-    # implementation and unit tests do not use plain wait() and notify()
+    # implementation and unit tests currently do not use plain wait()
+    # and notify(); these are reserved for future use
     def wait(self, timeout: float | None = None) -> bool: ...
     def wait_for(
         self, predicate: Callable[[], _T], timeout: float | None = None

{cachetools-7.2.3 → cachetools-7.2.4}/src/cachetools/_descriptor.py

@@ -96,15 +96,30 @@ class _MethodDescriptor:
         # Created once and shared by all class accesses; objtype is not
         # used for instance lookups, so it need not be bound here.
         if self.__unbound is None:
-            descriptor = self
+            self.__unbound = _Unbound(self)
+        return self.__unbound
 
-            # As in the previous function wrapper, the receiver is named self.
-            @functools.wraps(self.__wrapped__)  # type: ignore
-            def unbound(self, *args, **kwargs):
-                return descriptor.__get__(self)(*args, **kwargs)
 
-            self.__unbound = unbound  # type: ignore
-        return self.__unbound
+class _Unbound:
+    """Callable returned on class access.
+
+    Deliberately not a function: unittest.mock.create_autospec() only strips
+    the receiver from plain functions found in the class dict, so a function
+    here would leave the receiver in an autospec'd instance's signature.
+    """
+
+    def __init__(self, descriptor):
+        functools.update_wrapper(self, descriptor.__wrapped__)
+        self.__descriptor = descriptor
+
+    # Receiver is taken from *args so autospec'd instances accept any call,
+    # as they did before class access returned a callable.
+    def __call__(self, /, *args, **kwargs):
+        if not args:
+            msg = "Cannot call @cachedmethod through the class without an instance"
+            raise TypeError(msg)
+        obj, *args = args
+        return self.__descriptor.__get__(obj)(*args, **kwargs)
 
 
 class _ClassMethodDescriptor(_MethodDescriptor):

{cachetools-7.2.3 → cachetools-7.2.4/src/cachetools.egg-info}/PKG-INFO

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

{cachetools-7.2.3 → cachetools-7.2.4}/tests/__init__.py

@@ -5,6 +5,39 @@ from typing import Any, Protocol
 import cachetools
 
 
+class CountedLock:
+    def __init__(self):
+        self.count = 0
+
+    def __enter__(self):
+        self.count += 1
+
+    def __exit__(self, *exc):
+        pass
+
+
+class CountedCondition(CountedLock):
+    def __init__(self):
+        super().__init__()
+        self.wait_count = 0
+        self.notify_count = 0
+
+    def wait(self, timeout=None):
+        self.wait_count += 1
+        return True
+
+    def wait_for(self, predicate, timeout=None):
+        res = predicate()
+        self.wait_count += 1
+        return res
+
+    def notify(self, n=1):
+        self.notify_count += 1
+
+    def notify_all(self):
+        self.notify_count += 1
+
+
 class SimplifiedTestCaseProtocol(Protocol):
     def assertEqual(self, first: Any, second: Any, msg: Any = None) -> None: ...
     def assertNotEqual(self, first: Any, second: Any, msg: Any = None) -> None: ...
@@ -323,6 +356,13 @@ class CacheTestMixin(SimplifiedTestCaseProtocol):
         self.assertEqual(3, cache[3])
         self.assertEqual(7, cache[4])
 
+        # growing an existing entry may have to evict other entries
+        cache[4] = 9
+        self.assertEqual(1, len(cache))
+        self.assertEqual(9, cache.currsize)
+        self.assertNotIn(3, cache)
+        self.assertEqual(9, cache[4])
+
     def test_getsizeof_replace_same_size(self):
         cache = self.Cache(maxsize=10, getsizeof=lambda x: x)
 
@@ -453,39 +493,3 @@ class CacheTestMixin(SimplifiedTestCaseProtocol):
             cache = pickle.loads(pickle.dumps(source))
             self.assertEqual(n, len(cache))
             self.assertEqual(source, cache)
-
-
-class CountedLock:
-    def __init__(self):
-        self.count = 0
-
-    def __enter__(self):
-        self.count += 1
-
-    def __exit__(self, *exc):
-        pass
-
-
-class CountedCondition(CountedLock):
-    def __init__(self):
-        super().__init__()
-        self.wait_count = 0
-        self.notify_count = 0
-
-    # only wait_for() and notify_all() are currently used, but wait()
-    # and notify() are also required according to the docs...
-
-    def wait(self, timeout=None):
-        self.wait_count += 1
-        return True
-
-    def wait_for(self, predicate, timeout=None):
-        res = predicate()
-        self.wait_count += 1
-        return res
-
-    def notify(self, n=1):
-        self.notify_count += 1
-
-    def notify_all(self):
-        self.notify_count += 1

{cachetools-7.2.3 → cachetools-7.2.4}/tests/test_cachedmethod.py

@@ -500,6 +500,17 @@ class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
 
                 bar = foo
 
+    def test_decorator_same_name(self):
+        # assigning to a second owner under the same name is accepted
+        class Other(Cached):
+            get = Cached.__dict__["get"]
+
+        other = Other(self.cache(2))
+
+        self.assertEqual(other.get(0), 0)
+        self.assertEqual(other.get(0), 0)
+        self.assertEqual(other.get(1), 1)
+
     def test_decorator_no_set_name(self):
         class Cached:
             def foo(_self):
@@ -776,6 +787,10 @@ class UnboundMethodTest(unittest.TestCase):
         self.assertEqual(cached.get(1), 0)
         self.assertEqual(cached.count, 1)
 
+    def test_class_call_without_instance(self):
+        with self.assertRaises(TypeError):
+            Cached.get()  # type: ignore
+
     def test_class_access_identity(self):
         self.assertIs(Cached.get, Cached.get)
         self.assertIs(Cached.get_info, Cached.get_info)
@@ -798,3 +813,13 @@ class UnboundMethodTest(unittest.TestCase):
             warnings.simplefilter("always")
             unittest.mock.create_autospec(Cached, instance=True)
         self.assertEqual(len(w), 0)
+
+    def test_autospec_call(self):
+        import unittest.mock
+
+        mock = unittest.mock.create_autospec(Cached, instance=True)
+        mock.get.return_value = 42
+        self.assertEqual(mock.get(1), 42)
+        mock.get.assert_called_with(1)
+        self.assertEqual(mock.get(value=1), 42)
+        mock.get.assert_called_with(value=1)

{cachetools-7.2.3 → cachetools-7.2.4}/tests/test_tlru.py

@@ -217,6 +217,19 @@ class TLRUCacheTest(unittest.TestCase, CacheTestMixin):
         self.assertNotIn(2, cache)
         self.assertNotIn(3, cache)
 
+    def test_ttu_iter_expired(self):
+        cache = TLRUCache[int, int, int](
+            maxsize=2, ttu=lambda _k, _v, t: t + 2, timer=Timer()
+        )
+        cache[1] = 1
+        cache.timer.tick()
+        cache[2] = 2
+        cache.timer.tick()
+        # a bare for loop skips expired items without removing them
+        self.assertEqual([2], [key for key in cache])
+        self.assertEqual({(1, 1)}, set(cache.expire()))
+        self.assertEqual([2], [key for key in cache])
+
     def test_ttu_expired(self):
         cache = TLRUCache[int, None, int](
             maxsize=1, ttu=lambda k, _, t: t + k, timer=Timer()

{cachetools-7.2.3 → cachetools-7.2.4}/tests/test_ttl.py

@@ -177,6 +177,17 @@ class TTLCacheTest(unittest.TestCase, CacheTestMixin):
         self.assertNotIn(2, cache)
         self.assertNotIn(3, cache)
 
+    def test_ttl_iter_expired(self):
+        cache = TTLCache[int, int, int](maxsize=2, ttl=2, timer=Timer())
+        cache[1] = 1
+        cache.timer.tick()
+        cache[2] = 2
+        cache.timer.tick()
+        # a bare for loop skips expired items without removing them
+        self.assertEqual([2], [key for key in cache])
+        self.assertEqual({(1, 1)}, set(cache.expire()))
+        self.assertEqual([2], [key for key in cache])
+
     def test_ttl_atomic(self):
         cache = TTLCache[int, int, int](maxsize=1, ttl=2, timer=Timer(auto=True))
         cache[1] = 1

{cachetools-7.2.3 → cachetools-7.2.4}/tox.ini

@@ -6,7 +6,7 @@ deps =
     pytest
     pytest-cov
 commands =
-    py.test --basetemp={envtmpdir} --cov=cachetools --cov-report term-missing {posargs}
+    py.test --basetemp={envtmpdir} --cov=cachetools --cov-branch --cov-report term-missing {posargs}
 
 [testenv:docs]
 deps =