cachebox 6.2.0__tar.gz → 6.2.2__tar.gz

{cachebox-6.2.0 → cachebox-6.2.2}/.github/workflows/CI.yml

@@ -57,7 +57,6 @@ jobs:
           args: --release --out dist --interpreter ${{ matrix.platform.interpreter }}
           sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
           manylinux: auto
-          rust-toolchain: nightly
 
       - uses: actions/upload-artifact@v7.0.1
         with:
@@ -101,7 +100,6 @@ jobs:
           args: --release --out dist --interpreter ${{ matrix.platform.interpreter }}
           sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
           manylinux: musllinux_1_2
-          rust-toolchain: nightly
 
       - uses: actions/upload-artifact@v7.0.1
         with:
@@ -117,7 +115,10 @@ jobs:
               target: x64,
               interpreter: "3.10 3.11 3.12 3.13 3.14 3.14t 3.15 3.15t pypy3.11",
             }
-          - { target: x86, interpreter: "3.10 3.11 3.12 3.13 3.14 3.14t 3.15 3.15t" }
+          - {
+              target: x86,
+              interpreter: "3.10 3.11 3.12 3.13 3.14 3.14t 3.15 3.15t",
+            }
 
     steps:
       - uses: actions/checkout@v6.0.2
@@ -134,7 +135,6 @@ jobs:
           target: ${{ matrix.platform.target }}
           args: --release --out dist --interpreter ${{ matrix.platform.interpreter }}
           sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
-          rust-toolchain: nightly
 
       - uses: actions/upload-artifact@v7.0.1
         with:
@@ -169,7 +169,6 @@ jobs:
           target: ${{ matrix.platform.target }}
           args: --release --out dist --interpreter ${{ matrix.platform.interpreter }}
           sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
-          rust-toolchain: nightly
 
       - uses: actions/upload-artifact@v7.0.1
         with:
@@ -188,7 +187,6 @@ jobs:
         with:
           command: sdist
           args: --out dist
-          rust-toolchain: nightly
 
       - name: Upload sdist
         uses: actions/upload-artifact@v7.0.1

{cachebox-6.2.0 → cachebox-6.2.2}/.github/workflows/python-test.yml

@@ -16,7 +16,7 @@ env:
 
 jobs:
   test-python:
-    name: test ${{ matrix.python-version }}
+    name: ${{ matrix.python-version }}
     runs-on: ubuntu-latest
     continue-on-error: ${{ endsWith(matrix.python-version, 't') }}
     strategy:
@@ -36,22 +36,24 @@ jobs:
     steps:
       - uses: actions/checkout@v6.0.2
 
-      - uses: dtolnay/rust-toolchain@nightly
+      - uses: dtolnay/rust-toolchain@stable
 
       - uses: actions/setup-python@v6.2.0
         with:
           python-version: ${{ matrix.python-version }}
           allow-prereleases: true
 
-      - run: pip install virtualenv pytest pytest-asyncio hypothesis maturin
+      - run: pip install virtualenv
+      - run: pip install -r requirements-dev.txt
       - run: virtualenv --no-vcs-ignore .venv
+
       - run: maturin develop --features use-small-offset
-      - run: pytest -v
+      - run: pytest -v -n auto
         env:
           HYPOTHESIS_PROFILE: slow
 
   test-os:
-    name: test on ${{ matrix.os }}
+    name: ${{ matrix.os }}
     runs-on: ${{ matrix.os }}-latest
     strategy:
       fail-fast: false
@@ -61,16 +63,17 @@ jobs:
     steps:
       - uses: actions/checkout@v6.0.2
 
-      - uses: dtolnay/rust-toolchain@nightly
+      - uses: dtolnay/rust-toolchain@stable
 
       - uses: actions/setup-python@v6.2.0
         with:
           python-version: "3.13"
-          allow-prereleases: true
 
-      - run: pip install virtualenv pytest pytest-asyncio hypothesis maturin
+      - run: pip install virtualenv
+      - run: pip install -r requirements-dev.txt
       - run: virtualenv --no-vcs-ignore .venv
+
       - run: maturin develop --features use-small-offset
-      - run: pytest -v
+      - run: pytest -v -n auto
         env:
           HYPOTHESIS_PROFILE: slow

{cachebox-6.2.0 → cachebox-6.2.2}/Cargo.lock

