cachetools 7.2.5__tar.gz → 7.2.7__tar.gz

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

@@ -1,3 +1,17 @@
+v7.2.7 (2026-10-28)
+===================
+
+- Various performance improvements.
+
+- Minor unit test improvements.
+
+
+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.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachetools
-Version: 7.2.5
+Version: 7.2.7
 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.7}/src/cachetools/__init__.py

@@ -12,7 +12,7 @@ __all__ = (
     "cachedmethod",
 )
 
-__version__ = "7.2.5"
+__version__ = "7.2.7"
 
 import collections
 import collections.abc
@@ -24,30 +24,12 @@ import time
 from . import keys
 
 
-class _DefaultSize:
-    """A minimal "fake" dict that returns a constant size 1 for any key."""
-
-    __slots__ = ()
-
-    def __getitem__(self, _key):
-        return 1
-
-    def __setitem__(self, _key, _value):
-        pass
-
-    def pop(self, _key):
-        return 1
-
-    def clear(self):
-        pass
-
-
 class Cache(collections.abc.MutableMapping):
     """Mutable mapping to serve as a simple cache or cache base class."""
 
     __marker = object()
 
-    __size = _DefaultSize()
+    __size = None
 
     def __init__(self, maxsize, getsizeof=None):
         if maxsize < 0:
@@ -75,30 +57,48 @@ class Cache(collections.abc.MutableMapping):
             return self.__missing__(key)
 
     def __setitem__(self, key, value):
+        data = self.__data
+        size = self.__size
         maxsize = self.__maxsize
-        size = self.getsizeof(value)
-        if size < 0:
-            raise ValueError("value size must be non-negative")
-        if size > maxsize:
-            raise ValueError("value too large")
-        if key not in self.__data:
-            diffsize = size
-            while self.__currsize + diffsize > maxsize:
-                self.popitem()
+        if size is None:
+            if maxsize < 1:
+                raise ValueError("value too large")
+            elif key in data:
+                data[key] = value
+            else:
+                while self.__currsize + 1 > maxsize:
+                    self.popitem()
+                data[key] = value
+                self.__currsize += 1
         else:
-            diffsize = size - self.__size[key]
-            while self.__currsize + diffsize > maxsize:
-                self.popitem()
-                if key not in self.__data:
-                    diffsize = size
-        self.__data[key] = value
-        self.__size[key] = size
-        self.__currsize += diffsize
+            itemsize = self.getsizeof(value)
+            if itemsize > maxsize:
+                raise ValueError("value too large")
+            if itemsize < 0:
+                raise ValueError("value size must be non-negative")
+            if key not in data:
+                diffsize = itemsize
+                while self.__currsize + diffsize > maxsize:
+                    self.popitem()
+            else:
+                diffsize = itemsize - size[key]
+                while self.__currsize + diffsize > maxsize:
+                    self.popitem()
+                    if key not in data:
+                        diffsize = itemsize
+            data[key] = value
+            size[key] = itemsize
+            self.__currsize += diffsize
 
     def __delitem__(self, key):
-        size = self.__size.pop(key)
-        del self.__data[key]
-        self.__currsize -= size
+        size = self.__size
+        if size is None:
+            del self.__data[key]
+            self.__currsize -= 1
+        else:
+            itemsize = size.pop(key)
+            del self.__data[key]
+            self.__currsize -= itemsize
 
     def __contains__(self, key):
         return key in self.__data
@@ -148,8 +148,10 @@ class Cache(collections.abc.MutableMapping):
     # optimized version for each Cache subclass.
 
     def clear(self):
+        size = self.__size
+        if size is not None:
+            size.clear()
         self.__data.clear()
-        self.__size.clear()
         self.__currsize = 0
 
     @property
@@ -193,7 +195,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 +228,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 +261,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 +299,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 +320,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 +371,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,27 +494,28 @@ 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:
             expires = time + self.__ttl
             self.expire(time)
             cache_setitem(self, key, value)
