Update tests

Author: awolverp

Cargo.lock

@@ -157,9 +157,7 @@ class BaseCacheImpl(typing.Generic[KT, VT]):
         *args: typing.Any,
         **kwargs: typing.Any,
     ) -> None: ...
-    def get(
-        self, key: KT, default: typing.Optional[DT] = None
-    ) -> typing.Union[VT, DT]: ...
+    def get(self, key: KT, default: typing.Optional[DT] = None) -> typing.Union[VT, DT]: ...
     def __getitem__(self, key: KT) -> VT: ...
     def setdefault(
         self,

cachebox/_core.pyi

@@ -71,9 +71,7 @@ def _cached_wrapper_without_lock(
 
     # Per-instance caches receive `self` as args[0]; exclude it from the ke
     _make_key = (
-        (lambda a, k: key_maker(*a[1:], **k))
-        if cache_is_fn
-        else (lambda a, k: key_maker(*a, **k))
+        (lambda a, k: key_maker(*a[1:], **k)) if cache_is_fn else (lambda a, k: key_maker(*a, **k))
     )
 
     hits = 0
@@ -145,9 +143,7 @@ def _async_cached_wrapper_without_lock(
 
     # Per-instance caches receive `self` as args[0]; exclude it from the ke
     _make_key = (
-        (lambda a, k: key_maker(*a[1:], **k))
-        if cache_is_fn
-        else (lambda a, k: key_maker(*a, **k))
+        (lambda a, k: key_maker(*a[1:], **k)) if cache_is_fn else (lambda a, k: key_maker(*a, **k))
     )
 
     hits = 0
@@ -209,9 +205,7 @@ def _cached_wrapper(
 
     # Per-instance caches receive `self` as args[0]; exclude it from the key
     _make_key = (
-        (lambda a, k: key_maker(*a[1:], **k))
-        if cache_is_fn
-        else (lambda a, k: key_maker(*a, **k))
+        (lambda a, k: key_maker(*a[1:], **k)) if cache_is_fn else (lambda a, k: key_maker(*a, **k))
     )
 
     hits = 0
@@ -313,9 +307,7 @@ def _async_cached_wrapper(
 ):
     cache_is_fn = callable(cache)
     _make_key = (
-        (lambda a, k: key_maker(*a[1:], **k))
-        if cache_is_fn
-        else (lambda a, k: key_maker(*a, **k))
+        (lambda a, k: key_maker(*a[1:], **k)) if cache_is_fn else (lambda a, k: key_maker(*a, **k))
     )
 
     hits = 0

cachebox/_wrappers.py

@@ -366,16 +366,9 @@ def __repr__(self) -> str:
 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
@@ -388,18 +381,12 @@ 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__"):
@@ -416,10 +403,7 @@ 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]:
     """
@@ -495,9 +479,7 @@ def decorator(func: FT) -> FT:
         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/utils.py

@@ -17,7 +17,7 @@ pub unsafe fn pyobject_hash(
     let py_hash = pyo3::ffi::PyObject_Hash(arg1);
     if std::hint::unlikely(py_hash == -1) {
         // SAFETY: PyObject_Hash never returns -1 on success.
-        return Err(pyo3::PyErr::take(py).unwrap_unchecked());
+        return Err(pyo3::PyErr::take(py).unwrap());
     }
 
     Ok(py_hash as u64)

src/internal/utils.rs

@@ -762,9 +762,7 @@ def __hash__(self) -> int:
 
 
 class SweepIntervalMixin(BaseMixin):
-    def _create_sweep_cache(
-        self, *args, **kwds
-    ) -> cachebox.TTLCache | cachebox.VTTLCache:
+    def _create_sweep_cache(self, *args, **kwds) -> cachebox.TTLCache | cachebox.VTTLCache:
         return typing.cast(
             cachebox.TTLCache | cachebox.VTTLCache,
             self.create_cache(*args, **kwds),
@@ -787,19 +785,15 @@ def test_numeric_sweep_interval_starts_thread(self):
             cache.stop_sweeper()
 
     def test_timedelta_sweep_interval_starts_thread(self):
-        cache = self._create_sweep_cache(
-            maxsize=10, sweep_interval=timedelta(seconds=1)
-        )
+        cache = self._create_sweep_cache(maxsize=10, sweep_interval=timedelta(seconds=1))
         try:
             assert cache._thread is not None
             assert cache._thread.is_alive()
         finally:
             cache.stop_sweeper()
 
     def test_timedelta_converted_to_seconds(self):
-        cache = self._create_sweep_cache(
-            maxsize=10, sweep_interval=timedelta(seconds=5)
-        )
+        cache = self._create_sweep_cache(maxsize=10, sweep_interval=timedelta(seconds=5))
         try:
             assert cache.sweep_interval == 5.0
         finally:
@@ -813,9 +807,7 @@ def test_sweep_interval_stored_as_float(self):
             cache.stop_sweeper()
 
     def test_sweep_interval_below_1_raises(self):
-        with pytest.raises(
-            ValueError, match="sweep_interval must be more than 1 seconds"
-        ):
+        with pytest.raises(ValueError, match="sweep_interval must be more than 1 seconds"):
             self._create_sweep_cache(maxsize=10, sweep_interval=0.5)
 
     def test_sweep_interval_zero_raises(self):
@@ -1032,9 +1024,7 @@ def test_fuzzy_keys_values_items_are_consistent(self, pairs):
         cache_items = dict(c.items())
         assert cache_items == truth
         assert set(c.keys()) == set(truth.keys())
-        assert sorted(str(v) for v in c.values()) == sorted(
-            str(v) for v in truth.values()
-        )
+        assert sorted(str(v) for v in c.values()) == sorted(str(v) for v in truth.values())
 
     @given(key=hashable_keys, existing=any_value, default=any_value)
     def test_fuzzy_setdefault_never_overwrites_existing(self, key, existing, default):
@@ -1056,12 +1046,8 @@ def test_fuzzy_copy_equals_original(self, pairs):
             c.insert(k, v)
         assert c.copy() == c
 
-    @given(
-        key=hashable_keys, value=any_value, new_key=hashable_keys, new_value=any_value
-    )
-    def test_fuzzy_copy_is_independent_of_original(
-        self, key, value, new_key, new_value
-    ):
+    @given(key=hashable_keys, value=any_value, new_key=hashable_keys, new_value=any_value)
+    def test_fuzzy_copy_is_independent_of_original(self, key, value, new_key, new_value):
         assume(new_key != key)
         c = self.create_cache(maxsize=0)
         c.insert(key, value)

tests/mixins.py

@@ -1116,19 +1116,15 @@ def test_last_returns_newest_key(self):
 
     def test_first_with_positive_n_browses_in_insertion_order(self):
         """first(n) must walk forward through insertion order."""
-        cache = self.create_cache(
-            4, [(10, "a"), (20, "b"), (30, "c"), (40, "d")], global_ttl=10
-        )
+        cache = self.create_cache(4, [(10, "a"), (20, "b"), (30, "c"), (40, "d")], global_ttl=10)
         assert cache.first(0) == 10
         assert cache.first(1) == 20
         assert cache.first(2) == 30
         assert cache.first(3) == 40
 
     def test_first_with_negative_n_browses_from_end(self):
         """first(-1) is an alias for last(); first(-2) is the second newest."""
-        cache = self.create_cache(
-            4, [(10, "a"), (20, "b"), (30, "c"), (40, "d")], global_ttl=10
-        )
+        cache = self.create_cache(4, [(10, "a"), (20, "b"), (30, "c"), (40, "d")], global_ttl=10)
         assert cache.first(-1) == 40
         assert cache.first(-2) == 30
 
@@ -1750,9 +1746,7 @@ def test_get_with_expire(self):
         time.sleep(0.1)
         value, dur = obj.get_with_expire(1)
         assert 1 == value
-        assert isinstance(dur, float) and 10 > dur > 9, (
-            "10 > dur > 9 failed [dur: %f]" % dur
-        )
+        assert isinstance(dur, float) and 10 > dur > 9, "10 > dur > 9 failed [dur: %f]" % dur
 
         obj.insert(1, 1, None)
         time.sleep(0.1)
@@ -1775,9 +1769,7 @@ def test_pop_with_expire(self):
         time.sleep(0.1)
         value, dur = obj.pop_with_expire(1)
         assert 1 == value
-        assert isinstance(dur, float) and 10 > dur > 9, (
-            "10 > dur > 9 failed [dur: %f]" % dur
-        )
+        assert isinstance(dur, float) and 10 > dur > 9, "10 > dur > 9 failed [dur: %f]" % dur
 
         obj.insert(1, 1, None)
         time.sleep(0.1)
@@ -1801,15 +1793,11 @@ def test_popitem_with_expire(self):
         time.sleep(0.1)
         key, value, dur = obj.popitem_with_expire()
         assert (1, 1) == (key, value)
-        assert isinstance(dur, float) and 10 > dur > 9, (
-            "10 > dur > 9 failed [dur: %f]" % dur
-        )
+        assert isinstance(dur, float) and 10 > dur > 9, "10 > dur > 9 failed [dur: %f]" % dur
 
         key, value, dur = obj.popitem_with_expire()
         assert (2, 2) == (key, value)
-        assert isinstance(dur, float) and 20 > dur > 19, (
-            "20 > dur > 19 failed [dur: %f]" % dur
-        )
+        assert isinstance(dur, float) and 20 > dur > 19, "20 > dur > 19 failed [dur: %f]" % dur
 
         with pytest.raises(KeyError):
             obj.popitem_with_expire()

tests/test_impls.py

@@ -1,4 +1,5 @@
 import asyncio
+import platform
 import threading
 import time
 import typing
@@ -574,6 +575,10 @@ def run():
     assert "err" in result
 
 
+@pytest.mark.skipif(
+    platform.python_implementation() == "PyPy",
+    reason="https://github.com/PyO3/pyo3/issues/6109",
+)
 def test_recursive_cached_issue_54(random_cache_impl: type[cachebox.BaseCacheImpl]):
     # https://github.com/awolverp/cachebox/issues/54
 
@@ -609,6 +614,10 @@ async def run():
     assert "err" in result
 
 
+@pytest.mark.skipif(
+    platform.python_implementation() == "PyPy",
+    reason="https://github.com/PyO3/pyo3/issues/6109",
+)
 @pytest.mark.asyncio
 async def test_async_recursive_cached_issue_54(
     random_cache_impl: type[cachebox.BaseCacheImpl],