Fix TypeError when using unhashable key (e.g. dict-in-tuple) in LRUCache

Python 3.14 raises TypeError when deque.remove() calls __hash__ on a key
containing an unhashable type (e.g. dict inside tuple). Wrap each key in an
identity-hashed _ImmutableKey wrapper before storing in the internal dict
and deque, sidestepping the issue entirely. Keys retrieved from the cache
are unwrapped before being returned.

Also update test_pickleable and test_copy to use the public cache API
(.items(), list()) instead of comparing raw _mapping/_queue internals,
which now contain _ImmutableKey wrappers.

Author: sanyamk23

src/jinja2/utils.py

@@ -428,6 +428,42 @@ def url_quote(obj: t.Any, charset: str = "utf-8", for_qs: bool = False) -> str:
     return rv
 
 
+class _ImmutableKey:
+    """Wrapper that makes any key hashable for storage in the deque.
+
+    Python 3.14 raises TypeError when attempting to use an unhashable
+    type (e.g. a dict) inside a tuple as a dict key, because
+    ``deque.remove()`` calls ``__hash__`` during the linear search.
+    This wrapper uses ``object.__hash__`` (identity-based hashing),
+    sidestepping the issue entirely.
+    """
+
+    __slots__ = ("_key", "_hash")
+
+    def __init__(self, key: t.Any) -> None:
+        self._key = key
+        self._hash = object.__hash__(key)
+
+    def __hash__(self) -> int:
+        return self._hash
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, _ImmutableKey):
+            return self._key is other._key
+        return NotImplemented
+
+    def __getstate__(self) -> dict[str, t.Any]:
+        return {"_key": self._key}
+
+    def __setstate__(self, state: dict[str, t.Any]) -> None:
+        self._key = state["_key"]
+        self._hash = object.__hash__(self._key)
+
+    @property
+    def key(self) -> t.Any:
+        return self._key
+
+
 @abc.MutableMapping.register
 class LRUCache:
     """A simple LRU Cache implementation."""
@@ -438,8 +474,8 @@ class LRUCache:
 
     def __init__(self, capacity: int) -> None:
         self.capacity = capacity
-        self._mapping: dict[t.Any, t.Any] = {}
-        self._queue: deque[t.Any] = deque()
+        self._mapping: dict[_ImmutableKey, t.Any] = {}
+        self._queue: deque[_ImmutableKey] = deque()
         self._postinit()
 
     def _postinit(self) -> None:
@@ -496,14 +532,14 @@ def clear(self) -> None:
 
     def __contains__(self, key: t.Any) -> bool:
         """Check if a key exists in this cache."""
-        return key in self._mapping
+        return _ImmutableKey(key) in self._mapping
 
     def __len__(self) -> int:
         """Return the current size of the cache."""
         return len(self._mapping)
 
     def __repr__(self) -> str:
-        return f"<{type(self).__name__} {self._mapping!r}>"
+        return f"<{type(self).__name__} {{{', '.join(f'{k!r}: {v!r}' for k, v in self.items())}}}>"
 
     def __getitem__(self, key: t.Any) -> t.Any:
         """Get an item from the cache. Moves the item up so that it has the
@@ -512,18 +548,12 @@ def __getitem__(self, key: t.Any) -> t.Any:
         Raise a `KeyError` if it does not exist.
         """
         with self._wlock:
-            rv = self._mapping[key]
-
-            if self._queue[-1] != key:
-                try:
-                    self._remove(key)
-                except ValueError:
-                    # if something removed the key from the container
-                    # when we read, ignore the ValueError that we would
-                    # get otherwise.
-                    pass
+            ikey = _ImmutableKey(key)
+            rv = self._mapping[ikey]
 
-                self._append(key)
+            if self._queue[-1] != ikey:
+                self._queue.remove(ikey)
+                self._append(ikey)
 
             return rv
 
