cachebox 6.2.9__tar.gz → 6.2.10__tar.gz

{cachebox-6.2.9 → cachebox-6.2.10}/Cargo.lock

@@ -37,7 +37,7 @@ checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
 
 [[package]]
 name = "cachebox"
-version = "6.2.9"
+version = "6.2.10"
 dependencies = [
  "allocator-api2",
  "cfg-if",

{cachebox-6.2.9 → cachebox-6.2.10}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cachebox"
-version = "6.2.9"
+version = "6.2.10"
 edition = "2024"
 description = "The fastest memoizing and caching Python library written in Rust"
 readme = "README.md"

{cachebox-6.2.9 → cachebox-6.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachebox
-Version: 6.2.9
+Version: 6.2.10
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{cachebox-6.2.9 → cachebox-6.2.10}/docs/docs/algorithms.md

@@ -15,7 +15,8 @@ in **when** and **which** entries are removed under pressure (or over time).
 | [`TTLCache`](#ttlcache)   | Global TTL + FIFO among live entries    | Uniform freshness windows              | Per-key TTLs needed              |
 | [`VTTLCache`](#vttlcache) | Per-item TTL (optional non-expiring)    | Mixed lifetimes                        | All items share one TTL          |
 
-Complexity (worst-case, amortized where marked with `~`):
+Complexity (expected, as for any hash table; amortized where marked with `~`; `e` is the number of
+expired entries the call removes):
 
 | Class       | get  | insert         | delete         | popitem       |
 | ----------- | ---- | -------------- | -------------- | ------------- |
@@ -24,9 +25,13 @@ Complexity (worst-case, amortized where marked with `~`):
 | `RRCache`   | O(1) | O(1)~          | O(1)           | O(1) expected |
 | `LRUCache`  | O(1) | O(1)~          | O(1)           | O(1)          |
 | `LFUCache`  | O(1) | O(log n)~      | O(log n)       | O(log n)~     |
-| `TTLCache`  | O(1) | O(e)~          | O(n)           | O(1)~         |
+| `TTLCache`  | O(1) | O(e+1)~        | O(n)           | O(1)~         |
 | `VTTLCache` | O(1) | O((e+1) log n) | O((e+1) log n) | O(log n)~     |
 
+`LFUCache.get` only bumps a counter; the heap is repaired on the next eviction, so a `popitem`
+after `k` reads takes O(k log n), which amortizes to O(log n) per read. Iterating an `LFUCache` or
+a `VTTLCache` re-sorts all entries, O(n log n), when anything changed since the last iteration.
+
 ## Decision Guide
 
 ```
@@ -56,7 +61,7 @@ print(cache["key"])  # value
 
 # Overflow when full
 cache.update({i: i for i in range(200)})
-# OverflowError: The cache has reached the bound.
+# OverflowError: The cache has no algorithm to evict items
 
 # popitem always fails — there is no eviction order
 cache.popitem()  # OverflowError
@@ -138,7 +143,7 @@ print(cache.least_recently_used())  # still 2 if nothing else was accessed
 ## LFUCache
 
 Least-Frequently-Used. The key with the lowest access count is evicted first. Ties are broken by
-recency (older first).
+insertion order (inserted earlier first).
 
 ```python
 from cachebox import LFUCache
@@ -208,9 +213,10 @@ cache3.stop_sweeper()  # stop the daemon thread when done
 
 !!! note "Lazy expiry"
 
-    Without `sweep_interval`, expired entries linger until the next interaction
-    (`insert`, `get`, iteration, `current_size`, …). See
-    [TTL sweepers](tips.md#ttlcachevttlcache-background-thread).
+    Without `sweep_interval`, expired entries are misses for `get` and `[]` but stay in the
+    cache, and `len()` / `bool()` still count them, until an insert, iteration, `current_size()`
+    or `expire()` removes them. See
+    [TTL sweepers](tips.md#ttlcache-vttlcache-background-thread).
 
 ---
 
@@ -227,7 +233,8 @@ import time
 # ttl= here applies only to the initial iterable, not as a global default
 cache = VTTLCache(100, iterable={i: i for i in range(4)}, ttl=3)
 time.sleep(3)
-print(len(cache))  # 0 after interaction/expire
+cache.expire()
+print(len(cache))  # 0
 
 cache.insert("session", "tok", ttl=5)  # lives 5 seconds
 cache.insert("config", {"theme": "dark"})  # never expires
@@ -275,6 +282,7 @@ Regardless of policy:
 - **`getsizeof`** — optional weighted capacity (see [Getting Started](getting-started.md#capacity-size-and-weighted-entries)).
 - **`insert` preferred over `[]=`** when you need the previous value or cross-policy consistency.
 - **Iterators are one-shot** — not live dict views; modifying the cache while iterating raises
-  `RuntimeError`.
+  `RuntimeError`. In an `LRUCache`, `get` and `[]` count as modifications (they reorder entries);
+  in an `LFUCache`, starting a new iteration after a read invalidates iterators already open.
 
 Full method lists: [API Reference — Classes](api/impls.md).

{cachebox-6.2.9 → cachebox-6.2.10}/pyproject.toml

@@ -55,8 +55,8 @@ lint = [
   "ruff>=0.16.9",
 ]
 maturin = [
-  "maturin == 1.14.1 ; sys_platform != 'linux'",
-  "maturin[patchelf] == 1.14.1 ; sys_platform == 'linux'",
+  "maturin == 1.15.0 ; sys_platform != 'linux'",
+  "maturin[patchelf] == 1.15.0 ; sys_platform == 'linux'",
 ]
 test = [
   "hypothesis >= 6.165.0",

{cachebox-6.2.9 → cachebox-6.2.10}/src/internal/linked_list.rs

@@ -1,11 +1,9 @@
+use std::alloc::Layout;
 use std::alloc::alloc;
 use std::alloc::dealloc;
 use std::alloc::handle_alloc_error;
-use std::alloc::Layout;
 use std::marker::PhantomData;
-use std::mem;
-use std::ptr::NonNull;
-use std::ptr::{self};
+use std::ptr;
 
 /// Maximum number of nodes parked on the free list
 const FREE_LIST_CAPACITY: usize = 256;
@@ -42,7 +40,7 @@ pub struct Node<T> {
 
 /// A doubly-linked list with an internal, bounded free-list for node reuse.
 pub struct LinkedList<T> {
-    sentinel: NonNull<Links>,
+    sentinel: ptr::NonNull<Links>,
     free_head: *mut Links,
     free_len: usize,
     len: usize,
@@ -61,7 +59,7 @@ impl<T> LinkedList<T> {
     /// - The caller must not use `node` again as an "unlinked" node until it is
     ///   unlinked again.
     #[inline]
-    unsafe fn push_front_node(&mut self, node: NonNull<Links>) {
+    unsafe fn push_front_node(&mut self, node: ptr::NonNull<Links>) {
         let s = self.sentinel.as_ptr();
         let n = node.as_ptr();
         unsafe {
@@ -80,7 +78,7 @@ impl<T> LinkedList<T> {
     ///
     /// Same contract as [`push_front_node`](Self::push_front_node).
     #[inline]
-    unsafe fn push_back_node(&mut self, node: NonNull<Links>) {
+    unsafe fn push_back_node(&mut self, node: ptr::NonNull<Links>) {
         let s = self.sentinel.as_ptr();
         let n = node.as_ptr();
         unsafe {
@@ -95,7 +93,7 @@ impl<T> LinkedList<T> {
 
     /// Removes and returns the node at the front of the list, if any.
     #[inline]
-    fn pop_front_node(&mut self) -> Option<NonNull<Links>> {
+    fn pop_front_node(&mut self) -> Option<ptr::NonNull<Links>> {
         if self.len == 0 {
             return None;
         }
@@ -110,12 +108,12 @@ impl<T> LinkedList<T> {
         };
         self.len -= 1;
         // SAFETY: read from a valid node above, so non-null.
-        Some(unsafe { NonNull::new_unchecked(node) })
+        Some(unsafe { ptr::NonNull::new_unchecked(node) })
     }
 
     /// Removes and returns the node at the back of the list, if any.
     #[inline]
-    fn pop_back_node(&mut self) -> Option<NonNull<Links>> {
+    fn pop_back_node(&mut self) -> Option<ptr::NonNull<Links>> {
         if self.len == 0 {
             return None;
         }
@@ -130,7 +128,7 @@ impl<T> LinkedList<T> {
         };
         self.len -= 1;
         // SAFETY: read from a valid node above, so non-null.
-        Some(unsafe { NonNull::new_unchecked(node) })
+        Some(unsafe { ptr::NonNull::new_unchecked(node) })
     }
 
     /// Unlinks `node` from the list, without deallocating or reading its element.
@@ -139,7 +137,7 @@ impl<T> LinkedList<T> {
     ///
     /// `node` must point to a node currently linked into this list (not the sentinel).
     #[inline]
-    unsafe fn unlink_node(&mut self, node: NonNull<Links>) {
+    unsafe fn unlink_node(&mut self, node: ptr::NonNull<Links>) {
         let n = node.as_ptr();
         unsafe {
             // SAFETY: `n` linked per fn contract; `prev`/`next` valid.
@@ -182,7 +180,7 @@ impl<T> LinkedList<T> {
     /// `node` must point to a node whose `element` is initialized and which is
     /// no longer linked into the list (already unlinked by the caller).
     #[inline]
-    unsafe fn take_element_and_recycle(&mut self, node: NonNull<Links>) -> T {
+    unsafe fn take_element_and_recycle(&mut self, node: ptr::NonNull<Links>) -> T {
         let node_ptr = node.as_ptr() as *mut Node<T>;
         // SAFETY: `element` initialized per fn contract; `ptr::read` doesn't drop.
         let element = unsafe { ptr::read(&(*node_ptr).element) };
@@ -197,7 +195,7 @@ impl<T> LinkedList<T> {
     ///
     /// `node` must point to a node currently linked into this list
     #[inline]
-    unsafe fn remove_node(&mut self, node: NonNull<Links>) -> T {
+    unsafe fn remove_node(&mut self, node: ptr::NonNull<Links>) -> T {
         // SAFETY: caller guarantees `node` is linked.
         unsafe { self.unlink_node(node) };
         self.len -= 1;
@@ -212,20 +210,23 @@ impl<T> LinkedList<T> {
     fn drop_nodes(&mut self) {
         let s = self.sentinel.as_ptr();
         while self.len != 0 {
-            unsafe {
+            let element = unsafe {
                 // SAFETY: `self.len != 0`, so `(*s).next` points to a real node.
                 let node = (*s).next;
                 let second = (*node).next;
                 (*second).prev = s;
                 (*s).next = second;
 
-                let node_ptr = node as *mut Node<T>;
                 // SAFETY: layout-compatible (see `Node` docs); `element` still init.
-                ptr::drop_in_place(&mut (*node_ptr).element);
-                // SAFETY: element dropped above; node already unlinked.
+                let element = ptr::read(&(*(node as *mut Node<T>)).element);
+                // SAFETY: element moved out above; node already unlinked.
                 self.recycle_node(node);
-            }
+                element
+            };
             self.len -= 1;
+            // Dropped last: if this panics, the list is already consistent and
+            // the drop guard can carry on.
+            drop(element);
         }
     }
 
@@ -302,7 +303,7 @@ impl<T> LinkedList<T> {
             p
         };
         // SAFETY: non-null checked above (or diverged).
-        let sentinel = unsafe { NonNull::new_unchecked(raw) };
+        let sentinel = unsafe { ptr::NonNull::new_unchecked(raw) };
         LinkedList {
             sentinel,
             free_head: ptr::null_mut(),
@@ -348,7 +349,7 @@ impl<T> LinkedList<T> {
         let node = unsafe { (*s).next };
         // SAFETY: non-null above; layout-compatible (see `Node` docs).
         Some(Cursor(unsafe {
-            NonNull::new_unchecked(node as *mut Node<T>)
+            ptr::NonNull::new_unchecked(node as *mut Node<T>)
         }))
     }
 
@@ -364,7 +365,7 @@ impl<T> LinkedList<T> {
         let node = unsafe { (*s).prev };
         // SAFETY: same as `cursor_front`.
         Some(Cursor(unsafe {
-            NonNull::new_unchecked(node as *mut Node<T>)
+            ptr::NonNull::new_unchecked(node as *mut Node<T>)
         }))
     }
 
@@ -373,13 +374,13 @@ impl<T> LinkedList<T> {
     pub fn push_front(&mut self, elt: T) -> Cursor<T> {
         let node = self.get_node(elt);
         // SAFETY: `get_node` never returns null.
-        let links = unsafe { NonNull::new_unchecked(node as *mut Links) };
+        let links = unsafe { ptr::NonNull::new_unchecked(node as *mut Links) };
 
         // SAFETY: freshly obtained node, unlinked (see `push_front_node` contract).
         unsafe { self.push_front_node(links) };
         self.len += 1;
         // SAFETY: same pointer validated above.
-        Cursor(unsafe { NonNull::new_unchecked(node) })
+        Cursor(unsafe { ptr::NonNull::new_unchecked(node) })
     }
 
     /// Removes and returns the front element, or `None` if the list is empty.
@@ -397,14 +398,14 @@ impl<T> LinkedList<T> {
     pub fn push_back(&mut self, elt: T) -> Cursor<T> {
         let node = self.get_node(elt);
         // SAFETY: `get_node` always returns a non-null, freshly-usable `Node<T>` pointer.
-        let links = unsafe { NonNull::new_unchecked(node as *mut Links) };
+        let links = unsafe { ptr::NonNull::new_unchecked(node as *mut Links) };
 
         // SAFETY: `links` refers to a node that was just obtained and is
         // not linked into any list yet.
         unsafe { self.push_back_node(links) };
         self.len += 1;
         // SAFETY: `node` is the same non-null pointer validated above.
-        Cursor(unsafe { NonNull::new_unchecked(node) })
+        Cursor(unsafe { ptr::NonNull::new_unchecked(node) })
     }
 
     /// Removes and returns the back element, or `None` if the list is empty.
@@ -439,17 +440,22 @@ impl<T> LinkedList<T> {
     }
 }
 
-// Guard ensures that if dropping an element panics, we still free
-// the free-list allocations instead of leaking them (the sentinel
-// is freed unconditionally below regardless of panics).
+// Frees the rest of the list when it goes out of scope, which also covers an
+// element destructor panicking in `LinkedList::drop`: the remaining elements,
+// the free list and the sentinel are freed either way.
 struct DropGuard<'a, T>(&'a mut LinkedList<T>);
 
 impl<'a, T> Drop for DropGuard<'a, T> {
     fn drop(&mut self) {
         self.0.drop_nodes();
-        // SAFETY: `self` is being torn down during unwind; no other
-        // references to the free list exist, satisfying `drop_freelist`'s contract.
-        unsafe { self.0.drop_freelist() };
+        unsafe {
+            // SAFETY: the list is being destroyed; no other references to the
+            // free list exist, satisfying `drop_freelist`'s contract.
+            self.0.drop_freelist();
+            // SAFETY: `sentinel` was allocated in `new` with exactly this
+            // layout and is never dereferenced after this point.
+            dealloc(self.0.sentinel.as_ptr() as *mut u8, Layout::new::<Links>());
+        }
     }
 }
 
@@ -457,16 +463,7 @@ impl<T> Drop for LinkedList<T> {
     fn drop(&mut self) {
         let guard = DropGuard(self);
         guard.0.drop_nodes();
-        // SAFETY: `drop_nodes` completed without panicking; the free list is
-        // only touched here and then never again (guard is forgotten next).
-        unsafe { guard.0.drop_freelist() };
-        mem::forget(guard);
-        // SAFETY: `self.sentinel` was allocated in `new` with exactly this
-        // layout (`Layout::new::<Links>()`), and after this point `self` is
-        // being destroyed, so the pointer is never dereferenced again.
-        unsafe {
-            dealloc(self.sentinel.as_ptr() as *mut u8, Layout::new::<Links>());
-        }
+        // `guard` drops here and frees the free list and the sentinel.
     }
 }
 
@@ -478,7 +475,7 @@ impl<T> Drop for LinkedList<T> {
 /// later access or reposition that node via [`Cursor::element`],
 /// [`Cursor::move_to_front`], [`Cursor::move_to_back`], or [`Cursor::unlink`].
 ///
-/// `#[repr(transparent)]` over `NonNull<Node<T>>` means a `Cursor<T>` has the
+/// `#[repr(transparent)]` over `ptr::NonNull<Node<T>>` means a `Cursor<T>` has the
 /// exact same layout as the raw pointer it wraps — no extra state is tracked,
 /// so the cursor does *not* know which `LinkedList` it came from, whether the
 /// node is still linked, or whether other `Cursor`s alias the same node. All
@@ -489,9 +486,9 @@ impl<T> Drop for LinkedList<T> {
 /// equality (`PartialEq`/`Eq`) compares the underlying pointer, i.e. identity
 /// of the node, not the value of the element.
 #[repr(transparent)]
-pub struct Cursor<T>(NonNull<Node<T>>);
+pub struct Cursor<T>(ptr::NonNull<Node<T>>);
 
-// `NonNull<Node<T>>` is just a pointer; copying it is always safe.
+// `ptr::NonNull<Node<T>>` is just a pointer; copying it is always safe.
 impl<T> Clone for Cursor<T> {
     #[inline]
     fn clone(&self) -> Self {
@@ -516,10 +513,10 @@ impl<T> Cursor<T> {
     /// Relies on `#[repr(C)]` on `Node<T>` placing `links` at offset 0, so the
     /// cast is always valid regardless of `T`.
     #[inline]
-    fn links(&self) -> NonNull<Links> {
+    fn links(&self) -> ptr::NonNull<Links> {
         let ptr = self.0.as_ptr() as *mut Links;
-        // SAFETY: `self.0` is `NonNull`, so the reinterpreted pointer is non-null too.
-        unsafe { NonNull::new_unchecked(ptr) }
+        // SAFETY: `self.0` is `ptr::NonNull`, so the reinterpreted pointer is non-null too.
+        unsafe { ptr::NonNull::new_unchecked(ptr) }
     }
 
     /// Returns a reference to the node's element, with a caller-chosen lifetime.
@@ -621,7 +618,7 @@ impl<T> Cursor<T> {
 pub struct RawIter<T> {
     next: *mut Links,
     len: usize,
-    _marker: PhantomData<NonNull<Node<T>>>,
+    _marker: PhantomData<ptr::NonNull<Node<T>>>,
 }
 
 impl<T> Iterator for RawIter<T> {
@@ -641,7 +638,7 @@ impl<T> Iterator for RawIter<T> {
         self.next = unsafe { (*node).next };
         // SAFETY: `node` is non-null (came from a valid linked `Links`), and
         // by `#[repr(C)]` on `Node<T>` a `*mut Links` is a valid `*mut Node<T>`.
-        let cursor = Cursor(unsafe { NonNull::new_unchecked(node as *mut Node<T>) });
+        let cursor = Cursor(unsafe { ptr::NonNull::new_unchecked(node as *mut Node<T>) });
         Some(cursor)
     }
 
@@ -659,3 +656,36 @@ unsafe impl<T: Send + Send> Send for RawIter<T> {}
 unsafe impl<T: Sync + Sync> Sync for RawIter<T> {}
 unsafe impl<T: Send + Send> Send for Cursor<T> {}
 unsafe impl<T: Sync + Sync> Sync for Cursor<T> {}
+
+#[cfg(test)]
+mod tests {
+    use super::LinkedList;
+
+    #[test]
+    fn a_panicking_element_drop_still_frees_every_node() {
+        struct Bomb {
+            panics: bool,
+            _label: String,
+        }
+        impl Drop for Bomb {
+            fn drop(&mut self) {
+                if self.panics {
+                    panic!("boom");
+                }
+            }
+        }
+
+        let mut list = LinkedList::new();
+        for i in 0..6 {
+            list.push_back(Bomb {
+                panics: i == 2,
+                _label: i.to_string(),
+            });
+        }
+        list.pop_back(); // leave a node on the free list too
+        let dropped = std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || drop(list)));
+        assert!(dropped.is_err());
+        // the other elements, the free list and the sentinel are freed; under
+        // Miri this also checks that nothing leaks
+    }
+}

{cachebox-6.2.9 → cachebox-6.2.10}/src/internal/utils.rs

@@ -16,13 +16,23 @@ pub unsafe fn pyobject_hash(
 ) -> pyo3::PyResult<u64> {
     let py_hash = pyo3::ffi::PyObject_Hash(arg1);
     if crate::hashbrown::util::unlikely(py_hash == -1) {
-        // SAFETY: PyObject_Hash never returns -1 on success.
-        return Err(pyo3::PyErr::take(py).unwrap());
+        // PyObject_Hash never returns -1 on success.
+        return Err(take_error(py));
     }
 
     Ok(mix_hash(py_hash as u64))
 }
 
+/// Takes the exception set by a failed C API call.
+///
+/// A broken C type can report an error without setting one; like CPython, raise
+/// `SystemError` then instead of panicking (release builds abort on panic).
+#[cold]
+fn take_error(py: pyo3::Python<'_>) -> pyo3::PyErr {
+    pyo3::PyErr::take(py)
+        .unwrap_or_else(|| new_py_error!(PySystemError, "error return without exception set"))
+}
+
 /// Spreads entropy of a Python hash across all 64 bits.
 ///
 /// CPython hashes are frequently low-entropy in the high bits: `hash(n) == n` for
@@ -55,7 +65,7 @@ pub unsafe fn pyobject_equal(
     let boolean = pyo3::ffi::PyObject_RichCompareBool(arg1, arg2, pyo3::ffi::Py_EQ);
 
     if boolean < 0 {
-        Err(pyo3::PyErr::take(py).unwrap_unchecked())
+        Err(take_error(py))
     } else {
         Ok(boolean == 1)
     }

{cachebox-6.2.9 → cachebox-6.2.10}/src/macro_rules.rs

@@ -54,7 +54,7 @@ macro_rules! implement_view_guard {
                 let cache = self.cache.get();
                 let inner = cache.0.get()?;
 
-                let policy = inner.policy_py_attached(py);
+                let policy = inner.policy(py);
 
                 if self.initial_gv == inner.shared().generation_version().get() {
                     return Ok(policy);

{cachebox-6.2.9 → cachebox-6.2.10}/src/policies/fifopolicy.rs

@@ -166,10 +166,11 @@ impl FIFOPolicy {
 
     #[inline]
     fn decrement_indexes(&mut self, start: usize, end: usize) {
-        const MAX_FRONT_OFFSET: usize = cfg_select! {
-            feature = "use-small-offset" => u8::MAX as usize,
-            not(feature = "use-small-offset") => usize::MAX - isize::MAX as usize,
-        };
+        const MAX_FRONT_OFFSET: usize =
+            cfg_select! {
+                feature = "use-small-offset" => u8::MAX as usize,
+                not(feature = "use-small-offset") => usize::MAX - isize::MAX as usize,
+            };
 
         // Fast path: shifting the entire front is a single counter increment.
         // Guard against overflow; the full-normalization path below handles that case.

{cachebox-6.2.9 → cachebox-6.2.10}/src/policies/ttlpolicy.rs

@@ -256,10 +256,11 @@ impl TTLPolicy {
 
     #[inline]
     fn decrement_indexes(&mut self, start: usize, end: usize) {
-        const MAX_FRONT_OFFSET: usize = cfg_select! {
-            feature = "use-small-offset" => u8::MAX as usize,
-            not(feature = "use-small-offset") => usize::MAX - isize::MAX as usize,
-        };
+        const MAX_FRONT_OFFSET: usize =
+            cfg_select! {
+                feature = "use-small-offset" => u8::MAX as usize,
+                not(feature = "use-small-offset") => usize::MAX - isize::MAX as usize,
+            };
 
         // Fast path: shifting the entire front is a single counter increment.
         // Guard against overflow; the full-normalization path below handles that case.
@@ -422,12 +423,11 @@ impl PolicyExt for TTLPolicy {
     }
 
     fn evict(&mut self, shared: &Self::Shared) -> pyo3::PyResult<Self::Handle> {
-        let front = self.entries.front();
-        if front.is_none() {
-            return Err(new_py_error!(PyKeyError, ()));
-        }
+        self.expire(shared.generation_version());
 
-        let front = unsafe { front.unwrap_unchecked() };
+        let Some(front) = self.entries.front() else {
+            return Err(new_py_error!(PyKeyError, ()));
+        };
 
         let eq = |index: &usize| Ok::<_, pyo3::PyErr>(*index - self.front_offset == 0);
         let removed_key_table = self.table.remove_entry(front.key().hash(), eq).unwrap();

{cachebox-6.2.9 → cachebox-6.2.10}/src/policies/vttlpolicy.rs

@@ -391,11 +391,12 @@ impl PolicyExt for VTTLPolicy {
     }
 
     fn evict(&mut self, shared: &Self::Shared) -> pyo3::PyResult<Self::Handle> {
+        self.expire(shared.generation_version());
+
         {
-            let front_cursor = self
-                .heap
-                .front()
-                .ok_or_else(|| new_py_error!(PyKeyError, "cache is empty"))?;
+            let Some(front_cursor) = self.heap.front() else {
+                return Err(new_py_error!(PyKeyError, "cache is empty"));
+            };
 
             self.table
                 .remove_entry(unsafe { front_cursor.element().key.hash() }, |x| {