cachetools 6.0.0b4__tar.gz → 6.2.0__tar.gz

{cachetools-6.0.0b4 → cachetools-6.2.0}/CHANGELOG.rst

@@ -1,4 +1,24 @@
-v6.0.0 (UNRELEASED)
+v6.2.0 (2025-08-25)
+===================
+
+- Improve general ``RRCache`` performance by storing cache keys in an
+  additional sequence container.  Note that this will increase memory
+  consumption.
+
+- Add more unit tests.
+
+
+v6.1.0 (2025-06-16)
+===================
+
+- Improve ``LFUCache`` insertion performance by switching to an
+  implementation based on the `cacheing
+  <https://pypi.org/project/cacheing/>`_ library.
+
+- Update CI environment.
+
+
+v6.0.0 (2025-05-23)
 ===================
 
 - Require Python 3.9 or later (breaking change).

{cachetools-6.0.0b4/src/cachetools.egg-info → cachetools-6.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachetools
-Version: 6.0.0b4
+Version: 6.2.0
 Summary: Extensible memoizing collections and decorators
 Home-page: https://github.com/tkem/cachetools/
 Author: Thomas Kemmer
@@ -115,11 +115,12 @@ Project Resources
 Related Projects
 ------------------------------------------------------------------------
 
-- asyncache_: Helpers to use cachetools with async functions
-- cacheing_: Pure Python Cacheing Library
-- CacheToolsUtils_: Cachetools Utilities
-- kids.cache_: Kids caching library
-- shelved-cache_: Persistent cache for Python cachetools
+- asyncache_: Helpers to use cachetools_ with asyncio.
+- cacheing_: Pure Python Cacheing Library.
+- CacheToolsUtils_: Stackable cache classes for sharing, encryption,
+  statistics *and more* on top of cachetools_, redis_ and memcached_.
+- shelved-cache_: Persistent cache implementation for Python
+  cachetools_.
 
 
 License
@@ -144,7 +145,9 @@ Licensed under the `MIT License`_.
 .. _MIT License: https://raw.github.com/tkem/cachetools/master/LICENSE
 
 .. _asyncache: https://pypi.org/project/asyncache/
-.. _cacheing: https://github.com/breid48/cacheing
+.. _cacheing: https://pypi.org/project/cacheing/
 .. _CacheToolsUtils: https://pypi.org/project/CacheToolsUtils/
-.. _kids.cache: https://pypi.org/project/kids.cache/
 .. _shelved-cache: https://pypi.org/project/shelved-cache/
+.. _cachetools: https://pypi.org/project/cachetools/
+.. _redis: https://redis.io/
+.. _memcached: https://memcached.org/

{cachetools-6.0.0b4 → cachetools-6.2.0}/README.rst

@@ -90,11 +90,12 @@ Project Resources
 Related Projects
 ------------------------------------------------------------------------
 
-- asyncache_: Helpers to use cachetools with async functions
-- cacheing_: Pure Python Cacheing Library
-- CacheToolsUtils_: Cachetools Utilities
-- kids.cache_: Kids caching library
-- shelved-cache_: Persistent cache for Python cachetools
+- asyncache_: Helpers to use cachetools_ with asyncio.
+- cacheing_: Pure Python Cacheing Library.
+- CacheToolsUtils_: Stackable cache classes for sharing, encryption,
+  statistics *and more* on top of cachetools_, redis_ and memcached_.
+- shelved-cache_: Persistent cache implementation for Python
+  cachetools_.
 
 
 License
@@ -119,7 +120,9 @@ Licensed under the `MIT License`_.
 .. _MIT License: https://raw.github.com/tkem/cachetools/master/LICENSE
 
 .. _asyncache: https://pypi.org/project/asyncache/
-.. _cacheing: https://github.com/breid48/cacheing
+.. _cacheing: https://pypi.org/project/cacheing/
 .. _CacheToolsUtils: https://pypi.org/project/CacheToolsUtils/
-.. _kids.cache: https://pypi.org/project/kids.cache/
 .. _shelved-cache: https://pypi.org/project/shelved-cache/
+.. _cachetools: https://pypi.org/project/cachetools/
+.. _redis: https://redis.io/
+.. _memcached: https://memcached.org/

{cachetools-6.0.0b4 → cachetools-6.2.0}/src/cachetools/__init__.py

@@ -12,7 +12,7 @@ __all__ = (
     "cachedmethod",
 )
 
-__version__ = "6.0.0b4"
+__version__ = "6.2.0"
 
 import collections
 import collections.abc
@@ -170,32 +170,78 @@ class FIFOCache(Cache):
 class LFUCache(Cache):
     """Least Frequently Used (LFU) cache implementation."""
 
+    class _Link:
+        __slots__ = ("count", "keys", "next", "prev")
+
+        def __init__(self, count):
+            self.count = count
+            self.keys = set()
+
+        def unlink(self):
+            next = self.next
+            prev = self.prev
+            prev.next = next
+            next.prev = prev
+
     def __init__(self, maxsize, getsizeof=None):
         Cache.__init__(self, maxsize, getsizeof)
-        self.__counter = collections.Counter()
+        self.__root = root = LFUCache._Link(0)  # sentinel
+        root.prev = root.next = root
+        self.__links = {}
 
     def __getitem__(self, key, cache_getitem=Cache.__getitem__):
         value = cache_getitem(self, key)
         if key in self:  # __missing__ may not store item
-            self.__counter[key] -= 1
+            self.__touch(key)
         return value
 
     def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
         cache_setitem(self, key, value)
-        self.__counter[key] -= 1
+        if key in self.__links:
+            return self.__touch(key)
+        root = self.__root
+        link = root.next
+        if link.count != 1:
+            link = LFUCache._Link(1)
+            link.next = root.next
+            root.next = link.next.prev = link
+            link.prev = root
+        link.keys.add(key)
+        self.__links[key] = link
 
     def __delitem__(self, key, cache_delitem=Cache.__delitem__):
         cache_delitem(self, key)
-        del self.__counter[key]
+        link = self.__links.pop(key)
+        link.keys.remove(key)
+        if not link.keys:
+            link.unlink()
 
     def popitem(self):
         """Remove and return the `(key, value)` pair least frequently used."""
-        try:
-            ((key, _),) = self.__counter.most_common(1)
-        except ValueError:
+        root = self.__root
+        curr = root.next
+        if curr is root:
             raise KeyError("%s is empty" % type(self).__name__) from None
-        else:
-            return (key, self.pop(key))
+        key = next(iter(curr.keys))  # remove an arbitrary element
+        return (key, self.pop(key))
+
+    def __touch(self, key):
+        """Increment use count"""
+        link = self.__links[key]
+        curr = link.next
+        if curr.count != link.count + 1:
+            if len(link.keys) == 1:
+                link.count += 1
+                return
+            curr = LFUCache._Link(link.count + 1)
+            curr.next = link.next
+            link.next = curr.next.prev = curr
+            curr.prev = link
+        curr.keys.add(key)
+        link.keys.remove(key)
+        if not link.keys:
+            link.unlink()
+        self.__links[key] = curr
 
 
 class LRUCache(Cache):
@@ -242,16 +288,33 @@ class RRCache(Cache):
     def __init__(self, maxsize, choice=random.choice, getsizeof=None):
         Cache.__init__(self, maxsize, getsizeof)
         self.__choice = choice
+        self.__index = {}
+        self.__keys = []
 
     @property
     def choice(self):
         """The `choice` function used by the cache."""
         return self.__choice
 
+    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
+        cache_setitem(self, key, value)
+        if key not in self.__index:
+            self.__index[key] = len(self.__keys)
+            self.__keys.append(key)
+
+    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
+        cache_delitem(self, key)
+        index = self.__index.pop(key)
+        if index != len(self.__keys) - 1:
+            last = self.__keys[-1]
+            self.__keys[index] = last
+            self.__index[last] = index
+        self.__keys.pop()
+
     def popitem(self):
         """Remove and return a random `(key, value)` pair."""
         try:
-            key = self.__choice(list(self))
+            key = self.__choice(self.__keys)
         except IndexError:
             raise KeyError("%s is empty" % type(self).__name__) from None
         else:

{cachetools-6.0.0b4 → cachetools-6.2.0/src/cachetools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachetools
-Version: 6.0.0b4
+Version: 6.2.0
 Summary: Extensible memoizing collections and decorators
 Home-page: https://github.com/tkem/cachetools/
 Author: Thomas Kemmer
@@ -115,11 +115,12 @@ Project Resources
 Related Projects
 ------------------------------------------------------------------------
 
-- asyncache_: Helpers to use cachetools with async functions
-- cacheing_: Pure Python Cacheing Library
-- CacheToolsUtils_: Cachetools Utilities
-- kids.cache_: Kids caching library
-- shelved-cache_: Persistent cache for Python cachetools
+- asyncache_: Helpers to use cachetools_ with asyncio.
+- cacheing_: Pure Python Cacheing Library.
+- CacheToolsUtils_: Stackable cache classes for sharing, encryption,
+  statistics *and more* on top of cachetools_, redis_ and memcached_.
+- shelved-cache_: Persistent cache implementation for Python
+  cachetools_.
 
 
 License
@@ -144,7 +145,9 @@ Licensed under the `MIT License`_.
 .. _MIT License: https://raw.github.com/tkem/cachetools/master/LICENSE
 
 .. _asyncache: https://pypi.org/project/asyncache/
-.. _cacheing: https://github.com/breid48/cacheing
+.. _cacheing: https://pypi.org/project/cacheing/
 .. _CacheToolsUtils: https://pypi.org/project/CacheToolsUtils/
-.. _kids.cache: https://pypi.org/project/kids.cache/
 .. _shelved-cache: https://pypi.org/project/shelved-cache/
+.. _cachetools: https://pypi.org/project/cachetools/
+.. _redis: https://redis.io/
+.. _memcached: https://memcached.org/

{cachetools-6.0.0b4 → cachetools-6.2.0}/tests/test_cachedmethod.py

@@ -6,21 +6,35 @@ from cachetools import LRUCache, cachedmethod, keys
 
 
 class Cached:
+
+    class_cache = LRUCache(2)
+    class_count = 0
+
     def __init__(self, cache, count=0):
         self.cache = cache
         self.count = count
 
     @cachedmethod(lambda self: self.cache)
     def get(self, value):
-        count = self.count
         self.count += 1
-        return count
+        return self.count
 
     @cachedmethod(lambda self: self.cache, key=keys.typedmethodkey)
     def get_typedmethod(self, value):
-        count = self.count
         self.count += 1
-        return count
+        return self.count
+
+    @classmethod
+    @cachedmethod(lambda cls: cls.class_cache)
+    def get_classmethod(cls, value):
+        cls.class_count += 1
+        return cls.class_count
+
+    @classmethod
+    @cachedmethod(lambda cls: cls.class_cache, key=keys.typedmethodkey)
+    def get_typedclassmethod(cls, value):
+        cls.class_count += 1
+        return cls.class_count
 
 
 class Locked:
@@ -31,9 +45,8 @@ class Locked:
 
     @cachedmethod(lambda self: self.cache, lock=lambda self: self)
     def get(self, value):
-        count = self.count
         self.count += 1
-        return count
+        return self.count
 
     def __enter__(self):
         self.lock_count += 1
@@ -86,57 +99,57 @@ class CachedMethodTest(unittest.TestCase):
     def test_dict(self):
         cached = Cached({})
 
-        self.assertEqual(cached.get(0), 0)
-        self.assertEqual(cached.get(1), 1)
-        self.assertEqual(cached.get(1), 1)
-        self.assertEqual(cached.get(1.0), 1)
-        self.assertEqual(cached.get(1.0), 1)
+        self.assertEqual(cached.get(0), 1)
+        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.get(1.0), 2)
+        self.assertEqual(cached.get(1.0), 2)
 
         cached.cache.clear()
-        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.get(1), 3)
 
     def test_typedmethod_dict(self):
         cached = Cached(LRUCache(maxsize=2))
 