-        try:
-            link = self.__getlink(key)
-        except KeyError:
-            self.__links[key] = link = TTLCache._Link(key)
+        links = self.__links
+        link = links.get(key)
+        if link is None:
+            links[key] = link = TTLCache._Link(key)
         else:
+            links.move_to_end(key)
             link.unlink()
         link.expires = expires
         link.next = root = self.__root
@@ -550,6 +563,8 @@ class TTLCache(_TimedCache):
             time = self.timer()
         root = self.__root
         curr = root.next
+        if curr is root or time < curr.expires:
+            return []  # fast path: nothing has expired
         links = self.__links
         expired = []
         cache_delitem = Cache.__delitem__
@@ -575,7 +590,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)
@@ -583,11 +600,6 @@ class TTLCache(_TimedCache):
         root.prev = root.next = root
         self.__links.clear()
 
-    def __getlink(self, key):
-        value = self.__links[key]
-        self.__links.move_to_end(key)
-        return value
-
 
 class TLRUCache(_TimedCache):
     """Time-aware Least Recently Used (TLRU) cache implementation."""
@@ -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:
@@ -643,11 +655,12 @@ class TLRUCache(_TimedCache):
             cache_setitem(self, key, value)
         # removing an existing item would break the heap structure, so
         # only mark it as removed for now
-        try:
-            self.__getitem(key).removed = True
-        except KeyError:
-            pass
-        self.__items[key] = item = TLRUCache._Item(key, expires)
+        items = self.__items
+        item = items.get(key)
+        if item is not None:
+            item.removed = True
+            items.move_to_end(key)
+        items[key] = item = TLRUCache._Item(key, expires)
         heapq.heappush(self.__order, item)
 
     def __delitem__(self, key, cache_delitem=Cache.__delitem__):
@@ -684,6 +697,8 @@ class TLRUCache(_TimedCache):
         if len(order) > len(items) * self.__HEAP_CLEANUP_FACTOR:
             self.__order = order = [item for item in order if not item.removed]
             heapq.heapify(order)
+        if not order or (not order[0].removed and time < order[0].expires):
+            return []  # fast path: nothing has expired
         expired = []
         cache_delitem = Cache.__delitem__
         cache_getitem = Cache.__getitem__
@@ -707,18 +722,15 @@ 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)
         self.__items.clear()
         del self.__order[:]
 
-    def __getitem(self, key):
-        value = self.__items[key]
-        self.__items.move_to_end(key)
-        return value
-
     def __delitem(self, key, cache_delitem=Cache.__delitem__):
         try:
             self.__items.pop(key).removed = True

{cachetools-7.2.5 → cachetools-7.2.7}/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.7}/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.7}/src/cachetools/_descriptor.py

@@ -46,46 +46,34 @@ class _MethodDescriptor:
             # objtype is not used for instance lookups, so it need not be bound here
             return self.__get_unbound()
         elif self.__attrname is not None:
-            # replace descriptor instance with wrapper in instance dict
-            wrapper = self.Wrapper(obj, self)  # type: ignore
-            try:
-                descriptor = next(
-                    (
-                        cls.__dict__[self.__attrname]
-                        for cls in type(obj).__mro__
-                        if self.__attrname in cls.__dict__
-                    ),
-                    None,
-                )
-                if descriptor is self:
-                    # In case of a race condition where another thread already replaced
-                    # the descriptor, prefer the initial wrapper.
+            descriptor = next(
+                (
+                    cls.__dict__[self.__attrname]
+                    for cls in type(obj).__mro__
+                    if self.__attrname in cls.__dict__
+                ),
+                None,
+            )
+            if descriptor is self:
+                # In case of a race condition where another thread already replaced
+                # the descriptor, prefer the initial wrapper.
+                wrapper = self.Wrapper(obj, self)  # type: ignore
+                try:
                     wrapper = obj.__dict__.setdefault(self.__attrname, wrapper)
