cachetools 7.2.0__tar.gz → 7.2.2__tar.gz

{cachetools-7.2.0 → cachetools-7.2.2}/CHANGELOG.rst

@@ -1,3 +1,29 @@
+v7.2.2 (2026-10-15)
+===================
+
+- Fix ``@cachedmethod`` for subclasses that override a decorated
+  method and call the base class implementation via ``super()``.
+
+- Restore class access to instance methods decorated with
+  ``@cachedmethod``.
+
+- Improve ``TTLCache`` robustness when calculating expiration time
+  fails.
+
+- Various unit test improvements.
+
+
+v7.2.1 (2026-10-05)
+===================
+
+- Improve error handling for ``RRCache.popitem()`` when the cache is
+  empty.
+
+- Minor style and documentation improvements.
+
+- Update CI environment.
+
+
 v7.2.0 (2026-09-16)
 ===================
 

{cachetools-7.2.0/src/cachetools.egg-info → cachetools-7.2.2}/PKG-INFO

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

{cachetools-7.2.0 → cachetools-7.2.2}/docs/index.rst

@@ -756,8 +756,9 @@ this module provides several memoizing function decorators with a
 similar API.  All these decorators wrap a function with a memoizing
 callable that saves up to the `maxsize` most recent calls, using
 different caching strategies.  If `maxsize` is set to :const:`None`,
-the caching strategy is effectively disabled and the cache can grow
-without bound.
+the size limit is disabled and the cache can grow without bound.
+For :func:`ttl_cache`, the time-to-live still applies, so cached
+results expire after `ttl` even without a size limit.
 
 If the optional argument `typed` is set to :const:`True`, function
 arguments of different types will be cached separately.  For example,

{cachetools-7.2.0 → cachetools-7.2.2}/pyproject.toml

@@ -50,9 +50,6 @@ version = {attr = "cachetools.__version__"}
 
 [tool.pyright]
 typeCheckingMode = "standard"
-reportFunctionMemberAccess = "information"
-reportOptionalContextManager = "warning"
-reportOptionalMemberAccess = "warning"
 
 [tool.ruff.lint]
 ignore = ["DTZ005", "UP031"]

{cachetools-7.2.0 → cachetools-7.2.2}/src/cachetools/__init__.py

@@ -12,7 +12,7 @@ __all__ = (
     "cachedmethod",
 )
 
-__version__ = "7.2.0"
+__version__ = "7.2.2"
 
 import collections
 import collections.abc
@@ -52,7 +52,7 @@ class Cache(collections.abc.MutableMapping):
     def __init__(self, maxsize, getsizeof=None):
         if maxsize < 0:
             raise ValueError("maxsize must be non-negative")
-        if getsizeof:
+        if getsizeof is not None:
             self.getsizeof = getsizeof
         if self.getsizeof is not Cache.getsizeof:
             self.__size = {}
@@ -357,12 +357,11 @@ class RRCache(Cache):
 
     def popitem(self):
         """Remove and return a random `(key, value)` pair."""
-        try:
-            key = self.__choice(self.__keys)
-        except IndexError:
+        keys = self.__keys
+        if not keys:
             raise KeyError("%s is empty" % type(self).__name__) from None
-        else:
-            return (key, self.pop(key))
+        key = self.__choice(keys)
+        return (key, self.pop(key))
 
     def clear(self):
         Cache.clear(self)
@@ -496,6 +495,7 @@ class TTLCache(_TimedCache):
 
     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:
@@ -504,7 +504,7 @@ class TTLCache(_TimedCache):
             self.__links[key] = link = TTLCache._Link(key)
         else:
             link.unlink()
-        link.expires = time + self.__ttl
+        link.expires = expires
         link.next = root = self.__root
         link.prev = prev = root.prev
         prev.next = root.prev = link

{cachetools-7.2.0 → cachetools-7.2.2}/src/cachetools/__init__.pyi

@@ -191,6 +191,17 @@ def cached(
     info: Literal[True],
 ) -> Callable[[Callable[_P, _R]], _cached_wrapper_info[_P, _R]]: ...
 
