cachetools 7.2.5__tar.gz → 7.2.6__tar.gz

{cachetools-7.2.5 → cachetools-7.2.6}/CHANGELOG.rst

@@ -1,3 +1,9 @@
+v7.2.6 (2026-10-26)
+===================
+
+- Various performance improvements.
+
+
 v7.2.5 (2026-10-25)
 ===================
 

{cachetools-7.2.5/src/cachetools.egg-info → cachetools-7.2.6}/PKG-INFO

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

{cachetools-7.2.5 → cachetools-7.2.6}/src/cachetools/__init__.py

@@ -12,7 +12,7 @@ __all__ = (
     "cachedmethod",
 )
 
-__version__ = "7.2.5"
+__version__ = "7.2.6"
 
 import collections
 import collections.abc
@@ -193,7 +193,9 @@ class FIFOCache(Cache):
         except StopIteration:
             raise KeyError("%s is empty" % type(self).__name__) from None
         else:
-            return (key, self.pop(key))
+            value = Cache.__getitem__(self, key)
+            del self[key]
+            return (key, value)
 
     def clear(self):
         Cache.clear(self)
@@ -224,7 +226,7 @@ class LFUCache(Cache):
 
     def __getitem__(self, key, cache_getitem=Cache.__getitem__):
         value = cache_getitem(self, key)
-        if key in self:  # __missing__ may not store item
+        if key in self.__links:  # __missing__ may not store item
             self.__touch(key)
         return value
 
@@ -257,7 +259,9 @@ class LFUCache(Cache):
         if curr is root:
             raise KeyError("%s is empty" % type(self).__name__) from None
         key = next(iter(curr.keys))  # remove an arbitrary element
-        return (key, self.pop(key))
+        value = Cache.__getitem__(self, key)
+        del self[key]
+        return (key, value)
 
     def clear(self):
         Cache.clear(self)
@@ -293,8 +297,10 @@ class LRUCache(Cache):
 
     def __getitem__(self, key, cache_getitem=Cache.__getitem__):
         value = cache_getitem(self, key)
-        if key in self:  # __missing__ may not store item
-            self.__touch(key)
+        try:
+            self.__order.move_to_end(key)
+        except KeyError:  # __missing__ may not store item
+            pass
         return value
 
     def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
@@ -312,7 +318,9 @@ class LRUCache(Cache):
         except StopIteration:
             raise KeyError("%s is empty" % type(self).__name__) from None
         else:
-            return (key, self.pop(key))
+            value = Cache.__getitem__(self, key)
+            del self[key]
+            return (key, value)
 
     def clear(self):
         Cache.clear(self)
@@ -361,7 +369,9 @@ class RRCache(Cache):
         if not keys:
             raise KeyError("%s is empty" % type(self).__name__) from None
         key = self.__choice(keys)
-        return (key, self.pop(key))
+        value = Cache.__getitem__(self, key)
+        del self[key]
+        return (key, value)
 
     def clear(self):
         Cache.clear(self)
@@ -482,16 +492,16 @@ class TTLCache(_TimedCache):
             return self.timer() < link.expires
 
     def __getitem__(self, key, cache_getitem=Cache.__getitem__):
+        links = self.__links
         try:
-            link = self.__getlink(key)
+            link = links[key]
         except KeyError:
-            expired = False
+            return cache_getitem(self, key)
+        links.move_to_end(key)
+        if self.timer() < link.expires:
+            return cache_getitem(self, key)
         else:
-            expired = not (self.timer() < link.expires)
-        if expired:
             return self.__missing__(key)
-        else:
-            return cache_getitem(self, key)
 
     def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
         with self.timer as time:
@@ -575,7 +585,9 @@ class TTLCache(_TimedCache):
             except StopIteration:
                 raise KeyError("%s is empty" % type(self).__name__) from None
             else:
-                return (key, self.pop(key))
+                value = Cache.__getitem__(self, key)
+                del self[key]
+                return (key, value)
 
     def clear(self):
         _TimedCache.clear(self)
@@ -621,16 +633,16 @@ class TLRUCache(_TimedCache):
             return self.timer() < item.expires
 
     def __getitem__(self, key, cache_getitem=Cache.__getitem__):
+        items = self.__items
         try:
-            item = self.__getitem(key)
+            item = items[key]
         except KeyError:
-            expired = False
+            return cache_getitem(self, key)
+        items.move_to_end(key)
+        if self.timer() < item.expires:
+            return cache_getitem(self, key)
         else:
-            expired = not (self.timer() < item.expires)
-        if expired:
             return self.__missing__(key)