-        self.assertEqual(cached.get_typedmethod(0), 0)
-        self.assertEqual(cached.get_typedmethod(1), 1)
-        self.assertEqual(cached.get_typedmethod(1), 1)
-        self.assertEqual(cached.get_typedmethod(1.0), 2)
-        self.assertEqual(cached.get_typedmethod(1.0), 2)
-        self.assertEqual(cached.get_typedmethod(0.0), 3)
-        self.assertEqual(cached.get_typedmethod(0), 4)
+        self.assertEqual(cached.get_typedmethod(0), 1)
+        self.assertEqual(cached.get_typedmethod(1), 2)
+        self.assertEqual(cached.get_typedmethod(1), 2)
+        self.assertEqual(cached.get_typedmethod(1.0), 3)
+        self.assertEqual(cached.get_typedmethod(1.0), 3)
+        self.assertEqual(cached.get_typedmethod(0.0), 4)
+        self.assertEqual(cached.get_typedmethod(0), 5)
 
     def test_lru(self):
         cached = Cached(LRUCache(maxsize=2))
 
-        self.assertEqual(cached.get(0), 0)
-        self.assertEqual(cached.get(1), 1)
-        self.assertEqual(cached.get(1), 1)
-        self.assertEqual(cached.get(1.0), 1)
-        self.assertEqual(cached.get(1.0), 1)
+        self.assertEqual(cached.get(0), 1)
+        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.get(1.0), 2)
+        self.assertEqual(cached.get(1.0), 2)
 
         cached.cache.clear()