@@ -2,6 +2,12 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "allocator-api2"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c880a97d28a3681c0267bd29cff89621202715b065127cd445fa0f0fe0aa2880"
+
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -31,8 +37,9 @@ checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
 
 [[package]]
 name = "cachebox"
-version = "6.2.0"
+version = "6.2.2"
 dependencies = [
+ "allocator-api2",
  "cfg-if",
  "chrono",
  "fastrand",

{cachebox-6.2.0 → cachebox-6.2.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cachebox"
-version = "6.2.0"
+version = "6.2.2"
 edition = "2021"
 description = "The fastest memoizing and caching Python library written in Rust"
 readme = "README.md"
@@ -22,12 +22,12 @@ panic = "abort"
 strip = true
 
 [dependencies]
+allocator-api2 = "0.4.0"
 cfg-if = "1.0.4"
 chrono = "0.4.44"
 fastrand = "2.4.1"
 parking_lot = {version="0.12.5", default-features=false}
 pyo3 = {version="0.29", default-features=false, features=["macros", "chrono"]}
-# tokio = {version="1.52.3", default-features=false, features=["sync"]}
 
 [build-dependencies]
 pyo3-build-config = {version="0.29", default-features=false, features=["resolve-config"]}

{cachebox-6.2.0 → cachebox-6.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachebox
-Version: 6.2.0
+Version: 6.2.2
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Programming Language :: Python :: 3
@@ -41,6 +41,7 @@ Project-URL: Homepage, https://github.com/awolverp/cachebox
 
 [![License](https://img.shields.io/github/license/awolverp/cachebox.svg?style=flat-square)](https://github.com/awolverp/cachebox/blob/main/LICENSE)
 [![Downloads](https://img.shields.io/pypi/dm/cachebox?style=flat-square&color=%23314bb5)](https://pepy.tech/projects/cachebox)
+[![Donate](https://img.shields.io/badge/donate-PayRequest-blue)](https://payrequest.me/ali-pooralijan-awolverp)
 
 </div>
 

{cachebox-6.2.0 → cachebox-6.2.2}/README.md

@@ -10,6 +10,7 @@
 
 [![License](https://img.shields.io/github/license/awolverp/cachebox.svg?style=flat-square)](https://github.com/awolverp/cachebox/blob/main/LICENSE)
 [![Downloads](https://img.shields.io/pypi/dm/cachebox?style=flat-square&color=%23314bb5)](https://pepy.tech/projects/cachebox)
+[![Donate](https://img.shields.io/badge/donate-PayRequest-blue)](https://payrequest.me/ali-pooralijan-awolverp)
 
 </div>
 

{cachebox-6.2.0 → cachebox-6.2.2}/cachebox/_wrappers.py

@@ -18,8 +18,10 @@ class _Lock:
 
     def __enter__(self) -> None:
         self.waiters += 1
-        self._lock.__enter__()
-        self.waiters -= 1
+        try:
+            self._lock.__enter__()
+        finally:
+            self.waiters -= 1
 
     def __exit__(self, *_) -> None:
         self._lock.__exit__(*_)
@@ -34,8 +36,10 @@ class _AsyncLock:
 
     async def __aenter__(self) -> None:
         self.waiters += 1
-        await self._lock.__aenter__()
-        self.waiters -= 1
+        try:
+            await self._lock.__aenter__()
+        finally:
+            self.waiters -= 1
 
     async def __aexit__(self, *_) -> None:
         await self._lock.__aexit__(*_)
@@ -102,7 +106,7 @@ def _cached_wrapper_without_lock(
 
         result = func(*args, **kwds)
         _cache.insert(key, result)
-        hits += 1
+        misses += 1
         if callback is not None:
             callback(EVENT_MISS, key, result)
 
@@ -159,7 +163,7 @@ def _async_cached_wrapper_without_lock(
         # Passing `cachebox__ignore=True` bypasses the cache and
         # calls the function directly.
         if kwds.pop("cachebox__ignore", False):
-            return func(*args, **kwds)
+            return await func(*args, **kwds)
 
         _cache: BaseCacheImpl = cache(args[0]) if cache_is_fn else cache  # type: ignore[arg-type]
         key = _make_key(args, kwds)
@@ -266,17 +270,19 @@ def _cached_wrapper(
             except KeyError:
                 try:
                     result = func(*args, **kwds)
-                except Exception as exc:
+                except BaseException as exc:
                     if lock.waiters > 0:
                         pending_errors[key] = exc
+
                     raise
                 else:
                     _cache[key] = result
                     misses += 1
                     event = EVENT_MISS
 
-            if lock.waiters == 0:
-                locks.pop(key, None)
+            finally:
+                if lock.waiters == 0:
+                    locks.pop(key, None)
 
         if callback is not None:
             callback(event, key, result)
@@ -319,29 +325,7 @@ def _async_cached_wrapper(
     hits = 0
     misses = 0
 
-    # See _cached_wrapper
     locks: Cache[typing.Hashable, _AsyncLock] = Cache(0)
-
-    # if lock_type is asyncio.Lock:
-
-    #     async def _get_lock(key: typing.Hashable):
-    #         return locks.setdefault(key, _AsyncLock(lock_type()))
-
-    # else:
-    #     _lock_creation_guard = asyncio.Lock()
-
-    #     async def _get_lock(key: typing.Hashable):
-    #         lock = locks.get(key)
-    #         if lock is not None:
-    #             return lock
-
-    #         async with _lock_creation_guard:
-    #             lock = locks.get(key)
-    #             if lock is None:
-    #                 locks[key] = lock = _AsyncLock(lock_type())
-
-    #         return lock
-
     pending_errors: dict[typing.Hashable, BaseException] = {}
 
     async def _wrapped(*args, **kwds):
@@ -381,7 +365,7 @@ def _async_cached_wrapper(
             except KeyError:
                 try:
                     result = await func(*args, **kwds)
-                except Exception as exc:
+                except BaseException as exc:
                     if lock.waiters > 0:
                         pending_errors[key] = exc
                     raise
@@ -389,9 +373,9 @@ def _async_cached_wrapper(
                     _cache[key] = result
                     misses += 1
                     event = EVENT_MISS
-
-            if lock.waiters == 0:
-                locks.pop(key, None)
+            finally:
+                if lock.waiters == 0:
+                    locks.pop(key, None)
 
         await _call_async_callback(callback, event, key, result)
 

{cachebox-6.2.0 → cachebox-6.2.2}/cachebox/utils.py

@@ -73,12 +73,14 @@ def make_key(*args, **kwds) -> typing.Hashable:
     if not kwds:
         if len(args) == 1 and type(args[0]) in _FAST_TYPES:
             return args[0]
+
         return args
 
     key = args + (_KWDS_MARK,)
     for item in kwds.items():
         key += item
-    return key[0] if len(key) == 1 and type(key[0]) in _FAST_TYPES else key
+
+    return key
 
 
 def make_hash_key(*args, **kwds) -> int:
@@ -155,8 +157,13 @@ class Frozen(BaseCacheImpl[KT, VT]):  # pragma: no cover
             ignore: If ``True``, silently ignores modification attempts; if ``False``, raises
                 ``TypeError`` when modification is attempted. Default is ``False``.
         """
-        assert isinstance(cls, BaseCacheImpl)
-        assert type(cls) is not Frozen
+        if not isinstance(cls, BaseCacheImpl):
+            raise TypeError(
+                f"expected a BaseCacheImpl instance, got {type(cls).__name__!r}"
+            )
+
+        if type(cls) is Frozen:
+            raise TypeError("cannot wrap an already-frozen cache")
 
         self.__cache = cls
         self.ignore = ignore
@@ -366,9 +373,16 @@ class Frozen(BaseCacheImpl[KT, VT]):  # pragma: no cover
 def _cast_lock(
     iscoroutinefunction: bool,
     lock: (
-        typing.Type[AbstractContextManager] | typing.Type[AbstractAsyncContextManager] | bool | None
+        typing.Type[AbstractContextManager]
+        | typing.Type[AbstractAsyncContextManager]
+        | bool
+        | None
     ) = True,
-) -> typing.Type[AbstractContextManager] | typing.Type[AbstractAsyncContextManager] | None:
+) -> (
+    typing.Type[AbstractContextManager]
+    | typing.Type[AbstractAsyncContextManager]
+    | None
+):
     import _thread
     import asyncio
     import threading
@@ -381,12 +395,18 @@ def _cast_lock(
 
     if iscoroutinefunction:
         if not hasattr(lock, "__aenter__"):
-            raise TypeError("For async functions, you cannot use a regular synchronous lock.")
+            raise TypeError(
+                "For async functions, you cannot use a regular synchronous lock."
+            )
 
         return typing.cast(typing.Type[AbstractAsyncContextManager], lock)
 
     # threading.Lock, threading.RLock and _thread.allocate_lock are function
-    if lock is threading.Lock or lock is threading.RLock or lock is _thread.allocate_lock:
+    if (
+        lock is threading.Lock
+        or lock is threading.RLock
+        or lock is _thread.allocate_lock
+    ):
         return typing.cast(typing.Type[AbstractContextManager], lock)
 
     if not hasattr(lock, "__enter__"):
@@ -403,7 +423,10 @@ def cached(
     copy_level: int = 1,
     postprocess: _PostProcess | None = postprocess_copy_mutables,
     lock: (
-        typing.Type[AbstractContextManager] | typing.Type[AbstractAsyncContextManager] | bool | None
+        typing.Type[AbstractContextManager]
+        | typing.Type[AbstractAsyncContextManager]
+        | bool
+        | None
     ) = True,
 ) -> typing.Callable[[FT], FT]:
     """
@@ -480,7 +503,9 @@ def cached(
         lock_type = _cast_lock(iscoroutinefunction, lock)
 
         if not iscoroutinefunction and inspect.iscoroutinefunction(callback):
-            raise TypeError("For sync functions, you cannot use a asynchronous callback")
+            raise TypeError(
+                "For sync functions, you cannot use a asynchronous callback"
+            )
 
         if lock_type:
             builder = _async_cached_wrapper if iscoroutinefunction else _cached_wrapper

{cachebox-6.2.0 → cachebox-6.2.2}/requirements-dev.txt

@@ -2,5 +2,6 @@ maturin
 pytest
 hypothesis
 pytest-asyncio
+pytest-xdist
 mkdocs-material
 mkdocstrings[python]

cachebox-6.2.2/src/hashbrown/alloc.rs

@@ -0,0 +1,21 @@
+pub(crate) use self::inner::do_alloc;
+#[cfg(test)]
+pub(crate) use self::inner::AllocError;
+pub(crate) use self::inner::Allocator;
+pub(crate) use self::inner::Global;
+
+mod inner {
+    #[cfg(test)]
+    pub(crate) use allocator_api2::alloc::AllocError;
+    pub(crate) use allocator_api2::alloc::Allocator;
+    pub(crate) use allocator_api2::alloc::Global;
+    use core::alloc::Layout;
+    use core::ptr::NonNull;
+
+    pub(crate) fn do_alloc<A: Allocator>(alloc: &A, layout: Layout) -> Result<NonNull<[u8]>, ()> {
+        match alloc.allocate(layout) {
+            Ok(ptr) => Ok(ptr),
+            Err(_) => Err(()),
+        }
+    }
+}

{cachebox-6.2.0 → cachebox-6.2.2}/src/hashbrown/raw.rs

@@ -4,7 +4,6 @@ use super::control::Tag;
 use super::control::TagSliceExt;
 use super::scopeguard::guard;
 use super::scopeguard::ScopeGuard;
-use super::util::invalid_mut;
 use super::util::likely;
 use super::util::unlikely;
 use super::TryReserveError;
@@ -333,7 +332,7 @@ impl<T> Bucket<T> {
             // won't overflow because index must be less than length (bucket_mask)
             // and bucket_mask is guaranteed to be less than `isize::MAX`
             // (see TableLayout::calculate_layout_for method)
-            invalid_mut(index + 1)
+            ptr::without_provenance_mut(index + 1)
         } else {
             unsafe { base.as_ptr().sub(index) }
         };
@@ -422,7 +421,7 @@ impl<T> Bucket<T> {
         if T::IS_ZERO_SIZED {
             // Just return an arbitrary ZST pointer which is properly aligned
             // invalid pointer is good enough for ZST
-            invalid_mut(mem::align_of::<T>())
+            ptr::without_provenance_mut(mem::align_of::<T>())
         } else {
             unsafe { self.ptr.as_ptr().sub(1) }
         }
@@ -470,7 +469,7 @@ impl<T> Bucket<T> {
     unsafe fn next_n(&self, offset: usize) -> Self {
         let ptr = if T::IS_ZERO_SIZED {
             // invalid pointer is good enough for ZST
-            invalid_mut(self.ptr.as_ptr() as usize + offset)
+            ptr::without_provenance_mut(self.ptr.as_ptr() as usize + offset)
         } else {
             unsafe { self.ptr.as_ptr().sub(offset) }
         };
@@ -3479,7 +3478,7 @@ impl<T, A: Allocator + Default> Default for RawTable<T, A> {
     }
 }
 
-unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawTable<T, A> {
+impl<T, A: Allocator> Drop for RawTable<T, A> {
     #[cfg_attr(feature = "inline-more", inline)]
     fn drop(&mut self) {
         // SAFETY:

cachebox-6.2.2/src/hashbrown/util.rs

@@ -0,0 +1,23 @@
+#[inline(always)]
+#[cold]
+fn cold_path() {}
+
+#[inline(always)]
+pub(crate) fn likely(b: bool) -> bool {
+    if b {
+        true
+    } else {
+        cold_path();
+        false
+    }
+}
+
+#[inline(always)]
+pub(crate) fn unlikely(b: bool) -> bool {
+    if b {
+        cold_path();
+        true
+    } else {
+        false
+    }
+}

{cachebox-6.2.0 → cachebox-6.2.2}/src/internal/lazyheap.rs

@@ -242,7 +242,7 @@ impl<T> Default for LazyHeap<T> {
     }
 }
 
-unsafe impl<#[may_dangle] T> Drop for LazyHeap<T> {
+impl<T> Drop for LazyHeap<T> {
     fn drop(&mut self) {
         struct DropGuard<'a, T>(&'a mut LazyHeap<T>);
 

{cachebox-6.2.0 → cachebox-6.2.2}/src/internal/linked_list.rs

@@ -296,7 +296,7 @@ impl<T> LinkedList<T> {
     }
 }
 
-unsafe impl<#[may_dangle] T> Drop for LinkedList<T> {
+impl<T> Drop for LinkedList<T> {
     fn drop(&mut self) {
         struct DropGuard<'a, T>(&'a mut LinkedList<T>);
 

{cachebox-6.2.0 → cachebox-6.2.2}/src/internal/onceinit.rs

@@ -103,7 +103,7 @@ impl<T> OnceInit<T> {
     /// Panics if called before [`set`](Self::set) has completed.
     #[inline]
     pub fn get(&self) -> &T {
-        if std::hint::likely(self.0.state.load(atomic::Ordering::Acquire) == INIT) {
+        if crate::hashbrown::util::likely(self.0.state.load(atomic::Ordering::Acquire) == INIT) {
             // SAFETY: state == INIT guarantees `value` was fully written and is valid.
             unsafe { (*self.0.value.get()).assume_init_ref() }
         } else {

{cachebox-6.2.0 → cachebox-6.2.2}/src/internal/utils.rs

@@ -15,7 +15,7 @@ pub unsafe fn pyobject_hash(
     arg1: *mut pyo3::ffi::PyObject,
 ) -> pyo3::PyResult<u64> {
     let py_hash = pyo3::ffi::PyObject_Hash(arg1);
-    if std::hint::unlikely(py_hash == -1) {
+    if crate::hashbrown::util::unlikely(py_hash == -1) {
         // SAFETY: PyObject_Hash never returns -1 on success.
         return Err(pyo3::PyErr::take(py).unwrap());
     }

{cachebox-6.2.0 → cachebox-6.2.2}/src/lib.rs

@@ -1,7 +1,3 @@
-#![feature(allocator_api)]
-#![feature(dropck_eyepatch)]
-#![feature(likely_unlikely)]
-
 #[macro_use]
 mod macro_rules;
 mod hashbrown;
@@ -71,22 +67,22 @@ mod _core {
     #[pymodule_export]
     use crate::pyclasses::ttlcache::PyTTLCacheItems;
     #[pymodule_export]
+    use crate::pyclasses::ttlcache::PyTTLCacheItemsWithExpire;
+    #[pymodule_export]
     use crate::pyclasses::ttlcache::PyTTLCacheKeys;
     #[pymodule_export]
     use crate::pyclasses::ttlcache::PyTTLCacheValues;
-    #[pymodule_export]
-    use crate::pyclasses::ttlcache::PyTTLCacheItemsWithExpire;
 
     #[pymodule_export]
     use crate::pyclasses::vttlcache::PyVTTLCache;
     #[pymodule_export]
     use crate::pyclasses::vttlcache::PyVTTLCacheItems;
     #[pymodule_export]
+    use crate::pyclasses::vttlcache::PyVTTLCacheItemsWithExpire;
+    #[pymodule_export]
     use crate::pyclasses::vttlcache::PyVTTLCacheKeys;
     #[pymodule_export]
     use crate::pyclasses::vttlcache::PyVTTLCacheValues;
-    #[pymodule_export]
-    use crate::pyclasses::vttlcache::PyVTTLCacheItemsWithExpire;
 
     #[pymodule_init]
     pub fn init(m: &pyo3::Bound<'_, pyo3::types::PyModule>) -> pyo3::PyResult<()> {

{cachebox-6.2.0 → cachebox-6.2.2}/src/policies/fifopolicy.rs

@@ -299,7 +299,8 @@ impl PolicyExt for FIFOPolicy {
         let front = unsafe { front.unwrap_unchecked() };
 
         let eq = |index: &usize| Ok::<_, pyo3::PyErr>(*index - self.front_offset == 0);
-        if std::hint::unlikely(self.table.remove_entry(front.key().hash(), eq)?.is_none()) {
+        let removed_key_table = self.table.remove_entry(front.key().hash(), eq).unwrap();
+        if crate::hashbrown::util::unlikely(removed_key_table.is_none()) {
             unreachable!("popitem key not found in table");
         }
 

{cachebox-6.2.0 → cachebox-6.2.2}/src/policies/ttlpolicy.rs

@@ -322,12 +322,8 @@ impl TTLPolicy {
             }
 
             let eq = |index: &usize| Ok::<_, pyo3::PyErr>((*index - self.front_offset) == 0);
-            if std::hint::unlikely(
-                self.table
-                    .remove_entry(handle.key().hash(), eq)
-                    .unwrap()
-                    .is_none(),
-            ) {
+            let removed_key_table = self.table.remove_entry(handle.key().hash(), eq).unwrap();
+            if crate::hashbrown::util::unlikely(removed_key_table.is_none()) {
                 unreachable!("popitem key not found in table");
             }
 
@@ -430,7 +426,8 @@ impl PolicyExt for TTLPolicy {
         let front = unsafe { front.unwrap_unchecked() };
 
         let eq = |index: &usize| Ok::<_, pyo3::PyErr>(*index - self.front_offset == 0);
-        if std::hint::unlikely(self.table.remove_entry(front.key().hash(), eq)?.is_none()) {
+        let removed_key_table = self.table.remove_entry(front.key().hash(), eq).unwrap();
+        if crate::hashbrown::util::unlikely(removed_key_table.is_none()) {
             unreachable!("popitem key not found in table");
         }
 

{cachebox-6.2.0 → cachebox-6.2.2}/tests/test_utils.py

@@ -632,7 +632,7 @@ async def test_async_recursive_cached_issue_54(
 def test_recursive_cached(random_cache_impl: type[cachebox.BaseCacheImpl]):
     obj = random_cache_impl(10)
 
-    @cachebox.cached(obj)
+    @cachebox.cached(obj, lock=False)
     def factorial(n):
         if n < 0:
             raise ValueError
@@ -654,7 +654,7 @@ def test_recursive_threading_cached():
 
     obj = cachebox.LRUCache(10)
 
-    @cachebox.cached(obj)
+    @cachebox.cached(obj, lock=False)
     def factorial(n):
         if n < 0:
             raise ValueError
@@ -680,7 +680,7 @@ def test_recursive_threading_cached():
 async def test_recursive_asyncio_cached():
     obj = cachebox.LRUCache(10)
 
-    @cachebox.cached(obj)
+    @cachebox.cached(obj, lock=False)
     async def factorial(n) -> int:
         if n < 0:
             raise ValueError
@@ -742,3 +742,124 @@ async def test_async_handling_pending_errors():
         await calc(1, 2, 3, exception=True)
 
     assert await calc(1, 2, 3, exception=False) == 6
+
+
+def test_misses_should_increment_without_lock():
+    calls = {"n": 0}
+
+    @cachebox.cached(cachebox.LRUCache(0), lock=False)
+    def f(x):
+        calls["n"] += 1
+        return x * 2
+
+    assert f(1) == 2  # miss
+    assert f(1) == 2  # hit
+    assert f(2) == 4  # miss
+
+    info = cachebox.get_cached_cache_info(f)
+    print(info)
+
+    assert info.misses == 2
+    assert info.hits == 1
+
+
+@pytest.mark.asyncio
+async def test_ignore_path_should_return_awaited_value():
+    @cachebox.cached(cachebox.LRUCache(0), lock=False)
+    async def f(x):
+        await asyncio.sleep(0)
+        return x * 2
+
+    result = await f(
+        5,
+        cachebox__ignore=True,  # type: ignore
+    )
+    assert not asyncio.iscoroutine(result)
+    assert result == 10
+
+
+def test_locks_should_not_leak_on_exception():
+    @cachebox.cached(cachebox.LRUCache(0))  # lock پیش‌فرض True است
+    def f(x):
+        raise ValueError("boom")
+
+    for i in range(50):
+        with pytest.raises(ValueError):
+            f(i)
+
+    locks_cache = None
+    for cell in f.__closure__:  # type: ignore
+        try:
+            val = cell.cell_contents
+        except ValueError:
+            continue
+
+        if isinstance(val, cachebox.Cache):
+            locks_cache = val
+            break
+
+    assert locks_cache is not None, "We couldn't find locks_cache"
+    print("locks length after 50 failing calls:", len(locks_cache))
+
+    assert len(locks_cache) == 0
+
+
+@pytest.mark.asyncio
+async def test_waiters_should_not_leak_on_cancel():
+    started = asyncio.Event()
+    release = asyncio.Event()
+
+    @cachebox.cached(cachebox.LRUCache(0))
+    async def f(x):
+        started.set()
+        await release.wait()
+        return x
+
+    first = asyncio.create_task(f(1))
+    await started.wait()
+
+    second = asyncio.create_task(f(1))
+    await asyncio.sleep(0.05)
+
+    second.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await second
+
+    release.set()
+    result = await first
+    assert result == 1
+
+    locks_cache = None
+    for cell in f.__closure__:  # type: ignore
+        try:
+            val = cell.cell_contents
+        except ValueError:
+            continue
+        if isinstance(val, cachebox.Cache):
+            locks_cache = val
+            break
+    assert locks_cache is not None
+
+    print("locks length after cancel scenario:", len(locks_cache))
+    assert len(locks_cache) == 0
+
+
+@pytest.mark.asyncio
+async def test_cancelled_error_should_propagate_to_waiters_too():
+    gate = asyncio.Event()
+
+    @cachebox.cached(cachebox.LRUCache(0))
+    async def f(x):
+        await gate.wait()
+        raise asyncio.CancelledError()
+
+    t1 = asyncio.create_task(f(1))
+    t2 = asyncio.create_task(f(1))
+    await asyncio.sleep(0.01)
+    gate.set()
+
+    with pytest.raises(asyncio.CancelledError):
+        await t1
+
+    with pytest.raises(asyncio.CancelledError):
+        await t2

cachebox-6.2.0/src/hashbrown/alloc.rs

@@ -1,13 +0,0 @@
-use core::ptr::NonNull;
-
-#[cfg(test)]
-pub(crate) use std::alloc::AllocError;
-use std::alloc::Layout;
-pub(crate) use std::alloc::{Allocator, Global};
-
-pub(crate) fn do_alloc<A: Allocator>(alloc: &A, layout: Layout) -> Result<NonNull<[u8]>, ()> {
-    match alloc.allocate(layout) {
-        Ok(ptr) => Ok(ptr),
-        Err(_) => Err(()),
-    }
-}

cachebox-6.2.0/src/hashbrown/util.rs

@@ -1,9 +0,0 @@
-pub(crate) use std::hint::likely;
-pub(crate) use std::hint::unlikely;
-
-// FIXME: use strict provenance functions once they are stable.
-// Implement it with a transmute for now.
-#[inline(always)]
-pub(crate) fn invalid_mut<T>(addr: usize) -> *mut T {
-    unsafe { core::mem::transmute(addr) }
-}