-        else:
-            return cache_getitem(self, key)
 
     def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
         with self.timer as time:
@@ -707,7 +719,9 @@ class TLRUCache(_TimedCache):
             except StopIteration:
                 raise KeyError("%s is empty" % type(self).__name__) from None
             else:
-                return (key, self.pop(key))
+                value = Cache.__getitem__(self, key)
+                del self[key]
+                return (key, value)
 
     def clear(self):
         _TimedCache.clear(self)

{cachetools-7.2.5 → cachetools-7.2.6}/src/cachetools/_cached.py

@@ -25,7 +25,9 @@ def _condition_info(func, cache, key, lock, cond, info):
         nonlocal hits, misses
         k = key(*args, **kwargs)
         with lock:
-            cond.wait_for(lambda: k not in pending)
+            # apparently significantly faster than cond.wait_for(...)
+            while k in pending:
+                cond.wait()
             try:
                 result = cache[k]
                 hits += 1
@@ -158,7 +160,9 @@ def _condition(func, cache, key, lock, cond):
     def wrapper(*args, **kwargs):
         k = key(*args, **kwargs)
         with lock:
-            cond.wait_for(lambda: k not in pending)
+            # apparently significantly faster than cond.wait_for(...)
+            while k in pending:
+                cond.wait()
             try:
                 result = cache[k]
                 return result

{cachetools-7.2.5 → cachetools-7.2.6}/src/cachetools/_cachedmethod.py

@@ -79,7 +79,9 @@ def _condition_info(method, cache, key, lock, cond, info):
                 key = self.cache_key(*args, **kwargs)
 
                 with lock:
-                    cond.wait_for(lambda: key not in self.__pending)
+                    # apparently significantly faster than cond.wait_for(...)
+                    while key in self.__pending:
+                        cond.wait()
                     try:
                         result = cache[key]
                         self.__hits += 1
@@ -193,7 +195,9 @@ def _condition(method, cache, key, lock, cond):
         c = cache(self)
         k = key(self, *args, **kwargs)
         with lock(self):
-            cond(self).wait_for(lambda: k not in pending)
+            # apparently significantly faster than cond.wait_for(...)
+            while k in pending:
+                cond(self).wait()
             try:
                 return c[k]
             except KeyError:

{cachetools-7.2.5 → cachetools-7.2.6}/src/cachetools/keys.py

@@ -4,20 +4,31 @@ __all__ = ("hashkey", "methodkey", "typedkey", "typedmethodkey")
 
 
 class _HashedTuple(tuple):
-    """A tuple that ensures that hash() will be called no more than once
-    per element, since cache decorators will hash the key multiple
-    times on a cache miss.  See also _HashedSeq in the standard
-    library functools implementation.
+    """A tuple subclass used for cache keys.
 
-    """
+    Unlike _HashedSeq in the standard library functools implementation,
+    the hash value is not cached: the built-in tuple hash is faster than
+    a Python-level __hash__ that caches it.
 
-    __hashvalue = None  # default value, set in instance on first use
+    """
 
-    def __hash__(self, hash=tuple.__hash__):
-        hashvalue = self.__hashvalue
-        if hashvalue is None:
-            self.__hashvalue = hashvalue = hash(self)
-        return hashvalue
+    # A Python-level __hash__ that caches the hash costs more than it
+    # saves: hashing a 2-tuple three times takes 161 ns as _HashedTuple
+    # and 49 ns as a plain tuple (C tuple hash, 18 ns each); a dict
+    # lookup keyed by one takes 50 vs 12 ns.  Every cache operation
+    # hashes the key again (3 __hash__ calls per @cached hit, 12 per
+    # evicting miss by cProfile, 11.5% of miss time in __hash__ alone).
+    # The cached hash does not pay off even for a key wrapping a 200-int
+    # tuple (166 vs 49 ns for three hashes), only for elements whose own
+    # __hash__ is slow.
+    #
+    # __hashvalue = None  # default value, set in instance on first use
+    #
+    # def __hash__(self, hash=tuple.__hash__):
+    #     hashvalue = self.__hashvalue
+    #     if hashvalue is None:
+    #         self.__hashvalue = hashvalue = hash(self)
+    #     return hashvalue
 
     def __add__(self, other, add=tuple.__add__):
         return _HashedTuple(add(self, other))

{cachetools-7.2.5 → cachetools-7.2.6/src/cachetools.egg-info}/PKG-INFO

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

{cachetools-7.2.5 → cachetools-7.2.6}/tests/test_cached.py