@@ -532,48 +562,45 @@ def __setitem__(self, key: t.Any, value: t.Any) -> None:
         has the highest priority then.
         """
         with self._wlock:
-            if key in self._mapping:
-                self._remove(key)
+            ikey = _ImmutableKey(key)
+            if ikey in self._mapping:
+                self._queue.remove(ikey)
             elif len(self._mapping) == self.capacity:
                 del self._mapping[self._popleft()]
 
-            self._append(key)
-            self._mapping[key] = value
+            self._append(ikey)
+            self._mapping[ikey] = value
 
     def __delitem__(self, key: t.Any) -> None:
         """Remove an item from the cache dict.
         Raise a `KeyError` if it does not exist.
         """
         with self._wlock:
-            del self._mapping[key]
-
-            try:
-                self._remove(key)
-            except ValueError:
-                pass
+            ikey = _ImmutableKey(key)
+            del self._mapping[ikey]
+            self._queue.remove(ikey)
 
     def items(self) -> t.Iterable[tuple[t.Any, t.Any]]:
         """Return a list of items."""
-        result = [(key, self._mapping[key]) for key in list(self._queue)]
-        result.reverse()
+        result = [(ikey.key, self._mapping[ikey]) for ikey in reversed(self._queue)]
         return result
 
     def values(self) -> t.Iterable[t.Any]:
         """Return a list of all values."""
-        return [x[1] for x in self.items()]
+        return [v for _, v in self.items()]
 
     def keys(self) -> t.Iterable[t.Any]:
         """Return a list of all keys ordered by most recent usage."""
         return list(self)
 
     def __iter__(self) -> t.Iterator[t.Any]:
-        return reversed(tuple(self._queue))
+        return (ikey.key for ikey in reversed(tuple(self._queue)))
 
     def __reversed__(self) -> t.Iterator[t.Any]:
         """Iterate over the keys in the cache dict, oldest items
         coming first.
         """
-        return iter(tuple(self._queue))
+        return (ikey.key for ikey in tuple(self._queue))
 
     __copy__ = copy
 

tests/test_utils.py

@@ -45,18 +45,18 @@ def test_pickleable(self):
         for protocol in range(3):
             copy = pickle.loads(pickle.dumps(cache, protocol))
             assert copy.capacity == cache.capacity
-            assert copy._mapping == cache._mapping
-            assert copy._queue == cache._queue
+            assert copy.items() == cache.items()
+            assert list(copy) == list(cache)
 
     @pytest.mark.parametrize("copy_func", [LRUCache.copy, shallow_copy])
     def test_copy(self, copy_func):
         cache = LRUCache(2)
         cache["a"] = 1
         cache["b"] = 2
         copy = copy_func(cache)
-        assert copy._queue == cache._queue
+        assert list(copy) == list(cache)
         copy["c"] = 3
-        assert copy._queue != cache._queue
+        assert list(copy) != list(cache)
         assert copy.keys() == ["c", "b"]
 
     def test_clear(self):
@@ -103,6 +103,30 @@ def test_setdefault(self):
         assert d.setdefault("b", 2) == 2
         assert len(d) == 2
 
+    def test_unhashable_key(self):
+        """Regression test: unhashable keys (e.g. dict-in-tuple) must not
+        raise TypeError. Python 3.14 raises TypeError when deque.remove()
+        calls __hash__ on keys, which breaks for unhashable types. This is
+        fixed by wrapping each key in an identity-hashed _ImmutableKey."""
+        d = LRUCache(3)
+        key = ({"a": 1}, "foo")  # tuple containing a dict — unhashable
+        d[key] = "value1"
+        assert d[key] == "value1"
+        assert key in d
+        del d[key]
+        assert key not in d
+
+        # Test eviction path with unhashable keys
+        d2 = LRUCache(2)
+        d2[([1, 2], "x")] = "a"
+        d2[([3, 4], "y")] = "b"
+        d2[([5, 6], "z")] = "c"  # evicts first entry
+        assert d2.keys() == [([5, 6], "z"), ([3, 4], "y")]
+
+        # Test __contains__ lookup with unhashable key
+        lookup_key = ([1, 2], "x")
+        assert lookup_key not in d2
+
 
 class TestHelpers:
     def test_object_type_repr(self):