-        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.get(1), 3)
 
     def test_typedmethod_lru(self):
         cached = Cached(LRUCache(maxsize=2))
 
-        self.assertEqual(cached.get_typedmethod(0), 0)
-        self.assertEqual(cached.get_typedmethod(1), 1)
-        self.assertEqual(cached.get_typedmethod(1), 1)
-        self.assertEqual(cached.get_typedmethod(1.0), 2)
-        self.assertEqual(cached.get_typedmethod(1.0), 2)
-        self.assertEqual(cached.get_typedmethod(0.0), 3)
-        self.assertEqual(cached.get_typedmethod(0), 4)
+        self.assertEqual(cached.get_typedmethod(0), 1)
+        self.assertEqual(cached.get_typedmethod(1), 2)
+        self.assertEqual(cached.get_typedmethod(1), 2)
+        self.assertEqual(cached.get_typedmethod(1.0), 3)
+        self.assertEqual(cached.get_typedmethod(1.0), 3)
+        self.assertEqual(cached.get_typedmethod(0.0), 4)
+        self.assertEqual(cached.get_typedmethod(0), 5)
 
     def test_nospace(self):
         cached = Cached(LRUCache(maxsize=0))
 
-        self.assertEqual(cached.get(0), 0)
-        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.get(0), 1)
         self.assertEqual(cached.get(1), 2)