@@ -98,15 +98,15 @@ class DecoratorTestMixin(SimplifiedTestCaseProtocol):
         self.assertEqual(len(cache), 0)
         self.assertEqual(wrapper(0), 0)
         self.assertEqual(lock.count, 3)
-        self.assertEqual(cond.wait_count, 1)
+        self.assertEqual(cond.wait_count, 0)
         self.assertEqual(cond.notify_count, 1)
         self.assertEqual(wrapper(1), 1)
         self.assertEqual(lock.count, 6)
-        self.assertEqual(cond.wait_count, 2)
+        self.assertEqual(cond.wait_count, 0)
         self.assertEqual(cond.notify_count, 2)
         self.assertEqual(wrapper(1), 1)
         self.assertEqual(lock.count, 7)
-        self.assertEqual(cond.wait_count, 3)
+        self.assertEqual(cond.wait_count, 0)
         self.assertEqual(cond.notify_count, 2)
 
     def test_decorator_lock_cond(self):
@@ -118,15 +118,15 @@ class DecoratorTestMixin(SimplifiedTestCaseProtocol):
         self.assertEqual(len(cache), 0)
         self.assertEqual(wrapper(0), 0)
         self.assertEqual(lock.count, 3)
-        self.assertEqual(cond.wait_count, 1)
+        self.assertEqual(cond.wait_count, 0)
         self.assertEqual(cond.notify_count, 1)
         self.assertEqual(wrapper(1), 1)
         self.assertEqual(lock.count, 6)
-        self.assertEqual(cond.wait_count, 2)
+        self.assertEqual(cond.wait_count, 0)
         self.assertEqual(cond.notify_count, 2)
         self.assertEqual(wrapper(1), 1)
         self.assertEqual(lock.count, 7)
-        self.assertEqual(cond.wait_count, 3)
+        self.assertEqual(cond.wait_count, 0)
         self.assertEqual(cond.notify_count, 2)
 
     def test_decorator_cond_error(self):
@@ -138,7 +138,7 @@ class DecoratorTestMixin(SimplifiedTestCaseProtocol):
             wrapper(0)
         self.assertEqual(len(cache), 0)
         self.assertEqual(lock.count, 2)
-        self.assertEqual(cond.wait_count, 1)
+        self.assertEqual(cond.wait_count, 0)
         self.assertEqual(cond.notify_count, 1)
 
         # verify pending set is cleaned up, otherwise this might deadlock
@@ -146,7 +146,7 @@ class DecoratorTestMixin(SimplifiedTestCaseProtocol):
             wrapper(0)
         self.assertEqual(len(cache), 0)
         self.assertEqual(lock.count, 4)
-        self.assertEqual(cond.wait_count, 2)
+        self.assertEqual(cond.wait_count, 0)
         self.assertEqual(cond.notify_count, 2)
 
     def test_decorator_wrapped(self):

{cachetools-7.2.5 → cachetools-7.2.6}/tests/test_cachedmethod.py

@@ -150,29 +150,29 @@ class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
 
         self.assertEqual(cached.get_cond(0), 0)
         self.assertEqual(cached.cond.count, 3)
-        self.assertEqual(cached.cond.wait_count, 1)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 1)
         self.assertEqual(cached.get_cond(1), 1)
         self.assertEqual(cached.cond.count, 6)
-        self.assertEqual(cached.cond.wait_count, 2)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 2)
         self.assertEqual(cached.get_cond(1), 1)
         self.assertEqual(cached.cond.count, 7)
-        self.assertEqual(cached.cond.wait_count, 3)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 2)
         self.assertEqual(cached.get_cond(1.0), 1)
         self.assertEqual(cached.cond.count, 8)
-        self.assertEqual(cached.cond.wait_count, 4)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 2)
         self.assertEqual(cached.get_cond(1.0), 1)
         self.assertEqual(cached.cond.count, 9)
-        self.assertEqual(cached.cond.wait_count, 5)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 2)
 
         cached.cache.clear()
         self.assertEqual(cached.get_cond(1), 2)
         self.assertEqual(cached.cond.count, 12)
-        self.assertEqual(cached.cond.wait_count, 6)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 3)
 
     def test_decorator_info(self):
@@ -255,19 +255,19 @@ class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
         self.assertEqual(cached.cond.count, 1)
         self.assertEqual(wrapper(0), 0)
         self.assertEqual(cached.cond.count, 4)
-        self.assertEqual(cached.cond.wait_count, 1)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 1)
         self.assertEqual(wrapper.cache_info(), (0, 1, maxsize, 1))
         self.assertEqual(cached.cond.count, 5)
         self.assertEqual(wrapper(1), 1)
         self.assertEqual(cached.cond.count, 8)