-                else:
-                    # A super() lookup must neither reuse the override's wrapper
-                    # nor replace it, so preserve state separately for each descriptor.
+                except (AttributeError, TypeError) as e:
+                    self.__instance_dict_error(obj, e)
+            else:
+                # A super() lookup must neither reuse the override's wrapper
+                # nor replace it, so preserve state separately for each descriptor.
+                try:
                     wrappers = obj.__dict__.setdefault("__cachetools_cachedmethods", {})
+                except (AttributeError, TypeError) as e:
+                    self.__instance_dict_error(obj, e)
+                    wrappers = {}  # deprecated fallback: throwaway wrapper
+                wrapper = wrappers.get(self)
+                if wrapper is None:
+                    wrapper = self.Wrapper(obj, self)  # type: ignore
                     wrapper = wrappers.setdefault(self, wrapper)
-            except AttributeError:
-                # not all objects have __dict__ (e.g. class defines slots)
-                msg = (
-                    f"No '__dict__' attribute on {type(obj).__name__!r} "
-                    f"instance to cache {self.__attrname!r} property."
-                )
-                if self.__deprecated:
-                    _warn_instance_dict(msg, 3)
-                else:
-                    raise TypeError(msg) from None
-            except TypeError:
-                msg = (
-                    f"The '__dict__' attribute on {type(obj).__name__!r} "
-                    f"instance does not support item assignment for "
-                    f"caching {self.__attrname!r} property."
-                )
-                if self.__deprecated:
-                    _warn_instance_dict(msg, 3)
-                else:
-                    raise TypeError(msg) from None
         elif self.__deprecated:
             # deprecated @classmethod, warning already raised elsewhere
             wrapper = self.Wrapper(obj, self)  # type: ignore
@@ -110,6 +98,24 @@ class _MethodDescriptor:
             self.__unbound = _Unbound(self)
         return self.__unbound
 