-        self.assertEqual(cached.get(1.0), 3)
+        self.assertEqual(cached.get(1), 3)
         self.assertEqual(cached.get(1.0), 4)
+        self.assertEqual(cached.get(1.0), 5)
 
     def test_nocache(self):
         cached = Cached(None)
@@ -144,11 +157,11 @@ class CachedMethodTest(unittest.TestCase):
         with warnings.catch_warnings(record=True) as w:
             warnings.simplefilter("always")
 
-            self.assertEqual(cached.get(0), 0)
-            self.assertEqual(cached.get(1), 1)
+            self.assertEqual(cached.get(0), 1)
             self.assertEqual(cached.get(1), 2)
-            self.assertEqual(cached.get(1.0), 3)
+            self.assertEqual(cached.get(1), 3)
             self.assertEqual(cached.get(1.0), 4)
+            self.assertEqual(cached.get(1.0), 5)
 
         self.assertEqual(len(w), 5)
         self.assertIs(w[0].category, DeprecationWarning)
@@ -166,7 +179,7 @@ class CachedMethodTest(unittest.TestCase):
 
         cached = Cached(weakref.WeakValueDictionary(), count=Int(0))
 
-        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.get(0), 1)
         gc.collect()
         self.assertEqual(cached.get(0), 1)
 