-        self.assertEqual(cached.cond.wait_count, 2)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 2)
         self.assertEqual(wrapper.cache_info(), (0, 2, maxsize, 2))
         self.assertEqual(cached.cond.count, 9)
         self.assertEqual(wrapper(0), 0)
         self.assertEqual(cached.cond.count, 10)
-        self.assertEqual(cached.cond.wait_count, 3)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 2)
         self.assertEqual(wrapper.cache_info(), (1, 2, maxsize, 2))
         self.assertEqual(cached.cond.count, 11)
@@ -279,13 +279,13 @@ class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
         self.assertEqual(cached.cond.count, 13)
         self.assertEqual(wrapper(0), 2)
         self.assertEqual(cached.cond.count, 16)
-        self.assertEqual(cached.cond.wait_count, 4)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 3)
         self.assertEqual(wrapper.cache_info(), (0, 1, maxsize, 1))
         self.assertEqual(cached.cond.count, 17)
         self.assertEqual(wrapper(0), 2)
         self.assertEqual(cached.cond.count, 18)
-        self.assertEqual(cached.cond.wait_count, 5)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 3)
         self.assertEqual(wrapper.cache_info(), (1, 1, maxsize, 1))
         self.assertEqual(cached.cond.count, 19)
@@ -306,19 +306,19 @@ class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
         self.assertEqual(cached.lock.count, 1)
         self.assertEqual(wrapper(0), 0)
         self.assertEqual(cached.lock.count, 4)
-        self.assertEqual(cached.cond.wait_count, 1)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 1)
         self.assertEqual(wrapper.cache_info(), (0, 1, maxsize, 1))
         self.assertEqual(cached.lock.count, 5)
         self.assertEqual(wrapper(1), 1)
         self.assertEqual(cached.lock.count, 8)
-        self.assertEqual(cached.cond.wait_count, 2)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 2)
         self.assertEqual(wrapper.cache_info(), (0, 2, maxsize, 2))
         self.assertEqual(cached.lock.count, 9)
         self.assertEqual(wrapper(0), 0)
         self.assertEqual(cached.lock.count, 10)
-        self.assertEqual(cached.cond.wait_count, 3)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 2)
         self.assertEqual(wrapper.cache_info(), (1, 2, maxsize, 2))
         self.assertEqual(cached.lock.count, 11)
@@ -330,13 +330,13 @@ class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
         self.assertEqual(cached.lock.count, 13)
         self.assertEqual(wrapper(0), 2)
         self.assertEqual(cached.lock.count, 16)
-        self.assertEqual(cached.cond.wait_count, 4)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 3)
         self.assertEqual(wrapper.cache_info(), (0, 1, maxsize, 1))
         self.assertEqual(cached.lock.count, 17)
         self.assertEqual(wrapper(0), 2)
         self.assertEqual(cached.lock.count, 18)
-        self.assertEqual(cached.cond.wait_count, 5)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 3)
         self.assertEqual(wrapper.cache_info(), (1, 1, maxsize, 1))
         self.assertEqual(cached.lock.count, 19)
@@ -352,14 +352,14 @@ class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
         with self.assertRaises(ValueError):
             cached.get_cond_error(0)
         self.assertEqual(cached.cond.count, 2)
-        self.assertEqual(cached.cond.wait_count, 1)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 1)
 
         # verify pending set is cleaned up, otherwise this might deadlock
         with self.assertRaises(ValueError):
             cached.get_cond_error(0)
         self.assertEqual(cached.cond.count, 4)
-        self.assertEqual(cached.cond.wait_count, 2)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 2)
 
     def test_decorator_wrapped(self):
@@ -701,36 +701,36 @@ class CacheMethodTest(unittest.TestCase, MethodDecoratorTestMixin):
 
         self.assertEqual(cached.get_cond(0), 0)
         self.assertEqual(cached.cond.count, 3)
-        self.assertEqual(cached.cond.wait_count, 1)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 1)
         self.assertEqual(cached.get_cond(1), 1)
         self.assertEqual(cached.cond.count, 6)
-        self.assertEqual(cached.cond.wait_count, 2)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 2)
         self.assertEqual(cached.get_cond(1), 2)
         self.assertEqual(cached.cond.count, 9)
-        self.assertEqual(cached.cond.wait_count, 3)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 3)
         self.assertEqual(cached.get_cond(1.0), 3)
         self.assertEqual(cached.cond.count, 12)
-        self.assertEqual(cached.cond.wait_count, 4)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 4)
         self.assertEqual(cached.get_cond(1.0), 4)
         self.assertEqual(cached.cond.count, 15)
