cachetools 5.5.2__tar.gz → 6.0.0b2__tar.gz

{cachetools-5.5.2 → cachetools-6.0.0b2}/CHANGELOG.rst

@@ -1,3 +1,27 @@
+v6.0.0 (UNRELEASED)
+===================
+
+- Require Python 3.9 or later (breaking change).
+
+- Remove ``MRUCache`` and the ``@func.mru_cache`` decorator (breaking
+  change).
+
+- Add an optional ``condition`` parameter to the ``@cached`` and
+  ``@cachedmethod`` decorators, which, when used with a
+  ``threading.Condition`` instance, should improve `cache stampede
+  <https://en.wikipedia.org/wiki/Cache_stampede>`_ issues in massively
+  parallel environments.  Note that this will incur some performance
+  penalty, and therefore has to be enabled explicitly.
+
+- Convert the ``cachetools.func`` decorators to use a
+  ``threading.Condition`` instance to deal with `cache stampede
+  <https://en.wikipedia.org/wiki/Cache_stampede>`_ issues.  Note that
+  this *may* result in a noticable performance degradation, depending
+  on your actual use case.
+
+- Update CI environment.
+
+
 v5.5.2 (2025-02-20)
 ===================
 

{cachetools-5.5.2/src/cachetools.egg-info → cachetools-6.0.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: cachetools
-Version: 5.5.2
+Version: 6.0.0b2
 Summary: Extensible memoizing collections and decorators
 Home-page: https://github.com/tkem/cachetools/
 Author: Thomas Kemmer
@@ -13,8 +13,6 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -23,6 +21,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.7
 License-File: LICENSE
+Dynamic: license-file
 
 cachetools
 ========================================================================

{cachetools-5.5.2 → cachetools-6.0.0b2}/docs/index.rst

@@ -98,18 +98,6 @@ inserted into the cache.
    This class discards the least recently used items first to make
    space when necessary.
 
-.. autoclass:: MRUCache(maxsize, getsizeof=None)
-   :members: popitem
-
-   This class discards the most recently used items first to make
-   space when necessary.
-
-   .. deprecated:: 5.4
-
-   `MRUCache` has been deprecated due to lack of use, to reduce
-   maintenance.  Please choose another cache implementation that suits
-   your needs.
-
 .. autoclass:: RRCache(maxsize, choice=random.choice, getsizeof=None)
    :members: choice, popitem
 
@@ -174,7 +162,7 @@ inserted into the cache.
    value of `timer()`.
 
    .. testcode::
-   
+
       def my_ttu(_key, value, now):
           # assume value.ttu contains the item's time-to-use in seconds
           # note that the _key argument is ignored in this example
@@ -688,18 +676,6 @@ all the decorators in this module are thread-safe by default.
    saves up to `maxsize` results based on a Least Recently Used (LRU)
    algorithm.
 
-.. decorator:: mru_cache(user_function)
-               mru_cache(maxsize=128, typed=False)
-
-   Decorator that wraps a function with a memoizing callable that
-   saves up to `maxsize` results based on a Most Recently Used (MRU)
-   algorithm.
-
-   .. deprecated:: 5.4
-
-   The `mru_cache` decorator has been deprecated due to lack of use.
-   Please choose a decorator based on some other algorithm.
-
 .. decorator:: rr_cache(user_function)
                rr_cache(maxsize=128, choice=random.choice, typed=False)
 

{cachetools-5.5.2 → cachetools-6.0.0b2}/setup.cfg

@@ -16,8 +16,6 @@ classifiers =
 	Operating System :: OS Independent
 	Programming Language :: Python
 	Programming Language :: Python :: 3
-	Programming Language :: Python :: 3.7
-	Programming Language :: Python :: 3.8
 	Programming Language :: Python :: 3.9
 	Programming Language :: Python :: 3.10
 	Programming Language :: Python :: 3.11

{cachetools-5.5.2 → cachetools-6.0.0b2}/src/cachetools/__init__.py

@@ -5,7 +5,6 @@ __all__ = (
     "FIFOCache",
     "LFUCache",
     "LRUCache",
-    "MRUCache",
     "RRCache",
     "TLRUCache",
     "TTLCache",
@@ -13,7 +12,7 @@ __all__ = (
     "cachedmethod",
 )
 
-__version__ = "5.5.2"
+__version__ = "6.0.0b2"
 
 import collections
 import collections.abc
@@ -23,7 +22,8 @@ import random
 import time
 
 from . import keys
-from ._decorators import _cached_wrapper
+from ._cached import _cached_wrapper
+from ._cachedmethod import _cachedmethod_wrapper
 
 
 class _DefaultSize:
@@ -237,47 +237,6 @@ class LRUCache(Cache):
             self.__order[key] = None
 
 
-class MRUCache(Cache):
-    """Most Recently Used (MRU) cache implementation."""
-
-    def __init__(self, maxsize, getsizeof=None):
-        from warnings import warn
-
-        warn("MRUCache is deprecated", DeprecationWarning, stacklevel=2)
-
-        Cache.__init__(self, maxsize, getsizeof)
-        self.__order = collections.OrderedDict()
-
-    def __getitem__(self, key, cache_getitem=Cache.__getitem__):
-        value = cache_getitem(self, key)
-        if key in self:  # __missing__ may not store item
-            self.__update(key)
-        return value
-
-    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
-        cache_setitem(self, key, value)
-        self.__update(key)
-
-    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
-        cache_delitem(self, key)
-        del self.__order[key]
-
-    def popitem(self):
-        """Remove and return the `(key, value)` pair most recently used."""
-        try:
-            key = next(iter(self.__order))
-        except StopIteration:
-            raise KeyError("%s is empty" % type(self).__name__) from None
-        else:
-            return (key, self.pop(key))
-
-    def __update(self, key):
-        try:
-            self.__order.move_to_end(key, last=False)
-        except KeyError:
-            self.__order[key] = None
-
-
 class RRCache(Cache):
     """Random Replacement (RR) cache implementation."""
 
@@ -636,11 +595,21 @@ _CacheInfo = collections.namedtuple(
 )
 
 
-def cached(cache, key=keys.hashkey, lock=None, info=False):
+def cached(cache, key=keys.hashkey, lock=None, condition=None, info=False):
     """Decorator to wrap a function with a memoizing callable that saves
     results in a cache.
 
     """
+    if isinstance(condition, bool):
+        from warnings import warn
+
+        warn(
+            "passing `info` as positional parameter is deprecated",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        info = condition
+        condition = None
 
     def decorator(func):
         if info:
@@ -659,9 +628,9 @@ def cached(cache, key=keys.hashkey, lock=None, info=False):
                 def make_info(hits, misses):
                     return _CacheInfo(hits, misses, 0, 0)
 
-            wrapper = _cached_wrapper(func, cache, key, lock, make_info)
+            wrapper = _cached_wrapper(func, cache, key, lock, condition, info=make_info)
         else:
-            wrapper = _cached_wrapper(func, cache, key, lock, None)
+            wrapper = _cached_wrapper(func, cache, key, lock, condition)
 
         wrapper.cache = cache
         wrapper.cache_key = key
@@ -672,66 +641,18 @@ def cached(cache, key=keys.hashkey, lock=None, info=False):
     return decorator
 
 
-def cachedmethod(cache, key=keys.methodkey, lock=None):
+def cachedmethod(cache, key=keys.methodkey, lock=None, condition=None):
     """Decorator to wrap a class or instance method with a memoizing
     callable that saves results in a cache.
 
     """
 
     def decorator(method):
-        if lock is None:
-
-            def wrapper(self, *args, **kwargs):
-                c = cache(self)
-                if c is None:
-                    return method(self, *args, **kwargs)
-                k = key(self, *args, **kwargs)
-                try:
-                    return c[k]
-                except KeyError:
-                    pass  # key not found
-                v = method(self, *args, **kwargs)
-                try:
-                    c[k] = v
-                except ValueError:
-                    pass  # value too large
-                return v
-
-            def clear(self):
-                c = cache(self)
-                if c is not None:
-                    c.clear()
-
-        else:
-
-            def wrapper(self, *args, **kwargs):
-                c = cache(self)
-                if c is None:
-                    return method(self, *args, **kwargs)
-                k = key(self, *args, **kwargs)
-                try:
-                    with lock(self):
-                        return c[k]
-                except KeyError:
-                    pass  # key not found
-                v = method(self, *args, **kwargs)
-                # in case of a race, prefer the item already in the cache
-                try:
-                    with lock(self):
-                        return c.setdefault(k, v)
-                except ValueError:
-                    return v  # value too large
-
-            def clear(self):
-                c = cache(self)
-                if c is not None:
-                    with lock(self):
-                        c.clear()
+        wrapper = _cachedmethod_wrapper(method, cache, key, lock, condition)
 
         wrapper.cache = cache
         wrapper.cache_key = key
         wrapper.cache_lock = lock
-        wrapper.cache_clear = clear
 
         return functools.update_wrapper(wrapper, method)
 

cachetools-5.5.2/src/cachetools/_decorators.py → cachetools-6.0.0b2/src/cachetools/_cached.py

@@ -1,4 +1,48 @@
-"""Extensible memoizing decorator helpers."""
+"""Function decorator helpers."""
+
+
+def _cached_condition_info(func, cache, key, lock, cond, info):
+    hits = misses = 0
+    pending = set()
+
+    def wrapper(*args, **kwargs):
+        nonlocal hits, misses
+        k = key(*args, **kwargs)
+        with lock:
+            cond.wait_for(lambda: k not in pending)
+            try:
+                result = cache[k]
+                hits += 1
+                return result
+            except KeyError:
+                pending.add(k)
+                misses += 1
+        try:
+            v = func(*args, **kwargs)
+            with lock:
+                try:
+                    cache[k] = v
+                except ValueError:
+                    pass  # value too large
+                return v
+        finally:
+            with lock:
+                pending.remove(k)
+                cond.notify_all()
+
+    def cache_clear():
+        nonlocal hits, misses
+        with lock:
+            cache.clear()
+            hits = misses = 0
+
+    def cache_info():
+        with lock:
+            return info(hits, misses)
+
+    wrapper.cache_clear = cache_clear
+    wrapper.cache_info = cache_info
+    return wrapper
 
 
 def _cached_locked_info(func, cache, key, lock, info):
@@ -83,6 +127,39 @@ def _uncached_info(func, info):
     return wrapper
 
 
+def _cached_condition(func, cache, key, lock, cond):
+    pending = set()
+
+    def wrapper(*args, **kwargs):
+        k = key(*args, **kwargs)
+        with lock:
+            cond.wait_for(lambda: k not in pending)
+            try:
+                result = cache[k]
+                return result
+            except KeyError:
+                pending.add(k)
+        try:
+            v = func(*args, **kwargs)
+            with lock:
+                try:
+                    cache[k] = v
+                except ValueError:
+                    pass  # value too large
+                return v
+        finally:
+            with lock:
+                pending.remove(k)
+                cond.notify_all()
+
+    def cache_clear():
+        with lock:
+            cache.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
 def _cached_locked(func, cache, key, lock):
     def wrapper(*args, **kwargs):
         k = key(*args, **kwargs)
@@ -133,20 +210,28 @@ def _uncached(func):
     return wrapper
 
 
-def _cached_wrapper(func, cache, key, lock, info):
+def _cached_wrapper(func, cache, key, lock=None, cond=None, info=None):
     if info is not None:
         if cache is None:
             wrapper = _uncached_info(func, info)
-        elif lock is None:
-            wrapper = _cached_unlocked_info(func, cache, key, info)
-        else:
+        elif cond is not None and lock is not None:
+            wrapper = _cached_condition_info(func, cache, key, lock, cond, info)
+        elif cond is not None:
+            wrapper = _cached_condition_info(func, cache, key, cond, cond, info)
+        elif lock is not None:
             wrapper = _cached_locked_info(func, cache, key, lock, info)
+        else:
+            wrapper = _cached_unlocked_info(func, cache, key, info)
     else:
         if cache is None:
             wrapper = _uncached(func)
-        elif lock is None:
-            wrapper = _cached_unlocked(func, cache, key)
-        else:
+        elif cond is not None and lock is not None:
+            wrapper = _cached_condition(func, cache, key, lock, cond)
+        elif cond is not None:
+            wrapper = _cached_condition(func, cache, key, cond, cond)
+        elif lock is not None:
             wrapper = _cached_locked(func, cache, key, lock)
+        else:
+            wrapper = _cached_unlocked(func, cache, key)
         wrapper.cache_info = None
     return wrapper

cachetools-6.0.0b2/src/cachetools/_cachedmethod.py

@@ -0,0 +1,108 @@
+"""Method decorator helpers."""
+
+import weakref
+
+
+def _cachedmethod_condition(method, cache, key, lock, cond):
+    pending = weakref.WeakKeyDictionary()
+
+    def wrapper(self, *args, **kwargs):
+        c = cache(self)
+        if c is None:
+            return method(self, *args, **kwargs)
+        k = key(self, *args, **kwargs)
+        with lock(self):
+            p = pending.setdefault(self, set())
+            cond(self).wait_for(lambda: k not in p)
+            try:
+                return c[k]
+            except KeyError:
+                p.add(k)
+        try:
+            v = method(self, *args, **kwargs)
+            with lock(self):
+                try:
+                    c[k] = v
+                except ValueError:
+                    pass  # value too large
+                return v
+        finally:
+            with lock(self):
+                pending[self].remove(k)
+                cond(self).notify_all()
+
+    def cache_clear(self):
+        c = cache(self)
+        if c is not None:
+            with lock(self):
+                c.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _cachedmethod_locked(method, cache, key, lock):
+    def wrapper(self, *args, **kwargs):
+        c = cache(self)
+        if c is None:
+            return method(self, *args, **kwargs)
+        k = key(self, *args, **kwargs)
+        with lock(self):
+            try:
+                return c[k]
+            except KeyError:
+                pass  # key not found
+        v = method(self, *args, **kwargs)
+        # in case of a race, prefer the item already in the cache
+        with lock(self):
+            try:
+                return c.setdefault(k, v)
+            except ValueError:
+                return v  # value too large
+
+    def cache_clear(self):
+        c = cache(self)
+        if c is not None:
+            with lock(self):
+                c.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _cachedmethod_unlocked(method, cache, key):
+    def wrapper(self, *args, **kwargs):
+        c = cache(self)
+        if c is None:
+            return method(self, *args, **kwargs)
+        k = key(self, *args, **kwargs)
+        try:
+            return c[k]
+        except KeyError:
+            pass  # key not found
+        v = method(self, *args, **kwargs)
+        try:
+            c[k] = v
+        except ValueError:
+            pass  # value too large
+        return v
+
+    def cache_clear(self):
+        c = cache(self)
+        if c is not None:
+            c.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _cachedmethod_wrapper(func, cache, key, lock=None, cond=None):
+    if cond is not None and lock is not None:
+        wrapper = _cachedmethod_condition(func, cache, key, lock, cond)
+    elif cond is not None:
+        wrapper = _cachedmethod_condition(func, cache, key, cond, cond)
+    elif lock is not None:
+        wrapper = _cachedmethod_locked(func, cache, key, lock)
+    else:
+        wrapper = _cachedmethod_unlocked(func, cache, key)
+    return wrapper

{cachetools-5.5.2 → cachetools-6.0.0b2}/src/cachetools/func.py

@@ -1,17 +1,18 @@
 """`functools.lru_cache` compatible memoizing function decorators."""
 
-__all__ = ("fifo_cache", "lfu_cache", "lru_cache", "mru_cache", "rr_cache", "ttl_cache")
+__all__ = ("fifo_cache", "lfu_cache", "lru_cache", "rr_cache", "ttl_cache")
 
+import functools
 import math
 import random
 import time
 
 try:
-    from threading import RLock
+    from threading import Condition
 except ImportError:  # pragma: no cover
-    from dummy_threading import RLock
+    from dummy_threading import Condition
 
-from . import FIFOCache, LFUCache, LRUCache, MRUCache, RRCache, TTLCache
+from . import FIFOCache, LFUCache, LRUCache, RRCache, TTLCache
 from . import cached
 from . import keys
 
@@ -28,7 +29,7 @@ class _UnboundTTLCache(TTLCache):
 def _cache(cache, maxsize, typed):
     def decorator(func):
         key = keys.typedkey if typed else keys.hashkey
-        wrapper = cached(cache=cache, key=key, lock=RLock(), info=True)(func)
+        wrapper = cached(cache=cache, key=key, condition=Condition(), info=True)(func)
         wrapper.cache_parameters = lambda: {"maxsize": maxsize, "typed": typed}
         return wrapper
 
@@ -77,23 +78,6 @@ def lru_cache(maxsize=128, typed=False):
         return _cache(LRUCache(maxsize), maxsize, typed)
 
 
-def mru_cache(maxsize=128, typed=False):
-    """Decorator to wrap a function with a memoizing callable that saves
-    up to `maxsize` results based on a Most Recently Used (MRU)
-    algorithm.
-    """
-    from warnings import warn
-
-    warn("@mru_cache is deprecated", DeprecationWarning, stacklevel=2)
-
-    if maxsize is None:
-        return _cache({}, None, typed)
-    elif callable(maxsize):
-        return _cache(MRUCache(128), 128, typed)(maxsize)
-    else:
-        return _cache(MRUCache(maxsize), maxsize, typed)
-
-
 def rr_cache(maxsize=128, choice=random.choice, typed=False):
     """Decorator to wrap a function with a memoizing callable that saves
     up to `maxsize` results based on a Random Replacement (RR)

{cachetools-5.5.2 → cachetools-6.0.0b2/src/cachetools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: cachetools
-Version: 5.5.2
+Version: 6.0.0b2
 Summary: Extensible memoizing collections and decorators
 Home-page: https://github.com/tkem/cachetools/
 Author: Thomas Kemmer
@@ -13,8 +13,6 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -23,6 +21,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.7
 License-File: LICENSE
+Dynamic: license-file
 
 cachetools
 ========================================================================

{cachetools-5.5.2 → cachetools-6.0.0b2}/src/cachetools.egg-info/SOURCES.txt

@@ -9,7 +9,8 @@ tox.ini
 docs/conf.py
 docs/index.rst
 src/cachetools/__init__.py
-src/cachetools/_decorators.py
+src/cachetools/_cached.py
+src/cachetools/_cachedmethod.py
 src/cachetools/func.py
 src/cachetools/keys.py
 src/cachetools.egg-info/PKG-INFO
@@ -25,7 +26,6 @@ tests/test_func.py
 tests/test_keys.py
 tests/test_lfu.py
 tests/test_lru.py
-tests/test_mru.py
 tests/test_rr.py
 tests/test_tlru.py
 tests/test_ttl.py

{cachetools-5.5.2 → cachetools-6.0.0b2}/tests/test_cached.py

@@ -1,4 +1,5 @@
 import unittest
+import warnings
 
 import cachetools
 import cachetools.keys
@@ -15,6 +16,19 @@ class CountedLock:
         pass
 
 
+class CountedCondition(CountedLock):
+    def __init__(self):
+        CountedLock.__init__(self)
+        self.wait_count = 0
+        self.notify_count = 0
+
+    def wait_for(self, predicate):
+        self.wait_count += 1
+
+    def notify_all(self):
+        self.notify_count += 1
+
+
 class DecoratorTestMixin:
     def cache(self, minsize):
         raise NotImplementedError
@@ -95,6 +109,45 @@ class DecoratorTestMixin:
         self.assertEqual(wrapper(1), 1)
         self.assertEqual(lock.count, 5)
 
+    def test_decorator_condition(self):
+        cache = self.cache(2)
+        lock = cond = CountedCondition()
+        wrapper = cachetools.cached(cache, condition=cond)(self.func)
+
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(wrapper(0), 0)
+        self.assertEqual(lock.count, 3)
+        self.assertEqual(cond.wait_count, 1)
+        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.notify_count, 2)
+        self.assertEqual(wrapper(1), 1)
+        self.assertEqual(lock.count, 7)
+        self.assertEqual(cond.wait_count, 3)
+        self.assertEqual(cond.notify_count, 2)
+
+    def test_decorator_lock_condition(self):
+        cache = self.cache(2)
+        lock = CountedLock()
+        cond = CountedCondition()
+        wrapper = cachetools.cached(cache, lock=lock, condition=cond)(self.func)
+
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(wrapper(0), 0)
+        self.assertEqual(lock.count, 3)
+        self.assertEqual(cond.wait_count, 1)
+        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.notify_count, 2)
+        self.assertEqual(wrapper(1), 1)
+        self.assertEqual(lock.count, 7)
+        self.assertEqual(cond.wait_count, 3)
+        self.assertEqual(cond.notify_count, 2)
+
     def test_decorator_wrapped(self):
         cache = self.cache(2)
         wrapper = cachetools.cached(cache)(self.func)
@@ -145,6 +198,17 @@ class DecoratorTestMixin:
         self.assertEqual(len(cache), 0)
         self.assertEqual(lock.count, 3)
 
+    def test_decorator_clear_condition(self):
+        cache = self.cache(2)
+        lock = cond = CountedCondition()
+        wrapper = cachetools.cached(cache, condition=cond)(self.func)
+        self.assertEqual(wrapper(0), 0)
+        self.assertEqual(len(cache), 1)
+        self.assertEqual(lock.count, 3)
+        wrapper.cache_clear()
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(lock.count, 4)
+
 
 class CacheWrapperTest(unittest.TestCase, DecoratorTestMixin):
     def cache(self, minsize):
@@ -188,6 +252,69 @@ class CacheWrapperTest(unittest.TestCase, DecoratorTestMixin):
         self.assertEqual(wrapper.cache_info(), (0, 0, 2, 0))
         self.assertEqual(lock.count, 11)
 
+    def test_decorator_lock_info_deprecated(self):
+        cache = self.cache(2)
+        key = cachetools.keys.hashkey
+        lock = CountedLock()
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            # passing `ìnfo` as positional parameter is deprecated
+            wrapper = cachetools.cached(cache, key, lock, True)(self.func)
+        self.assertEqual(len(w), 1)
+        self.assertIs(w[0].category, DeprecationWarning)
+        self.assertEqual(wrapper.cache_info(), (0, 0, 2, 0))
+
+    def test_decorator_condition_info(self):
+        cache = self.cache(2)
+        lock = cond = CountedCondition()
+        wrapper = cachetools.cached(cache, condition=cond, info=True)(self.func)
+        self.assertEqual(wrapper.cache_info(), (0, 0, 2, 0))
+        self.assertEqual(lock.count, 1)
+        self.assertEqual(wrapper(0), 0)
+        self.assertEqual(lock.count, 4)
+        self.assertEqual(wrapper.cache_info(), (0, 1, 2, 1))
+        self.assertEqual(lock.count, 5)
+        self.assertEqual(wrapper(1), 1)
+        self.assertEqual(lock.count, 8)
+        self.assertEqual(wrapper.cache_info(), (0, 2, 2, 2))
+        self.assertEqual(lock.count, 9)
+        self.assertEqual(wrapper(0), 0)
+        self.assertEqual(lock.count, 10)
+        self.assertEqual(wrapper.cache_info(), (1, 2, 2, 2))
+        self.assertEqual(lock.count, 11)
+        wrapper.cache_clear()
+        self.assertEqual(lock.count, 12)
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(wrapper.cache_info(), (0, 0, 2, 0))
+        self.assertEqual(lock.count, 13)
+
+    def test_decorator_lock_condition_info(self):
+        cache = self.cache(2)
+        lock = CountedLock()
+        cond = CountedCondition()
+        wrapper = cachetools.cached(cache, lock=lock, condition=cond, info=True)(
+            self.func
+        )
+        self.assertEqual(wrapper.cache_info(), (0, 0, 2, 0))
+        self.assertEqual(lock.count, 1)
+        self.assertEqual(wrapper(0), 0)
+        self.assertEqual(lock.count, 4)
+        self.assertEqual(wrapper.cache_info(), (0, 1, 2, 1))
+        self.assertEqual(lock.count, 5)
+        self.assertEqual(wrapper(1), 1)
+        self.assertEqual(lock.count, 8)
+        self.assertEqual(wrapper.cache_info(), (0, 2, 2, 2))
+        self.assertEqual(lock.count, 9)
+        self.assertEqual(wrapper(0), 0)
+        self.assertEqual(lock.count, 10)
+        self.assertEqual(wrapper.cache_info(), (1, 2, 2, 2))
+        self.assertEqual(lock.count, 11)
+        wrapper.cache_clear()
+        self.assertEqual(lock.count, 12)
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(wrapper.cache_info(), (0, 0, 2, 0))
+        self.assertEqual(lock.count, 13)
+
     def test_zero_size_cache_decorator(self):
         cache = self.cache(0)
         wrapper = cachetools.cached(cache)(self.func)
@@ -206,6 +333,16 @@ class CacheWrapperTest(unittest.TestCase, DecoratorTestMixin):
         self.assertEqual(len(cache), 0)
         self.assertEqual(lock.count, 2)
 
+    def test_zero_size_cache_decorator_condition(self):
+        cache = self.cache(0)
+        lock = cond = CountedCondition()
+        wrapper = cachetools.cached(cache, condition=cond)(self.func)
+
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(wrapper(0), 0)
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(lock.count, 3)
+
     def test_zero_size_cache_decorator_info(self):
         cache = self.cache(0)
         wrapper = cachetools.cached(cache, info=True)(self.func)
@@ -214,6 +351,20 @@ class CacheWrapperTest(unittest.TestCase, DecoratorTestMixin):
         self.assertEqual(wrapper(0), 0)
         self.assertEqual(wrapper.cache_info(), (0, 1, 0, 0))
 
+    def test_zero_size_cache_decorator_lock_info(self):
+        cache = self.cache(0)
+        lock = CountedLock()
+        wrapper = cachetools.cached(cache, lock=lock, info=True)(self.func)
+
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(wrapper.cache_info(), (0, 0, 0, 0))
+        self.assertEqual(lock.count, 1)
+        self.assertEqual(wrapper(0), 0)
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(lock.count, 3)
+        self.assertEqual(wrapper.cache_info(), (0, 1, 0, 0))
+        self.assertEqual(lock.count, 4)
+
 
 class DictWrapperTest(unittest.TestCase, DecoratorTestMixin):
     def cache(self, minsize):

{cachetools-5.5.2 → cachetools-6.0.0b2}/tests/test_cachedmethod.py

@@ -25,18 +25,44 @@ class Locked:
     def __init__(self, cache):
         self.cache = cache
         self.count = 0
+        self.lock_count = 0
 
     @cachedmethod(lambda self: self.cache, lock=lambda self: self)
     def get(self, value):
-        return self.count
+        count = self.count
+        self.count += 1
+        return count
 
     def __enter__(self):
-        self.count += 1
+        self.lock_count += 1
 
     def __exit__(self, *exc):
         pass
 
 
+class Conditioned(Locked):
+    def __init__(self, cache):
+        Locked.__init__(self, cache)
+        self.wait_count = 0
+        self.notify_count = 0
+
+    @cachedmethod(lambda self: self.cache, condition=lambda self: self)
+    def get(self, value):
+        return Locked.get.__wrapped__(self, value)
+
+    @cachedmethod(
+        lambda self: self.cache, lock=lambda self: self, condition=lambda self: self
+    )
+    def get_lock(self, value):
+        return Locked.get.__wrapped__(self, value)
+
+    def wait_for(self, predicate):
+        self.wait_count += 1
+
+    def notify_all(self):
+        self.notify_count += 1
+
+
 class Unhashable:
     def __init__(self, cache):
         self.cache = cache
@@ -152,29 +178,110 @@ class CachedMethodTest(unittest.TestCase):
     def test_locked_dict(self):
         cached = Locked({})
 
-        self.assertEqual(cached.get(0), 1)
-        self.assertEqual(cached.get(1), 3)
-        self.assertEqual(cached.get(1), 3)
+        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.lock_count, 2)
+        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.lock_count, 4)
+        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.lock_count, 5)
+        self.assertEqual(cached.get(1.0), 1)
+        self.assertEqual(cached.lock_count, 6)
+        self.assertEqual(cached.get(1.0), 1)
+        self.assertEqual(cached.lock_count, 7)
+
+        cached.cache.clear()
+        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.lock_count, 9)
+
+    def test_locked_nospace(self):
+        cached = Locked(LRUCache(maxsize=0))
+
+        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.lock_count, 2)
+        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.lock_count, 4)
+        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.lock_count, 6)
         self.assertEqual(cached.get(1.0), 3)
-        self.assertEqual(cached.get(2.0), 7)
+        self.assertEqual(cached.lock_count, 8)
+        self.assertEqual(cached.get(1.0), 4)
+        self.assertEqual(cached.lock_count, 10)
 
     def test_locked_nocache(self):
         cached = Locked(None)
 
         self.assertEqual(cached.get(0), 0)
-        self.assertEqual(cached.get(1), 0)
-        self.assertEqual(cached.get(1), 0)
-        self.assertEqual(cached.get(1.0), 0)
-        self.assertEqual(cached.get(1.0), 0)
+        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.get(1.0), 3)
+        self.assertEqual(cached.get(1.0), 4)
+        self.assertEqual(cached.lock_count, 0)
 
-    def test_locked_nospace(self):
-        cached = Locked(LRUCache(maxsize=0))
+    def test_condition_dict(self):
+        cached = Conditioned({})
 
-        self.assertEqual(cached.get(0), 1)
-        self.assertEqual(cached.get(1), 3)
-        self.assertEqual(cached.get(1), 5)
-        self.assertEqual(cached.get(1.0), 7)
-        self.assertEqual(cached.get(1.0), 9)
+        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.lock_count, 3)
+        self.assertEqual(cached.wait_count, 1)
+        self.assertEqual(cached.notify_count, 1)
+        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.lock_count, 6)
+        self.assertEqual(cached.wait_count, 2)
+        self.assertEqual(cached.notify_count, 2)
+        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.lock_count, 7)
+        self.assertEqual(cached.wait_count, 3)
+        self.assertEqual(cached.notify_count, 2)
+        self.assertEqual(cached.get(1.0), 1)
+        self.assertEqual(cached.lock_count, 8)
+        self.assertEqual(cached.wait_count, 4)
+        self.assertEqual(cached.notify_count, 2)
+        self.assertEqual(cached.get(1.0), 1)
+        self.assertEqual(cached.lock_count, 9)
+        self.assertEqual(cached.wait_count, 5)
+        self.assertEqual(cached.notify_count, 2)
+
+        cached.cache.clear()
+        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.lock_count, 12)
+        self.assertEqual(cached.wait_count, 6)
+        self.assertEqual(cached.notify_count, 3)
+
+    def test_condition_nospace(self):
+        cached = Conditioned(LRUCache(maxsize=0))
+
+        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.lock_count, 3)
+        self.assertEqual(cached.wait_count, 1)
+        self.assertEqual(cached.notify_count, 1)
+        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.lock_count, 6)
+        self.assertEqual(cached.wait_count, 2)
+        self.assertEqual(cached.notify_count, 2)
+        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.lock_count, 9)
+        self.assertEqual(cached.wait_count, 3)
+        self.assertEqual(cached.notify_count, 3)
+        self.assertEqual(cached.get(1.0), 3)
+        self.assertEqual(cached.lock_count, 12)
+        self.assertEqual(cached.wait_count, 4)
+        self.assertEqual(cached.notify_count, 4)
+        self.assertEqual(cached.get(1.0), 4)
+        self.assertEqual(cached.lock_count, 15)
+        self.assertEqual(cached.wait_count, 5)
+        self.assertEqual(cached.notify_count, 5)
+
+    def test_condition_nocache(self):
+        cached = Conditioned(None)
+
+        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.get(1.0), 3)
+        self.assertEqual(cached.get(1.0), 4)
+        self.assertEqual(cached.lock_count, 0)
+        self.assertEqual(cached.wait_count, 0)
+        self.assertEqual(cached.notify_count, 0)
 
     def test_unhashable(self):
         cached = Unhashable(LRUCache(maxsize=0))
@@ -226,9 +333,20 @@ class CachedMethodTest(unittest.TestCase):
         cache = {}
         cached = Locked(cache)
 
-        self.assertEqual(cached.get(0), 1)
+        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(len(cache), 1)
+        self.assertEqual(cached.lock_count, 2)
+        cached.get.cache_clear(cached)
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(cached.lock_count, 3)
+
+    def test_clear_condition(self):
+        cache = {}
+        cached = Conditioned(cache)
+
+        self.assertEqual(cached.get(0), 0)
         self.assertEqual(len(cache), 1)
-        self.assertEqual(cached.count, 2)
+        self.assertEqual(cached.lock_count, 3)
         cached.get.cache_clear(cached)
         self.assertEqual(len(cache), 0)
-        self.assertEqual(cached.count, 3)
+        self.assertEqual(cached.lock_count, 4)

{cachetools-5.5.2 → cachetools-6.0.0b2}/tests/test_func.py

@@ -111,18 +111,6 @@ class LRUDecoratorTest(unittest.TestCase, DecoratorTestMixin):
     DECORATOR = staticmethod(cachetools.func.lru_cache)
 
 
-class MRUDecoratorTest(unittest.TestCase, DecoratorTestMixin):
-    def decorator(self, maxsize, **kwargs):
-        import warnings
-
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            d = cachetools.func.mru_cache(maxsize, **kwargs)
-        self.assertNotEqual(len(w), 0)
-        self.assertIs(w[0].category, DeprecationWarning)
-        return d
-
-
 class RRDecoratorTest(unittest.TestCase, DecoratorTestMixin):
     DECORATOR = staticmethod(cachetools.func.rr_cache)
 

cachetools-5.5.2/tests/test_mru.py

@@ -1,63 +0,0 @@
-import unittest
-import warnings
-
-from cachetools import MRUCache
-
-from . import CacheTestMixin
-
-
-class MRUCacheTest(unittest.TestCase, CacheTestMixin):
-    # TODO: method to create cache that can be overridden
-    Cache = MRUCache
-
-    def test_evict__writes_only(self):
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            cache = MRUCache(maxsize=2)
-        self.assertEqual(len(w), 1)
-        self.assertIs(w[0].category, DeprecationWarning)
-
-        cache[1] = 1
-        cache[2] = 2
-        cache[3] = 3  # Evicts 1 because nothing's been used yet
-
-        assert len(cache) == 2
-        assert 1 not in cache, "Wrong key was evicted. Should have been '1'."
-        assert 2 in cache
-        assert 3 in cache
-
-    def test_evict__with_access(self):
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            cache = MRUCache(maxsize=2)
-        self.assertEqual(len(w), 1)
-        self.assertIs(w[0].category, DeprecationWarning)
-
-        cache[1] = 1
-        cache[2] = 2
-        cache[1]
-        cache[2]
-        cache[3] = 3  # Evicts 2
-        assert 2 not in cache, "Wrong key was evicted. Should have been '2'."
-        assert 1 in cache
-        assert 3 in cache
-
-    def test_evict__with_delete(self):
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            cache = MRUCache(maxsize=2)
-        self.assertEqual(len(w), 1)
-        self.assertIs(w[0].category, DeprecationWarning)
-
-        cache[1] = 1
-        cache[2] = 2
-        del cache[2]
-        cache[3] = 3  # Doesn't evict anything because we just deleted 2
-
-        assert 2 not in cache
-        assert 1 in cache
-
-        cache[4] = 4  # Should evict 1 as we just accessed it with __contains__
-        assert 1 not in cache
-        assert 3 in cache
-        assert 4 in cache