@@ -175,44 +188,44 @@ class CachedMethodTest(unittest.TestCase):
         self.assertEqual(cached.get(1), 2)
         self.assertEqual(cached.get(1.0), 2)
 
-        ref = cached.get_typedmethod(1)
+        ref = cached.get_typedmethod(2)
         self.assertEqual(ref, 3)
-        self.assertEqual(cached.get_typedmethod(1), 3)
-        self.assertEqual(cached.get_typedmethod(1.0), 4)
+        self.assertEqual(cached.get_typedmethod(1), 4)
+        self.assertEqual(cached.get_typedmethod(1.0), 5)
 
         cached.cache.clear()
-        self.assertEqual(cached.get(1), 5)
+        self.assertEqual(cached.get(1), 6)
 
     def test_locked_dict(self):
         cached = Locked({})
 
-        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.get(0), 1)
         self.assertEqual(cached.lock_count, 2)
-        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.get(1), 2)
         self.assertEqual(cached.lock_count, 4)
-        self.assertEqual(cached.get(1), 1)
+        self.assertEqual(cached.get(1), 2)
         self.assertEqual(cached.lock_count, 5)
-        self.assertEqual(cached.get(1.0), 1)
+        self.assertEqual(cached.get(1.0), 2)
         self.assertEqual(cached.lock_count, 6)
-        self.assertEqual(cached.get(1.0), 1)
+        self.assertEqual(cached.get(1.0), 2)
         self.assertEqual(cached.lock_count, 7)
 
         cached.cache.clear()
-        self.assertEqual(cached.get(1), 2)
+        self.assertEqual(cached.get(1), 3)
         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.get(0), 1)
         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, 4)
+        self.assertEqual(cached.get(1), 3)
         self.assertEqual(cached.lock_count, 6)
-        self.assertEqual(cached.get(1.0), 3)
-        self.assertEqual(cached.lock_count, 8)
         self.assertEqual(cached.get(1.0), 4)
+        self.assertEqual(cached.lock_count, 8)
+        self.assertEqual(cached.get(1.0), 5)
         self.assertEqual(cached.lock_count, 10)
 
     def test_locked_nocache(self):
@@ -221,11 +234,11 @@ class CachedMethodTest(unittest.TestCase):
         with warnings.catch_warnings(record=True) as w:
             warnings.simplefilter("always")
 
-            self.assertEqual(cached.get(0), 0)
-            self.assertEqual(cached.get(1), 1)
+            self.assertEqual(cached.get(0), 1)
             self.assertEqual(cached.get(1), 2)
-            self.assertEqual(cached.get(1.0), 3)
+            self.assertEqual(cached.get(1), 3)
             self.assertEqual(cached.get(1.0), 4)
+            self.assertEqual(cached.get(1.0), 5)
             self.assertEqual(cached.lock_count, 0)
 
         self.assertEqual(len(w), 5)
@@ -234,29 +247,29 @@ class CachedMethodTest(unittest.TestCase):
     def test_condition_dict(self):
         cached = Conditioned({})
 
-        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.get(0), 1)
         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.get(1), 2)
         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.get(1), 2)
         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.get(1.0), 2)
         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.get(1.0), 2)
         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.get(1), 3)
         self.assertEqual(cached.lock_count, 12)
         self.assertEqual(cached.wait_count, 6)
         self.assertEqual(cached.notify_count, 3)
@@ -264,23 +277,23 @@ class CachedMethodTest(unittest.TestCase):
     def test_condition_nospace(self):
         cached = Conditioned(LRUCache(maxsize=0))
 