+    def __instance_dict_error(self, obj, error):
+        if isinstance(error, AttributeError):
+            # not all objects have __dict__ (e.g. class defines slots)
+            msg = (
+                f"No '__dict__' attribute on {type(obj).__name__!r} "
+                f"instance to cache {self.__attrname!r}"
+            )
+        else:
+            # some objects may have an immutable __dict__
+            msg = (
+                f"The '__dict__' attribute on {type(obj).__name__!r} "
+                f"instance does not support item assignment for "
+                f"caching {self.__attrname!r}"
+            )
+        if not self.__deprecated:
+            raise TypeError(msg) from None
+        _warn_instance_dict(msg, 4)
+
 
 class _Unbound:
     """Callable returned on class access.

{cachetools-7.2.5 → cachetools-7.2.7}/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.7/src/cachetools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachetools
-Version: 7.2.5
+Version: 7.2.7
 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.7}/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.7}/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):
@@ -565,6 +565,15 @@ class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
             def get_info(self, value):
                 return value
 
+        class SlotsChild(Slots):
+            __slots__ = ()
+
+            def get(self, value):  # type: ignore
+                return super().get(value)
+
+            def get_info(self, value):  # type: ignore
+                return super().get_info(value)
+
         cache = self.cache(2)
         cached = Slots(cache)
 
@@ -579,6 +588,21 @@ class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
         self.assertEqual(len(w), 2)
         self.assertIs(w[0].category, DeprecationWarning)
         self.assertIs(w[1].category, DeprecationWarning)
+        self.assertEqual(w[0].filename, __file__)
+
+        child = SlotsChild(cache)
+
+        with self.assertRaisesRegex(TypeError, "No '__dict__' attribute"):
+            child.get_info(42)
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.assertEqual(child.get(0), 0)
+            self.assertEqual(child.get(0), 0)
+        self.assertEqual(len(w), 2)
+        self.assertIs(w[0].category, DeprecationWarning)
+        self.assertIs(w[1].category, DeprecationWarning)
+        self.assertEqual(w[0].filename, __file__)
 
     def test_decorator_immutable_dict(self):
 
@@ -602,6 +626,13 @@ class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
             def get_info(self, value):
                 return value
 
+        class ImmutableChild(Immutable):
+            def get(self, value):  # type: ignore
+                return super().get(value)
+
+            def get_info(self, value):  # type: ignore
+                return super().get_info(value)
+
         cache = self.cache(2)
         cached = Immutable(cache)
 
@@ -616,6 +647,48 @@ class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
         self.assertEqual(len(w), 2)
         self.assertIs(w[0].category, DeprecationWarning)
         self.assertIs(w[1].category, DeprecationWarning)
+        self.assertEqual(w[0].filename, __file__)
+
+        child = ImmutableChild(cache)
+
+        with self.assertRaisesRegex(TypeError, "does not support item assignment"):
+            child.get_info(42)
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.assertEqual(child.get(0), 0)
+            self.assertEqual(child.get(0), 0)
+        self.assertEqual(len(w), 2)
+        self.assertIs(w[0].category, DeprecationWarning)
+        self.assertIs(w[1].category, DeprecationWarning)
+        self.assertEqual(w[0].filename, __file__)
+
+    def test_decorator_wrapper_error(self):
+        # a non-callable key makes Wrapper.__init__ raise TypeError
+        class Cached:
+            def __init__(self, cache):
+                self.cache = cache
+
+            @cachedmethod(lambda self: self.cache, key=None)  # type: ignore
+            def get(self, value):
+                return value
+
+            @cachedmethod(lambda self: self.cache, key=None, info=True)  # type: ignore
+            def get_info(self, value):
+                return value
+
+        class CachedChild(Cached):
+            def get(self, value):  # type: ignore
+                return super().get(value)
+
+            def get_info(self, value):
+                return super().get_info(value)
+
+        cached = CachedChild(self.cache(2))
+        with self.assertRaisesRegex(TypeError, "must be callable"):
+            cached.get(0)
+        with self.assertRaisesRegex(TypeError, "must be callable"):
+            cached.get_info(0)
 
     def test_decorator_different_names(self):
         # RuntimeError for Python < 3.12, TypeError otherwise
@@ -701,36 +774,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.7}/tests/test_classmethod.py

@@ -36,6 +36,12 @@ class Cached:
         cls.count += 1
         return cls.count
 
+    @classmethod
+    @cachedmethod(lambda cls: cls.cache, info=True)
+    def get_info(cls, value):
+        cls.count += 1
+        return cls.count
+
 
 class CachedClassMethodTest(unittest.TestCase):
     def test(self):
@@ -114,6 +120,43 @@ class CachedClassMethodTest(unittest.TestCase):
         self.assertIs(w[0].category, DeprecationWarning)
         self.assertIs(w[1].category, DeprecationWarning)
 
+    def test_info(self):
+        # info=True requires an instance method, so calls fail on all
+        # supported Python versions
+        Cached.cache = LRUCache(2)
+        cached = Cached()
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            with self.assertRaises(TypeError):
+                cached.get_info(0)
+            with self.assertRaises(TypeError):
+                Cached.get_info(0)
+            self.assertEqual(len(Cached.cache), 0)
+
+    def test_shared_cache(self):
+        class Child(Cached):
+            pass
+
+        # cache is a class attribute, so it is shared with subclasses
+        Cached.cache = LRUCache(2)
+        Cached.count = 0
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            self.assertIs(Child.cache, Cached.cache)
+            self.assertEqual(Cached.get(0), 1)
+            self.assertEqual(Child.get(0), 1)
+            self.assertEqual(Child().get(0), 1)
+            self.assertEqual(len(Cached.cache), 1)
+            self.assertEqual(Child.get(1), 2)
+            self.assertEqual(Cached.get(1), 2)
+            self.assertEqual(len(Cached.cache), 2)
+
+            Child.get.cache_clear(Child)  # type: ignore
+            self.assertEqual(len(Cached.cache), 0)
+            self.assertEqual(Cached.get(0), 2)
+
     def test_clear(self):
         Cached.cache = LRUCache(2)
         Cached.count = 0

{cachetools-7.2.5 → cachetools-7.2.7}/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.7}/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)