+@type_check_only
+class _cachedmethod_unbound(Generic[_P, _R]):
+    __wrapped__: Callable[Concatenate[Any, _P], _R]
+    __name__: str
+    __doc__: str | None
+    @overload
+    def __call__(self, obj: Any, /, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
+    # deprecated @classmethod use
+    @overload
+    def __call__(self, /, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
+
 @type_check_only
 class _cachedmethod_wrapper(Generic[_P, _R]):
     __wrapped__: Callable[Concatenate[Any, _P], _R]
@@ -201,6 +212,11 @@ class _cachedmethod_wrapper(Generic[_P, _R]):
     cache_lock: AbstractContextManager[Any] | None = None
     cache_condition: _AbstractCondition | None = None
     def __set_name__(self, owner: type, name: str) -> None: ...
+    @overload
+    def __get__(
+        self, obj: None, objtype: type | None = None
+    ) -> _cachedmethod_unbound[_P, _R]: ...
+    @overload
     def __get__(
         self, obj: Any, objtype: type | None = None
     ) -> _cachedmethod_wrapper[_P, _R]: ...
@@ -209,6 +225,11 @@ class _cachedmethod_wrapper(Generic[_P, _R]):
 
 @type_check_only
 class _cachedmethod_wrapper_info(_cachedmethod_wrapper[_P, _R]):
+    @overload
+    def __get__(
+        self, obj: None, objtype: type | None = None
+    ) -> _cachedmethod_unbound[_P, _R]: ...
+    @overload
     def __get__(
         self, obj: Any, objtype: type | None = None
     ) -> _cachedmethod_wrapper_info[_P, _R]: ...

{cachetools-7.2.0 → cachetools-7.2.2}/src/cachetools/_cached.py

@@ -1,5 +1,7 @@
 """Function decorator helpers."""
 
+# pyright: reportFunctionMemberAccess=false
+
 __all__ = ()
 
 import functools

{cachetools-7.2.0 → cachetools-7.2.2}/src/cachetools/_cachedmethod.py

@@ -1,26 +1,13 @@
 """Method decorator helpers."""
 
+# pyright: reportOptionalContextManager=false, reportOptionalMemberAccess=false
+
 __all__ = ()
 
 import functools
-import warnings
 import weakref
 
-
-def _warn_classmethod(stacklevel):
-    warnings.warn(
-        "decorating class methods with @cachedmethod is deprecated",
-        DeprecationWarning,
-        stacklevel=stacklevel,
-    )
-
-
-def _warn_instance_dict(msg, stacklevel):
-    warnings.warn(
-        msg,
-        DeprecationWarning,
-        stacklevel=stacklevel,
-    )
+from ._descriptor import _ClassMethodDescriptor, _MethodDescriptor, _warn_classmethod
 
 
 def _none(_):
@@ -63,82 +50,6 @@ class _WrapperBase:
         return self.__cond(self._obj)
 
 
-class _DescriptorBase:
-    """Descriptor base class implementing the basic descriptor protocol."""
-
-    def __init__(self, deprecated=False):
-        self.__attrname = None
-        self.__deprecated = deprecated
-
-    def __set_name__(self, owner, name):
-        if self.__attrname is None:
-            self.__attrname = name
-        elif name != self.__attrname:
-            raise TypeError(
-                "Cannot assign the same @cachedmethod to two different names "
-                f"({self.__attrname!r} and {name!r})."
-            )
-
-    def __get__(self, obj, objtype=None):
-        wrapper = self.Wrapper(obj)  # type: ignore
-        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
-                # the descriptor, prefer the initial wrapper.
-                wrapper = obj.__dict__.setdefault(self.__attrname, 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:
-            pass  # deprecated @classmethod, warning already raised elsewhere
-        else:
-            msg = "Cannot use @cachedmethod instance without calling __set_name__ on it"
-            raise TypeError(msg) from None
-        return wrapper
-
-
-class _DeprecatedDescriptorBase(_DescriptorBase):
-    """Descriptor base class supporting deprecated @classmethod use."""
-
-    def __init__(self, wrapper, cache_clear):
-        super().__init__(deprecated=True)
-        self.__wrapper = wrapper
-        self.__cache_clear = cache_clear
-
-    # called for @classmethod with Python >= 3.13
-    def __call__(self, *args, **kwargs):
-        _warn_classmethod(stacklevel=3)
-        return self.__wrapper(*args, **kwargs)
-
-    # backward-compatible @classmethod handling with Python >= 3.13
-    def cache_clear(self, objtype):
-        _warn_classmethod(stacklevel=3)
-        return self.__cache_clear(objtype)
-
-
 # At least for now, the implementation prefers clarity and performance
 # over ease of maintenance, thus providing separate descriptors for
 # all valid combinations of decorator parameters lock, condition and
@@ -146,7 +57,7 @@ class _DeprecatedDescriptorBase(_DescriptorBase):
 
 
 def _condition_info(method, cache, key, lock, cond, info):
-    class Descriptor(_DescriptorBase):
+    class Descriptor(_MethodDescriptor):
         class Wrapper(_WrapperBase):
             def __init__(self, obj):
                 super().__init__(obj, method, cache, key, lock, cond)
@@ -194,7 +105,7 @@ def _condition_info(method, cache, key, lock, cond, info):
 
 
 def _locked_info(method, cache, key, lock, info):
-    class Descriptor(_DescriptorBase):
+    class Descriptor(_MethodDescriptor):
         class Wrapper(_WrapperBase):
             def __init__(self, obj):
                 super().__init__(obj, method, cache, key, lock)
@@ -234,7 +145,7 @@ def _locked_info(method, cache, key, lock, info):
 
 
 def _unlocked_info(method, cache, key, info):
-    class Descriptor(_DescriptorBase):
+    class Descriptor(_MethodDescriptor):
         class Wrapper(_WrapperBase):
             def __init__(self, obj):
                 super().__init__(obj, method, cache, key)
@@ -301,7 +212,7 @@ def _condition(method, cache, key, lock, cond):
         p = pending.setdefault(self, set())
         return wrapper(self, p, *args, **kwargs)
 
-    class Descriptor(_DeprecatedDescriptorBase):
+    class Descriptor(_ClassMethodDescriptor):
         class Wrapper(_WrapperBase):
             def __init__(self, obj):
                 super().__init__(obj, method, cache, key, lock, cond)
@@ -341,7 +252,7 @@ def _locked(method, cache, key, lock):
         with lock(self):
             c.clear()
 
-    class Descriptor(_DeprecatedDescriptorBase):
+    class Descriptor(_ClassMethodDescriptor):
         class Wrapper(_WrapperBase):
             def __init__(self, obj):
                 super().__init__(obj, method, cache, key, lock)
@@ -375,7 +286,7 @@ def _unlocked(method, cache, key):
         c = cache(self)
         c.clear()
 
-    class Descriptor(_DeprecatedDescriptorBase):
+    class Descriptor(_ClassMethodDescriptor):
         class Wrapper(_WrapperBase):
             def __init__(self, obj):
                 super().__init__(obj, method, cache, key)

cachetools-7.2.2/src/cachetools/_descriptor.py

@@ -0,0 +1,126 @@
+"""Descriptor helpers."""
+
+__all__ = ()
+
+import functools
+import warnings
+
+
+def _warn_classmethod(stacklevel):
+    warnings.warn(
+        "decorating class methods with @cachedmethod is deprecated",
+        DeprecationWarning,
+        stacklevel=stacklevel,
+    )
+
+
+def _warn_instance_dict(msg, stacklevel):
+    warnings.warn(
+        msg,
+        DeprecationWarning,
+        stacklevel=stacklevel,
+    )
+
+
+class _MethodDescriptor:
+    """Descriptor class implementing the basic descriptor protocol."""
+
+    def __init__(self, deprecated=False):
+        self.__attrname = None
+        self.__deprecated = deprecated
+        self.__unbound = None
+
+    def __set_name__(self, owner, name):
+        if self.__attrname is None:
+            self.__attrname = name
+        elif name != self.__attrname:
+            raise TypeError(
+                "Cannot assign the same @cachedmethod to two different names "
+                f"({self.__attrname!r} and {name!r})."
+            )
+
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            # 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)  # 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.
+                    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.
+                    wrappers = obj.__dict__.setdefault("__cachetools_cachedmethods", {})
+                    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)  # type: ignore
+        else:
+            msg = "Cannot use @cachedmethod instance without calling __set_name__ on it"
+            raise TypeError(msg) from None
+        return wrapper
+
+    def __get_unbound(self):
+        # 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
+
+            # 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 _ClassMethodDescriptor(_MethodDescriptor):
+    """Descriptor base class supporting deprecated @classmethod use."""
+
+    def __init__(self, wrapper, cache_clear):
+        super().__init__(deprecated=True)
+        self.__wrapper = wrapper
+        self.__cache_clear = cache_clear
+
+    # called for @classmethod with Python >= 3.13
+    def __call__(self, *args, **kwargs):
+        _warn_classmethod(stacklevel=3)
+        return self.__wrapper(*args, **kwargs)
+
+    # backward-compatible @classmethod handling with Python >= 3.13
+    def cache_clear(self, objtype):
+        _warn_classmethod(stacklevel=3)
+        return self.__cache_clear(objtype)

{cachetools-7.2.0 → cachetools-7.2.2/src/cachetools.egg-info}/PKG-INFO

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

{cachetools-7.2.0 → cachetools-7.2.2}/src/cachetools.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/cachetools/__init__.py
 src/cachetools/__init__.pyi
 src/cachetools/_cached.py
 src/cachetools/_cachedmethod.py
+src/cachetools/_descriptor.py
 src/cachetools/func.py
 src/cachetools/func.pyi
 src/cachetools/keys.py

{cachetools-7.2.0 → cachetools-7.2.2}/tests/__init__.py

@@ -5,7 +5,7 @@ from typing import Any, Protocol
 import cachetools
 
 
-class _TestCaseProtocol(Protocol):
+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: ...
     def assertTrue(self, expr: Any, msg: Any = None) -> None: ...
@@ -29,7 +29,7 @@ class _TestCaseProtocol(Protocol):
     ) -> Any: ...
 
 
-class CacheTestMixin(_TestCaseProtocol):
+class CacheTestMixin(SimplifiedTestCaseProtocol):
     Cache: type[cachetools.Cache]
 
     def test_defaults(self):

{cachetools-7.2.0 → cachetools-7.2.2}/tests/test_cached.py

@@ -4,10 +4,10 @@ import warnings
 import cachetools
 import cachetools.keys
 
-from . import CountedCondition, CountedLock, _TestCaseProtocol
+from . import CountedCondition, CountedLock, SimplifiedTestCaseProtocol
 
 
-class DecoratorTestMixin(_TestCaseProtocol):
+class DecoratorTestMixin(SimplifiedTestCaseProtocol):
     def cache(self, minsize):
         raise NotImplementedError
 
@@ -380,6 +380,27 @@ class CacheWrapperTest(unittest.TestCase, DecoratorTestMixin):
         self.assertEqual(wrapper.cache_info(), (0, 1, 0, 0))
         self.assertEqual(lock.count, 5)
 
+    def test_decorator_method(self):
+        """Though it is not encouraged, like functools.lru_cache, the
+        @cached decorator may be used on methods, too.
+
+        """
+
+        class Cached:
+            @cachetools.cached(self.cache(2), key=cachetools.keys.methodkey, info=True)
+            def get(self, value):
+                return value
+
+        cached = Cached()
+        self.assertEqual(cached.get(1), 1)  # type: ignore
+        self.assertEqual(cached.get(1), 1)  # type: ignore
+        self.assertEqual(Cached.get(cached, 1), 1)
+        self.assertEqual(cached.get.cache_info(), (2, 1, 2, 1))
+        self.assertEqual(Cached.get.cache_info(), (2, 1, 2, 1))
+        cached.get.cache_clear()
+        self.assertEqual(cached.get.cache_info(), (0, 0, 2, 0))
+        self.assertEqual(Cached.get.cache_info(), (0, 0, 2, 0))
+
 
 class DictWrapperTest(unittest.TestCase, DecoratorTestMixin):
     def cache(self, minsize):

{cachetools-7.2.0 → cachetools-7.2.2}/tests/test_cachedmethod.py

@@ -1,10 +1,12 @@
+# TODO: type stub overloads for unbound methods?
+# pyright: reportCallIssue=false
+
 import unittest
-import unittest.mock
 import warnings
 
 from cachetools import Cache, cachedmethod, keys
 
-from . import CountedCondition, CountedLock, _TestCaseProtocol
+from . import CountedCondition, CountedLock, SimplifiedTestCaseProtocol
 
 
 class Cached:
@@ -77,7 +79,7 @@ class Unhashable(Cached):
         raise TypeError("unhashable type")
 
 
-class MethodDecoratorTestMixin(_TestCaseProtocol):
+class MethodDecoratorTestMixin(SimplifiedTestCaseProtocol):
     def cache(self, _minsize, **_kwargs):
         raise NotImplementedError
 
@@ -632,6 +634,69 @@ class CacheMethodTest(unittest.TestCase, MethodDecoratorTestMixin):
         self.assertEqual(cached.get(2), 2)
         self.assertNotIn(2, cache.values())
 
+    def test_undecorated_override(self):
+        class Child(Cached):
+            def get_info(self, value):  # type: ignore[reportIncompatibleVariableOverride]
+                return super().get_info(value) + 1
+
+        cache = self.cache(2)
+        cached = Child(cache)
+        self.assertEqual(cached.get_info(0), 1)
+        self.assertEqual(cached.get_info(0), 1)
+        self.assertEqual(super(Child, cached).get_info(0), 0)
+        self.assertEqual(cached.get_info(1), 2)
+        self.assertEqual(super(Child, cached).get_info(1), 1)
+        self.assertNotIn("get_info", vars(cached))
+        self.assertEqual(super(Child, cached).get_info.cache_info(), (3, 2, 2, 2))
+
+    def test_decorated_override(self):
+        class Child(Cached):
+            def __init__(self, base_cache, child_cache):
+                super().__init__(base_cache)
+                self.child_cache = child_cache
+
+            @cachedmethod(lambda self: self.child_cache, info=True)
+            def get_info(self, value):
+                return super().get_info(value) + 1
+
+        cached = Child(self.cache(2), self.cache(2))
+        self.assertEqual(cached.get_info(0), 1)
+        self.assertEqual(cached.get_info(0), 1)
+        self.assertEqual(super(Child, cached).get_info(0), 0)
+        self.assertEqual(cached.get_info(1), 2)
+        self.assertEqual(super(Child, cached).get_info(1), 1)
+        self.assertIn("get_info", vars(cached))
+        self.assertEqual(cached.get_info.cache_info(), (1, 2, 2, 2))
+        self.assertEqual(super(Child, cached).get_info.cache_info(), (2, 2, 2, 2))
+        cached.get_info.cache_clear()
+        self.assertEqual(cached.get_info.cache_info(), (0, 0, 2, 0))
+        self.assertEqual(super(Child, cached).get_info.cache_info(), (2, 2, 2, 2))
+        self.assertEqual(cached.get_info(0), 1)
+        self.assertEqual(cached.get_info.cache_info(), (0, 1, 2, 1))
+        self.assertEqual(super(Child, cached).get_info.cache_info(), (3, 2, 2, 2))
+        super(Child, cached).get_info.cache_clear()
+        self.assertEqual(cached.get_info.cache_info(), (0, 1, 2, 1))
+        self.assertEqual(super(Child, cached).get_info.cache_info(), (0, 0, 2, 0))
+
+    def test_multilevel_override(self):
+        class Child(Cached):
+            @cachedmethod(lambda self: self.cache, key=keys.typedmethodkey)
+            def get_typed(self, value):
+                return super().get_typed(float(value)) + 1
+
+        class GrandChild(Child):
+            @cachedmethod(lambda self: self.cache, key=keys.typedmethodkey, info=True)
+            def get_typed(self, value):
+                return super().get_typed(int(value)) + 1
+
+        cache = self.cache(5)  # shared cache, but different key types
+        cached = GrandChild(cache)
+        self.assertEqual(cached.get_typed("0"), 2)
+        self.assertEqual(cached.get_typed("0"), 2)
+        self.assertEqual(cached.get_typed.cache_info(), (1, 1, 5, 3))
+        self.assertEqual(super(GrandChild, cached).get_typed(0), 1)
+        self.assertEqual(super(Child, cached).get_typed(0.0), 0)
+
 
 class DictMethodTest(unittest.TestCase, MethodDecoratorTestMixin):
     def cache(self, minsize, **_kwargs):
@@ -683,8 +748,51 @@ class NoneMethodTest(unittest.TestCase):
             wrapper.cache_info()
 
 
-class AutospecTest(unittest.TestCase):
+class UnboundMethodTest(unittest.TestCase):
+    def test_class_call(self):
+        cached = Cached(Cache(2))
+        self.assertEqual(Cached.get(cached, 1), 0)
+        self.assertEqual(cached.get(1), 0)
+        self.assertEqual(Cached.get(cached, 2), 1)
+        self.assertEqual(cached.get(2), 1)
+        self.assertEqual(cached.count, 2)
+        other = Cached(Cache(2), count=10)
+        self.assertEqual(Cached.get(other, 1), 10)
+        self.assertEqual(cached.get(1), 0)
+
+    def test_class_call_info(self):
+        cached = Cached(Cache(2))
+        self.assertEqual(Cached.get_info(cached, 1), 0)
+        self.assertEqual(cached.get_info(1), 0)
+        self.assertEqual(Cached.get_info(cached, 2), 1)
+        self.assertEqual(cached.get_info(2), 1)
+        self.assertEqual(cached.count, 2)
+        self.assertEqual(cached.get_info.cache_info(), (2, 2, 2, 2))
+        other = Cached(Cache(2), count=10)
+        self.assertEqual(Cached.get_info(other, 1), 10)
+        self.assertEqual(cached.get_info(1), 0)
+
+    def test_base_class_call(self):
+        cached = Unhashable(Cache(2))
+        self.assertEqual(Cached.get(cached, 1), 0)
+        self.assertEqual(cached.get(1), 0)
+        self.assertEqual(cached.count, 1)
+
+    def test_class_access_identity(self):
+        self.assertIs(Cached.get, Cached.get)
+        self.assertIs(Cached.get_info, Cached.get_info)
+        self.assertIs(Unhashable.get, Cached.get)
+        self.assertIsNot(Cached.get, Cached.get_info)
+
+    def test_wrapped_method(self):
+        cached = Cached(Cache(2))
+        self.assertIs(Cached.get.__wrapped__, cached.get.__wrapped__)
+        self.assertEqual(Cached.get.__wrapped__(cached, 1), 0)
+        self.assertEqual(Cached.get.__wrapped__(cached, 1), 1)
+        self.assertEqual(len(cached.cache), 0)
+
     def test_autospec_no_warnings(self):
+        import unittest.mock
 
         with warnings.catch_warnings(record=True) as w:
             warnings.simplefilter("always")

{cachetools-7.2.0 → cachetools-7.2.2}/tests/test_func.py

@@ -4,10 +4,10 @@ from typing import Any
 
 import cachetools.func
 
-from . import _TestCaseProtocol
+from . import SimplifiedTestCaseProtocol
 
 
-class DecoratorTestMixin(_TestCaseProtocol):
+class DecoratorTestMixin(SimplifiedTestCaseProtocol):
     DECORATOR: Callable[..., Any]
 
     def decorator(self, maxsize, **kwargs):
@@ -109,6 +109,29 @@ class DecoratorTestMixin(_TestCaseProtocol):
         # Then do a call which will cause a deadlock with a non-reentrant lock.
         self.assertEqual(cached(RecursiveEquals(True)), RecursiveEquals(True))
 
+    def test_decorator_method(self):
+        """Though it is not encouraged, like functools.lru_cache, the
+        cachetools.func decorators may be used on methods, too.
+
+        """
+
+        decorator = self.decorator(maxsize=2)
+
+        class Cached:
+            @decorator
+            def get(self, n):
+                return n
+
+        cached = Cached()
+        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(Cached.get(cached, 1), 1)
+        self.assertEqual(cached.get.cache_info(), (2, 1, 2, 1))
+        self.assertEqual(Cached.get.cache_info(), (2, 1, 2, 1))
+        cached.get.cache_clear()
+        self.assertEqual(cached.get.cache_info(), (0, 0, 2, 0))
+        self.assertEqual(Cached.get.cache_info(), (0, 0, 2, 0))
+
 
 class FIFODecoratorTest(unittest.TestCase, DecoratorTestMixin):
     DECORATOR = staticmethod(cachetools.func.fifo_cache)

{cachetools-7.2.0 → cachetools-7.2.2}/tests/test_rr.py

@@ -86,3 +86,18 @@ class RRCacheTest(unittest.TestCase, CacheTestMixin):
     def test_rr_default_choice(self):
         cache = RRCache[int, int](maxsize=2)
         self.assertIs(cache.choice, random.choice)
+
+    def test_rr_popitem_empty_custom_choice(self):
+        # a custom `choice` function only has to handle non-empty
+        # sequences, so an empty cache has to be detected beforehand
+        for choice in (min, max, lambda seq: next(iter(seq))):
+            cache = RRCache[int, int](maxsize=2, choice=choice)
+
+            with self.assertRaises(KeyError):
+                cache.popitem()
+
+            cache[1] = 1
+            self.assertEqual((1, 1), cache.popitem())
+
+            with self.assertRaises(KeyError):
+                cache.popitem()

cachetools-7.2.2/tests/test_threading.py

@@ -0,0 +1,103 @@
+import unittest
+from threading import Barrier, Condition, Lock, Thread
+
+from cachetools import LRUCache, cached, cachedmethod
+
+
+class ThreadingTest(unittest.TestCase):
+    NTHREADS = 10
+
+    TIMEOUT = 10
+
+    def test_cached_lock(self):
+        for info in (False, True):
+            with self.subTest(info=info):
+                barrier = Barrier(self.NTHREADS, timeout=self.TIMEOUT)
+                cache = LRUCache(1)
+
+                @cached(cache, lock=Lock(), info=info)
+                def func(barrier=barrier):
+                    result = object()
+                    barrier.wait()
+                    return result
+
+                self.run_lock_test(func, cache, info)
+
+    def test_cachedmethod_lock(self):
+        for info in (False, True):
+            with self.subTest(info=info):
+                barrier = Barrier(self.NTHREADS, timeout=self.TIMEOUT)
+                cache = LRUCache(1)
+                lock = Lock()
+
+                class Cached:
+                    @cachedmethod(lambda _: cache, lock=lambda _: lock, info=info)
+                    def method(self, barrier=barrier):
+                        result = object()
+                        barrier.wait()
+                        return result
+
+                self.run_lock_test(Cached().method, cache, info)
+
+    def test_cached_cond(self):
+        for info in (False, True):
+            with self.subTest(info=info):
+                cache = LRUCache(1)
+
+                @cached(cache, condition=Condition(), info=info)
+                def func():
+                    result = object()
+                    return result
+
+                self.run_cond_test(func, cache, info)
+
+    def test_cachedmethod_cond(self):
+        for info in (False, True):
+            with self.subTest(info=info):
+                cache = LRUCache(1)
+                cond = Condition()
+
+                class Cached:
+                    @cachedmethod(lambda _: cache, condition=lambda _: cond, info=info)
+                    def method(self):
+                        result = object()
+                        return result
+
+                self.run_cond_test(Cached().method, cache, info)
+
+    def run_lock_test(self, func, cache, info):
+        self.run_threading_test(func, cache)
+
+        if info:
+            cache_info = func.cache_info()
+            self.assertEqual(cache_info.hits + cache_info.misses, self.NTHREADS)
+            self.assertGreaterEqual(cache_info.misses, 1)
+
+    def run_cond_test(self, func, cache, info):
+        self.run_threading_test(func, cache)
+
+        if info:
+            cache_info = func.cache_info()
+            self.assertEqual(cache_info.hits, self.NTHREADS - 1)
+            self.assertEqual(cache_info.misses, 1)
+
+    def run_threading_test(self, func, cache):
+        results = [None] * self.NTHREADS
+
+        def run(index):
+            results[index] = func()
+
+        threads = [Thread(target=run, args=[i]) for i in range(self.NTHREADS)]
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join(timeout=self.TIMEOUT)
+            self.assertFalse(thread.is_alive())
+        self.assertEqual(len(cache), 1)
+
+        # multiple threads may compute the value, but the first one
+        # should always win and all concurrent invocations should
+        # return the same result
+        cached_result = next(iter(cache.values()))
+        for result in results:
+            self.assertIs(result, cached_result)

{cachetools-7.2.0 → cachetools-7.2.2}/tests/test_ttl.py

@@ -218,6 +218,22 @@ class TTLCacheTest(unittest.TestCase, CacheTestMixin):
         self.assertEqual([(1, 1)], list(items))
         self.assertEqual(0, len(cache))
 
+    def test_ttl_datetime_overflow(self):
+        from datetime import datetime, timedelta
+
+        cache = TTLCache[str, int, datetime](
+            maxsize=1, ttl=timedelta(days=1), timer=lambda: datetime.max
+        )
+
+        with self.assertRaises(OverflowError):
+            cache["overflow"] = 1
+
+        self.assertNotIn("overflow", cache)
+        self.assertEqual(0, len(cache))
+        self.assertEqual(0, cache.currsize)
+        self.assertEqual([], list(cache))
+        self.assertEqual([], cache.expire())
+
     def test_ttl_clear(self):
         cache = TTLCache[int, int, int](maxsize=2, ttl=2, timer=Timer())
 

cachetools-7.2.0/tests/test_threading.py

@@ -1,122 +0,0 @@
-import threading
-import time
-import unittest
-from typing import Any
-
-from cachetools import LRUCache, cached, cachedmethod
-
-count = 0
-
-
-@cached(cache=LRUCache(1), condition=threading.Condition(), info=True)
-def func():
-    global count
-    time.sleep(1.0)
-    count += 1
-    return count
-
-
-@cached(cache=LRUCache(1), lock=threading.Lock(), info=True)
-def locked_func():
-    global count
-    time.sleep(1.0)
-    count += 1
-    return 42
-
-
-class ThreadingTest(unittest.TestCase):
-    NTHREADS = 10
-
-    TIMEOUT = 10
-
-    cache: LRUCache[Any, int] = LRUCache(1)
-
-    cond = threading.Condition()
-
-    lock = threading.Lock()
-
-    count = 0
-
-    @cachedmethod(
-        cache=lambda self: self.cache, condition=lambda self: self.cond, info=True
-    )
-    def method(self):
-        time.sleep(1.0)
-        self.count += 1
-        return 42
-
-    @cachedmethod(cache=lambda self: self.cache, lock=lambda self: self.lock, info=True)
-    def locked_method(self):
-        time.sleep(1.0)
-        self.count += 1
-        return 42
-
-    def test_cached_stampede(self):
-        global count
-        count = 0
-        threads = [threading.Thread(target=func) for i in range(self.NTHREADS)]
-        for t in threads:
-            t.start()
-        for t in threads:
-            t.join(timeout=self.TIMEOUT)
-            self.assertFalse(t.is_alive())
-
-        self.assertEqual(count, 1)
-
-        info = func.cache_info()
-        self.assertEqual(info.hits, self.NTHREADS - 1)
-        self.assertEqual(info.misses, 1)
-
-    def test_cachedmethod_stampede(self):
-        self.cache = LRUCache(1)
-        self.count = 0
-        threads = [threading.Thread(target=self.method) for i in range(self.NTHREADS)]
-        for t in threads:
-            t.start()
-        for t in threads:
-            t.join(timeout=self.TIMEOUT)
-            self.assertFalse(t.is_alive())
-
-        self.assertEqual(self.count, 1)
-
-        info = self.method.cache_info()
-        self.assertEqual(info.hits, self.NTHREADS - 1)
-        self.assertEqual(info.misses, 1)
-
-    def test_cached_locked(self):
-        global count
-        count = 0
-        threads = [threading.Thread(target=locked_func) for i in range(self.NTHREADS)]
-        for t in threads:
-            t.start()
-        for t in threads:
-            t.join(timeout=self.TIMEOUT)
-            self.assertFalse(t.is_alive())
-
-        # Without condition/stampede prevention, func is called by multiple
-        # threads, but all return the same cached value (42).
-        self.assertGreaterEqual(count, 1)
-
-        info = locked_func.cache_info()
-        self.assertEqual(info.hits + info.misses, self.NTHREADS)
-        self.assertGreaterEqual(info.misses, 1)
-
-    def test_cachedmethod_locked(self):
-        self.cache = LRUCache(1)
-        self.count = 0
-        threads = [
-            threading.Thread(target=self.locked_method) for i in range(self.NTHREADS)
-        ]
-        for t in threads:
-            t.start()
-        for t in threads:
-            t.join(timeout=self.TIMEOUT)
-            self.assertFalse(t.is_alive())
-
-        # Multiple threads may compute the value, but setdefault ensures
-        # the first cached result wins and all return 42.
-        self.assertGreaterEqual(self.count, 1)
-
-        info = self.locked_method.cache_info()
-        self.assertEqual(info.hits + info.misses, self.NTHREADS)
-        self.assertGreaterEqual(info.misses, 1)