-        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.get(0), 1)
         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.get(1), 2)
         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.get(1), 3)
         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.get(1.0), 4)
         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.get(1.0), 5)
         self.assertEqual(cached.lock_count, 15)
         self.assertEqual(cached.wait_count, 5)
         self.assertEqual(cached.notify_count, 5)
@@ -291,11 +304,11 @@ class CachedMethodTest(unittest.TestCase):
         with warnings.catch_warnings(record=True) as w:
             warnings.simplefilter("always")
 
-            self.assertEqual(cached.get(0), 0)
-            self.assertEqual(cached.get(1), 1)
+            self.assertEqual(cached.get(0), 1)
             self.assertEqual(cached.get(1), 2)
-            self.assertEqual(cached.get(1.0), 3)
+            self.assertEqual(cached.get(1), 3)
             self.assertEqual(cached.get(1.0), 4)
+            self.assertEqual(cached.get(1.0), 5)
             self.assertEqual(cached.lock_count, 0)
             self.assertEqual(cached.wait_count, 0)
             self.assertEqual(cached.notify_count, 0)
@@ -317,11 +330,11 @@ class CachedMethodTest(unittest.TestCase):
         cached = Cached(cache)
 
         self.assertEqual(len(cache), 0)
-        self.assertEqual(Cached.get.__wrapped__(cached, 0), 0)
+        self.assertEqual(Cached.get.__wrapped__(cached, 0), 1)
         self.assertEqual(len(cache), 0)
-        self.assertEqual(cached.get(0), 1)
+        self.assertEqual(cached.get(0), 2)
         self.assertEqual(len(cache), 1)
-        self.assertEqual(cached.get(0), 1)
+        self.assertEqual(cached.get(0), 2)
         self.assertEqual(len(cache), 1)
 
     def test_attributes(self):
@@ -355,7 +368,7 @@ class CachedMethodTest(unittest.TestCase):
         cache = {}
         cached = Cached(cache)
 
-        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.get(0), 1)
         self.assertEqual(len(cache), 1)
         Cached.get.cache_clear(cached)
         self.assertEqual(len(cache), 0)
@@ -364,7 +377,7 @@ class CachedMethodTest(unittest.TestCase):
         cache = {}
         cached = Locked(cache)
 
-        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.get(0), 1)
         self.assertEqual(len(cache), 1)
         self.assertEqual(cached.lock_count, 2)
         Locked.get.cache_clear(cached)
@@ -375,9 +388,47 @@ class CachedMethodTest(unittest.TestCase):
         cache = {}
         cached = Conditioned(cache)
 
-        self.assertEqual(cached.get(0), 0)
+        self.assertEqual(cached.get(0), 1)
         self.assertEqual(len(cache), 1)
         self.assertEqual(cached.lock_count, 3)
         Conditioned.get.cache_clear(cached)
         self.assertEqual(len(cache), 0)
         self.assertEqual(cached.lock_count, 4)
+
+
+class CachedClassMethodTest(unittest.TestCase):
+
+    def test(self):
+        Cached.class_cache = LRUCache(2)
+        Cached.class_count = 0
+        cached = Cached(None)
+
+        self.assertEqual(cached.get_classmethod(0), 1)
+        self.assertEqual(Cached.get_classmethod(0), 1)
+        self.assertEqual(cached.get_classmethod(1), 2)
+        self.assertEqual(Cached.get_classmethod(1), 2)
+        self.assertEqual(cached.get_classmethod(1), 2)
+        self.assertEqual(Cached.get_classmethod(1), 2)
+        self.assertEqual(cached.get_classmethod(1.0), 2)
+        self.assertEqual(Cached.get_classmethod(1.0), 2)
+        self.assertEqual(Cached.get_classmethod(1.1), 3)
+        self.assertEqual(cached.get_classmethod(1.1), 3)
+
+        cached.class_cache.clear()
+        self.assertEqual(cached.get_classmethod(1), 4)
+
+    def test_typedmethod(self):
+        Cached.class_cache = LRUCache(2)
+        Cached.class_count = 0
+        cached = Cached(None)
+
+        self.assertEqual(cached.get_typedclassmethod(0), 1)
+        self.assertEqual(Cached.get_typedclassmethod(0), 1)
+        self.assertEqual(cached.get_typedclassmethod(1), 2)
+        self.assertEqual(Cached.get_typedclassmethod(1), 2)
+        self.assertEqual(cached.get_typedclassmethod(1.0), 3)
+        self.assertEqual(Cached.get_typedclassmethod(1.0), 3)
+        self.assertEqual(cached.get_typedclassmethod(0.0), 4)
+        self.assertEqual(Cached.get_typedclassmethod(0.0), 4)
+        self.assertEqual(Cached.get_typedclassmethod(0), 5)
+        self.assertEqual(cached.get_typedclassmethod(0), 5)