-        self.assertEqual(cached.cond.wait_count, 5)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 5)
 
         self.assertEqual(cached.get_cond_info(0), 5)
         self.assertEqual(cached.cond.count, 18)
-        self.assertEqual(cached.cond.wait_count, 6)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 6)
         self.assertEqual(cached.get_cond_info(1), 6)
         self.assertEqual(cached.cond.count, 21)
-        self.assertEqual(cached.cond.wait_count, 7)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 7)
         self.assertEqual(cached.get_cond(1.0), 7)
         self.assertEqual(cached.cond.count, 24)
-        self.assertEqual(cached.cond.wait_count, 8)
+        self.assertEqual(cached.cond.wait_count, 0)
         self.assertEqual(cached.cond.notify_count, 8)
 
     def test_shared_cache(self):

{cachetools-7.2.5 → cachetools-7.2.6}/tests/test_keys.py

@@ -82,10 +82,9 @@ class CacheKeysTest(unittest.TestCase):
         import pickle
 
         for k in [key(), key("abc"), key("abc", 123), key("abc", q="abc")]:
-            # white-box test: assert cached hash value is not pickled
             self.assertEqual(len(k.__dict__), 0)
             h = hash(k)
-            self.assertEqual(len(k.__dict__), 1)
+            self.assertEqual(h, hash(tuple(k)))
             pickled = pickle.loads(pickle.dumps(k))
             self.assertEqual(len(pickled.__dict__), 0)
             self.assertEqual(k, pickled)

{cachetools-7.2.5 → cachetools-7.2.6}/tests/test_threading.py

@@ -1,9 +1,19 @@
 import unittest
-from threading import Barrier, Condition, Lock, Thread
+from threading import Barrier, Condition, Event, Lock, Thread
 
 from cachetools import LRUCache, cached, cachedmethod
 
 
+class WaitCondition(Condition):
+    def __init__(self):
+        super().__init__()
+        self.waiting = Event()
+
+    def wait(self, timeout=None):
+        self.waiting.set()
+        return super().wait(timeout)
+
+
 class ThreadingTest(unittest.TestCase):
     NTHREADS = 10
 
@@ -43,27 +53,66 @@ class ThreadingTest(unittest.TestCase):
         for info in (False, True):
             with self.subTest(info=info):
                 cache = LRUCache(1)
+                cond = WaitCondition()
+                started = Event()
+                release = Event()
+                calls = []
 
-                @cached(cache, condition=Condition(), info=info)
-                def func():
-                    result = object()
-                    return result
+                @cached(cache, condition=cond, info=info)
+                def func(calls=calls, started=started, release=release):
+                    calls.append(None)
+                    started.set()
+                    release.wait(self.TIMEOUT)
+                    return object()
 
-                self.run_cond_test(func, cache, info)
+                self.run_cond_wait_test(func, cond, started, release, calls)
 
     def test_cachedmethod_cond(self):
         for info in (False, True):
             with self.subTest(info=info):
                 cache = LRUCache(1)
-                cond = Condition()
+                cond = WaitCondition()
+                started = Event()
+                release = Event()
+                calls = []
 
                 class Cached:
                     @cachedmethod(lambda _: cache, condition=lambda _: cond, info=info)
-                    def method(self):
-                        result = object()
-                        return result
+                    def method(
+                        self,
+                        calls=calls,
+                        started=started,
+                        release=release,
+                        timeout=self.TIMEOUT,
+                    ):
+                        calls.append(None)
+                        started.set()
+                        release.wait(timeout)
+                        return object()
+
+                func = Cached().method
+                self.run_cond_wait_test(func, cond, started, release, calls)
+
+    def run_cond_wait_test(self, func, cond, started, release, calls):
+        results = [None] * 2
+
+        def run(index):
+            results[index] = func()
 
-                self.run_cond_test(Cached().method, cache, info)
+        first = Thread(target=run, args=[0])
+        first.start()
+        self.assertTrue(started.wait(self.TIMEOUT))
+        second = Thread(target=run, args=[1])
+        second.start()
+        # second caller must block on the pending key
+        self.assertTrue(cond.waiting.wait(self.TIMEOUT))
+        release.set()
+        for thread in (first, second):
+            thread.join(timeout=self.TIMEOUT)
+            self.assertFalse(thread.is_alive())
+        self.assertEqual(len(calls), 1)
+        self.assertIsNotNone(results[0])
+        self.assertIs(results[0], results[1])
 
     def run_lock_test(self, func, cache, info):
         self.run_threading_test(func, cache)