cachetools 6.2.5__tar.gz → 6.2.6__tar.gz

{cachetools-6.2.5 → cachetools-6.2.6}/CHANGELOG.rst

@@ -1,3 +1,15 @@
+v6.2.6 (2026-01-27)
+===================
+
+- Improve typedkey performance.
+
+- Minor documentation improvements.
+
+- Minor testing improvements.
+
+- Minor code readability improvements.
+
+
 v6.2.5 (2026-01-25)
 ===================
 

{cachetools-6.2.5/src/cachetools.egg-info → cachetools-6.2.6}/PKG-INFO

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

{cachetools-6.2.5 → cachetools-6.2.6}/docs/index.rst

@@ -35,11 +35,11 @@ Cache implementations
 This module provides several classes implementing caches using
 different cache algorithms.  All these classes derive from class
 :class:`Cache`, which in turn derives from
-:class:`collections.MutableMapping`, and provide :attr:`maxsize` and
-:attr:`currsize` properties to retrieve the maximum and current size
-of the cache.  When a cache is full, :meth:`Cache.__setitem__()` calls
-:meth:`self.popitem()` repeatedly until there is enough room for the
-item to be added.
+:class:`collections.abc.MutableMapping`, and provide :attr:`maxsize`
+and :attr:`currsize` properties to retrieve the maximum and current
+size of the cache.  When a cache is full, :meth:`Cache.__setitem__()`
+calls :meth:`self.popitem()` repeatedly until there is enough room for
+the item to be added.
 
 .. note::
 
@@ -53,8 +53,9 @@ returns the size of a given `value`.  The default implementation of
 :meth:`getsizeof` returns :const:`1` irrespective of its argument,
 making the cache's size equal to the number of its items, or
 `len(cache)`.  For convenience, all cache classes accept an optional
-named constructor parameter `getsizeof`, which may specify a function
-of one argument used to retrieve the size of an item's value.
+named constructor parameter `getsizeof`, which may specify a callable
+``getsizeof(value) -> int`` used to retrieve the size of an item's
+value.
 
 The values of a :class:`Cache` are mutable by default, as are e.g. the
 values of a :class:`dict`.  It is the user's responsibility to take

{cachetools-6.2.5 → cachetools-6.2.6}/src/cachetools/__init__.py

@@ -12,7 +12,7 @@ __all__ = (
     "cachedmethod",
 )
 
-__version__ = "6.2.5"
+__version__ = "6.2.6"
 
 import collections
 import collections.abc
@@ -540,6 +540,8 @@ class TTLCache(_TimedCache):
 class TLRUCache(_TimedCache):
     """Time aware Least Recently Used (TLRU) cache implementation."""
 
+    __HEAP_CLEANUP_FACTOR = 2  # clean up the heap if size > N * len(items)
+
     @functools.total_ordering
     class _Item:
         __slots__ = ("key", "expires", "removed")
@@ -625,7 +627,7 @@ class TLRUCache(_TimedCache):
         items = self.__items
         order = self.__order
         # clean up the heap if too many items are marked as removed
-        if len(order) > len(items) * 2:
+        if len(order) > len(items) * self.__HEAP_CLEANUP_FACTOR:
             self.__order = order = [item for item in order if not item.removed]
             heapq.heapify(order)
         expired = []

{cachetools-6.2.5 → cachetools-6.2.6}/src/cachetools/func.py

@@ -24,6 +24,9 @@ class _UnboundTTLCache(TTLCache):
 
 def _cache(cache, maxsize, typed):
     def decorator(func):
+        # like functools.lru_cache, this has to be thread-safe;
+        # additionally, this also prevents cache stampede scenarios
+        # using a condition variable
         key = keys.typedkey if typed else keys.hashkey
         wrapper = cached(cache=cache, key=key, condition=Condition(), info=True)(func)
         wrapper.cache_parameters = lambda: {"maxsize": maxsize, "typed": typed}

{cachetools-6.2.5 → cachetools-6.2.6}/src/cachetools/keys.py

@@ -51,10 +51,13 @@ def methodkey(self, *args, **kwargs):
 def typedkey(*args, **kwargs):
     """Return a typed cache key for the specified hashable arguments."""
 
-    key = hashkey(*args, **kwargs)
+    if kwargs:
+        sorted_kwargs = tuple(sorted(kwargs.items()))
+        key = _HashedTuple(args + _kwmark + sorted_kwargs)
+        key += tuple(type(v) for _, v in sorted_kwargs)
+    else:
+        key = _HashedTuple(args)
     key += tuple(type(v) for v in args)
-    # TODO: avoid iterating twice over kwargs
-    key += tuple(type(v) for _, v in sorted(kwargs.items()))
     return key
 
 

{cachetools-6.2.5 → cachetools-6.2.6/src/cachetools.egg-info}/PKG-INFO

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

{cachetools-6.2.5 → cachetools-6.2.6}/tests/__init__.py

@@ -98,9 +98,12 @@ class CacheTestMixin:
         cache = self.Cache(maxsize=2)
 
         cache.update({1: 1, 2: 2})
-        self.assertIn(cache.pop(1), {1: 1, 2: 2})
+
+        key, _ = cache.popitem()
+        self.assertIn(key, {1, 2})
         self.assertEqual(1, len(cache))
-        self.assertIn(cache.pop(2), {1: 1, 2: 2})
+        key, _ = cache.popitem()
+        self.assertIn(key, {1, 2})
         self.assertEqual(0, len(cache))
 
         with self.assertRaises(KeyError):

{cachetools-6.2.5 → cachetools-6.2.6}/tests/test_keys.py

@@ -21,7 +21,7 @@ class CacheKeysTest(unittest.TestCase):
         self.assertEqual(key(1, 2, 3), key(1.0, 2.0, 3.0))
         self.assertEqual(hash(key(1, 2, 3)), hash(key(1.0, 2.0, 3.0)))
 
-    def methodkey(self, key=cachetools.keys.methodkey):
+    def test_methodkey(self, key=cachetools.keys.methodkey):
         # similar to hashkey(), but ignores its first positional argument
         self.assertEqual(key("x"), key("y"))
         self.assertEqual(hash(key("x")), hash(key("y")))