{cachetools-6.0.0b4 → cachetools-6.2.0}/tests/test_fifo.py

@@ -5,7 +5,7 @@ from cachetools import FIFOCache
 from . import CacheTestMixin
 
 
-class LRUCacheTest(unittest.TestCase, CacheTestMixin):
+class FIFOCacheTest(unittest.TestCase, CacheTestMixin):
     Cache = FIFOCache
 
     def test_fifo(self):
@@ -54,3 +54,15 @@ class LRUCacheTest(unittest.TestCase, CacheTestMixin):
             cache[4] = 4
         self.assertEqual(len(cache), 1)
         self.assertEqual(cache[3], 3)
+
+    def test_fifo_update_existing(self):
+        cache = FIFOCache(maxsize=2)
+
+        cache[1] = 1
+        cache[2] = 2
+        cache[1] = "updated"
+        cache[3] = 3
+
+        self.assertEqual(cache[1], "updated")
+        self.assertIn(3, cache)
+        self.assertNotIn(2, cache)

{cachetools-6.0.0b4 → cachetools-6.2.0}/tests/test_func.py

@@ -76,6 +76,11 @@ class DecoratorTestMixin:
         self.assertEqual(cached.cache_info(), (2, 1, 128, 1))
 
     def test_decorator_needs_rlock(self):
+        """This will deadlock on a cache that uses a regular lock.
+        https://github.com/python/cpython/blob/3.13/Lib/test/test_functools.py#L1791
+
+        """
+
         cached = self.decorator(lambda n: n)
 
         class RecursiveEquals:

{cachetools-6.0.0b4 → cachetools-6.2.0}/tests/test_lfu.py

@@ -26,6 +26,11 @@ class LFUCacheTest(unittest.TestCase, CacheTestMixin):
         self.assertEqual(cache[4], 4)
         self.assertEqual(cache[1], 1)
 
+        cache[1]
+        self.assertEqual(len(cache), 2)
+        self.assertEqual(cache[1], 1)
+        self.assertEqual(cache[4], 4)
+
     def test_lfu_getsizeof(self):
         cache = LFUCache(maxsize=3, getsizeof=lambda x: x)
 
@@ -47,3 +52,15 @@ class LFUCacheTest(unittest.TestCase, CacheTestMixin):
             cache[4] = 4
         self.assertEqual(len(cache), 1)
         self.assertEqual(cache[3], 3)
+
+    def test_lfu_update_existing(self):
+        cache = LFUCache(maxsize=2)
+
+        cache[1] = 1
+        cache[2] = 2
+        cache[1] = "updated"
+        cache[3] = 3
+
+        self.assertEqual(cache[1], "updated")
+        self.assertIn(3, cache)
+        self.assertNotIn(2, cache)

{cachetools-6.0.0b4 → cachetools-6.2.0}/tests/test_lru.py

@@ -54,3 +54,15 @@ class LRUCacheTest(unittest.TestCase, CacheTestMixin):
             cache[4] = 4
         self.assertEqual(len(cache), 1)
         self.assertEqual(cache[3], 3)
+
+    def test_lru_update_existing(self):
+        cache = LRUCache(maxsize=2)
+
+        cache[1] = 1
+        cache[2] = 2
+        cache[1] = "updated"
+        cache[3] = 3
+
+        self.assertEqual(cache[1], "updated")
+        self.assertIn(3, cache)
+        self.assertNotIn(2, cache)

cachetools-6.2.0/tests/test_rr.py

@@ -0,0 +1,83 @@
+import random
+import unittest
+
+from cachetools import RRCache
+
+from . import CacheTestMixin
+
+
+class RRCacheTest(unittest.TestCase, CacheTestMixin):
+    Cache = RRCache
+
+    def test_rr(self):
+        cache = RRCache(maxsize=2, choice=min)
+        self.assertEqual(min, cache.choice)
+
+        cache[1] = 1
+        cache[2] = 2
+        cache[3] = 3
+
+        self.assertEqual(2, len(cache))
+        self.assertEqual(2, cache[2])
+        self.assertEqual(3, cache[3])
+        self.assertNotIn(1, cache)
+
+        cache[0] = 0
+        self.assertEqual(2, len(cache))
+        self.assertEqual(0, cache[0])
+        self.assertEqual(3, cache[3])
+        self.assertNotIn(2, cache)
+
+        cache[4] = 4
+        self.assertEqual(2, len(cache))
+        self.assertEqual(3, cache[3])
+        self.assertEqual(4, cache[4])
+        self.assertNotIn(0, cache)
+
+    def test_rr_getsizeof(self):
+        cache = RRCache(maxsize=3, choice=min, getsizeof=lambda x: x)
+
+        cache[1] = 1
+        cache[2] = 2
+
+        self.assertEqual(len(cache), 2)
+        self.assertEqual(cache[1], 1)
+        self.assertEqual(cache[2], 2)
+
+        cache[3] = 3
+
+        self.assertEqual(len(cache), 1)
+        self.assertEqual(cache[3], 3)
+        self.assertNotIn(1, cache)
+        self.assertNotIn(2, cache)
+
+        with self.assertRaises(ValueError):
+            cache[4] = 4
+        self.assertEqual(len(cache), 1)
+        self.assertEqual(cache[3], 3)
+
+    def test_rr_update_existing(self):
+        cache = RRCache(maxsize=2, choice=min)
+
+        cache[1] = 1
+        cache[2] = 2
+        cache[1] = "updated"
+        cache[3] = 3
+
+        self.assertIn(2, cache)
+        self.assertIn(3, cache)
+        self.assertNotIn(1, cache)
+
+    def test_rr_bad_choice(self):
+        def bad_choice(seq):
+            raise ValueError("test error")
+
+        cache = RRCache(maxsize=2, choice=bad_choice)
+        cache[1] = 1
+        cache[2] = 2
+        with self.assertRaises(ValueError):
+            cache[3] = 3
+
+    def test_rr_default_choice(self):
+        cache = RRCache(maxsize=2)
+        self.assertIs(cache.choice, random.choice)

cachetools-6.0.0b4/tests/test_rr.py

@@ -1,34 +0,0 @@
-import unittest
-
-from cachetools import RRCache
-
-from . import CacheTestMixin
-
-
-class RRCacheTest(unittest.TestCase, CacheTestMixin):
-    Cache = RRCache
-
-    def test_rr(self):
-        cache = RRCache(maxsize=2, choice=min)
-        self.assertEqual(min, cache.choice)
-
-        cache[1] = 1
-        cache[2] = 2
-        cache[3] = 3
-
-        self.assertEqual(2, len(cache))
-        self.assertEqual(2, cache[2])
-        self.assertEqual(3, cache[3])
-        self.assertNotIn(1, cache)
-
-        cache[0] = 0
-        self.assertEqual(2, len(cache))
-        self.assertEqual(0, cache[0])
-        self.assertEqual(3, cache[3])
-        self.assertNotIn(2, cache)
-
-        cache[4] = 4
-        self.assertEqual(2, len(cache))
-        self.assertEqual(3, cache[3])
-        self.assertEqual(4, cache[4])
-        self.assertNotIn(0, cache)