From 719549d2c617df532d1d4071bd3a0074f797f17d Mon Sep 17 00:00:00 2001 From: chiri Date: Thu, 11 Sep 2025 18:42:18 +0300 Subject: [PATCH 1/6] bump dependencies --- Cargo.lock | 34 ++++++++++++++++------------------ Cargo.toml | 10 +++++----- 2 files changed, 21 insertions(+), 23 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index b435229..28f7d24 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -29,9 +29,9 @@ dependencies = [ [[package]] name = "cfg-if" -version = "1.0.0" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9" [[package]] name = "fastrand" @@ -65,9 +65,9 @@ checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6" [[package]] name = "lock_api" -version = "0.4.12" +version = "0.4.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17" +checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765" dependencies = [ "autocfg", "scopeguard", @@ -90,9 +90,9 @@ checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" [[package]] name = "parking_lot_core" -version = "0.9.10" +version = "0.9.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" +checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5" dependencies = [ "cfg-if", "libc", @@ -118,11 +118,10 @@ dependencies = [ [[package]] name = "pyo3" -version = "0.24.1" +version = "0.26.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "17da310086b068fbdcefbba30aeb3721d5bb9af8db4987d6735b2183ca567229" +checksum = "7ba0117f4212101ee6544044dae45abe1083d30ce7b29c4b5cbdfa2354e07383" dependencies = [ - "cfg-if", "indoc", "libc", "memoffset", @@ -136,19 +135,18 @@ dependencies = [ [[package]] name = "pyo3-build-config" -version = "0.24.1" +version = "0.26.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e27165889bd793000a098bb966adc4300c312497ea25cf7a690a9f0ac5aa5fc1" +checksum = "4fc6ddaf24947d12a9aa31ac65431fb1b851b8f4365426e182901eabfb87df5f" dependencies = [ - "once_cell", "target-lexicon", ] [[package]] name = "pyo3-ffi" -version = "0.24.1" +version = "0.26.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05280526e1dbf6b420062f3ef228b78c0c54ba94e157f5cb724a609d0f2faabc" +checksum = "025474d3928738efb38ac36d4744a74a400c901c7596199e20e45d98eb194105" dependencies = [ "libc", "pyo3-build-config", @@ -156,9 +154,9 @@ dependencies = [ [[package]] name = "pyo3-macros" -version = "0.24.1" +version = "0.26.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c3ce5686aa4d3f63359a5100c62a127c9f15e8398e5fdeb5deef1fed5cd5f44" +checksum = "2e64eb489f22fe1c95911b77c44cc41e7c19f3082fc81cce90f657cdc42ffded" dependencies = [ "proc-macro2", "pyo3-macros-backend", @@ -168,9 +166,9 @@ dependencies = [ [[package]] name = "pyo3-macros-backend" -version = "0.24.1" +version = "0.26.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4cf6faa0cbfb0ed08e89beb8103ae9724eb4750e3a78084ba4017cbe94f3855" +checksum = "100246c0ecf400b475341b8455a9213344569af29a3c841d29270e53102e0fcf" dependencies = [ "heck", "proc-macro2", diff --git a/Cargo.toml b/Cargo.toml index b0f6045..4984bda 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -30,23 +30,23 @@ features = ["inline-more", "raw"] version = "2.3.0" [dependencies.pyo3] -version = "0.24.1" +version = "0.26.0" default-features = false features = ["macros", "extension-module"] [dependencies.cfg-if] -version = "1.0.0" +version = "1.0.3" [dependencies.parking_lot_core] -version = "0.9.10" +version = "0.9.11" default-features = false [dependencies.lock_api] -version = "0.4.12" +version = "0.4.13" default-features = false [build-dependencies.pyo3-build-config] -version = "0.24.1" +version = "0.26.0" features = ["resolve-config"] [lints.clippy] From f6509883aebccc8f3f928de88630e18a8f580141 Mon Sep 17 00:00:00 2001 From: chiri Date: Thu, 11 Sep 2025 18:42:37 +0300 Subject: [PATCH 2/6] add 3.14 classifiers --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index edb1710..630d769 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -21,6 +21,7 @@ classifiers = [ "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", "Programming Language :: Python", "Programming Language :: Rust", "Intended Audience :: Developers", From 0dcc418ae1940d4924f5c7f05ae68048dd65f12c Mon Sep 17 00:00:00 2001 From: chiri Date: Thu, 11 Sep 2025 18:59:38 +0300 Subject: [PATCH 3/6] fix all deprecation and some clean up --- src/bridge/cache.rs | 47 +++++++++++++++++++++----------- src/bridge/fifocache.rs | 55 ++++++++++++++++++++++++------------- src/bridge/lfucache.rs | 59 ++++++++++++++++++++++++++++------------ src/bridge/lrucache.rs | 57 +++++++++++++++++++++++++------------- src/bridge/mod.rs | 16 +++++------ src/bridge/rrcache.rs | 49 +++++++++++++++++++++------------ src/bridge/ttlcache.rs | 50 ++++++++++++++++++++++------------ src/bridge/vttlcache.rs | 45 ++++++++++++++++++++---------- src/common.rs | 17 +++++++----- src/lib.rs | 2 +- src/linked_list.rs | 8 +++--- src/policies/fifo.rs | 36 ++++++++++++++---------- src/policies/lfu.rs | 21 ++++++++------ src/policies/lru.rs | 30 ++++++++++++-------- src/policies/nopolicy.rs | 25 ++++++++++------- src/policies/random.rs | 27 ++++++++++-------- src/policies/ttl.rs | 17 ++++++++---- src/policies/vttl.rs | 17 ++++++++---- 18 files changed, 368 insertions(+), 210 deletions(-) diff --git a/src/bridge/cache.rs b/src/bridge/cache.rs index a066567..b23ccec 100644 --- a/src/bridge/cache.rs +++ b/src/bridge/cache.rs @@ -11,7 +11,7 @@ pub struct Cache { #[pyo3::pyclass(module = "cachebox._core")] pub struct cache_items { pub ptr: ObservedIterator, - pub iter: crate::mutex::Mutex>, + pub iter: crate::mutex::Mutex)>>, } #[pyo3::pymethods] @@ -45,11 +45,14 @@ impl Cache { fn __sizeof__(&self) -> usize { let lock = self.raw.lock(); - lock.capacity() - * (std::mem::size_of::() + std::mem::size_of::()) + lock.capacity() * (size_of::() + size_of::()) } - fn __contains__(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn __contains__( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -70,9 +73,9 @@ impl Cache { fn insert( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - value: pyo3::PyObject, - ) -> pyo3::PyResult> { + key: pyo3::Py, + value: pyo3::Py, + ) -> pyo3::PyResult>> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -85,7 +88,11 @@ impl Cache { } } - fn get(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn get( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -98,7 +105,7 @@ impl Cache { fn update( slf: pyo3::PyRef<'_, Self>, py: pyo3::Python<'_>, - iterable: pyo3::PyObject, + iterable: pyo3::Py, ) -> pyo3::PyResult<()> { if slf.as_ptr() == iterable.as_ptr() { return Ok(()); @@ -110,7 +117,7 @@ impl Cache { fn __richcmp__( slf: pyo3::PyRef<'_, Self>, - other: pyo3::PyObject, + other: pyo3::Py, op: pyo3::class::basic::CompareOp, ) -> pyo3::PyResult { let other = other.extract::>(slf.py())?; @@ -139,7 +146,11 @@ impl Cache { } } - fn remove(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn remove( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -169,9 +180,9 @@ impl Cache { fn setdefault( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - default: pyo3::PyObject, - ) -> pyo3::PyResult { + key: pyo3::Py, + default: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -204,7 +215,7 @@ impl Cache { (0,) } - fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult { + fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult> { let lock = self.raw.lock(); unsafe { let state = { @@ -235,7 +246,11 @@ impl Cache { } } - pub fn __setstate__(&self, py: pyo3::Python<'_>, state: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn __setstate__( + &self, + py: pyo3::Python<'_>, + state: pyo3::Py, + ) -> pyo3::PyResult<()> { let mut lock = self.raw.lock(); lock.from_pickle(py, state.as_ptr()) } diff --git a/src/bridge/fifocache.rs b/src/bridge/fifocache.rs index 8ac8b0d..688cd37 100644 --- a/src/bridge/fifocache.rs +++ b/src/bridge/fifocache.rs @@ -47,13 +47,15 @@ impl FIFOCache { let lock = self.raw.lock(); let capacity = lock.capacity(); - capacity.0 * std::mem::size_of::() - + capacity.1 - * (std::mem::size_of::() - + std::mem::size_of::()) + capacity.0 * size_of::() + + capacity.1 * (size_of::() + size_of::()) } - fn __contains__(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn __contains__( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -74,9 +76,9 @@ impl FIFOCache { fn insert( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - value: pyo3::PyObject, - ) -> pyo3::PyResult> { + key: pyo3::Py, + value: pyo3::Py, + ) -> pyo3::PyResult>> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -89,7 +91,11 @@ impl FIFOCache { } } - fn get(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn get( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -102,7 +108,7 @@ impl FIFOCache { fn update( slf: pyo3::PyRef<'_, Self>, py: pyo3::Python<'_>, - iterable: pyo3::PyObject, + iterable: pyo3::Py, ) -> pyo3::PyResult<()> { if slf.as_ptr() == iterable.as_ptr() { return Ok(()); @@ -114,7 +120,7 @@ impl FIFOCache { fn __richcmp__( slf: pyo3::PyRef<'_, Self>, - other: pyo3::PyObject, + other: pyo3::Py, op: pyo3::class::basic::CompareOp, ) -> pyo3::PyResult { let other = other.extract::>(slf.py())?; @@ -144,7 +150,11 @@ impl FIFOCache { } } - fn remove(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn remove( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -157,7 +167,10 @@ impl FIFOCache { } } - fn popitem(&self, py: pyo3::Python<'_>) -> pyo3::PyResult<(pyo3::PyObject, pyo3::PyObject)> { + fn popitem( + &self, + py: pyo3::Python<'_>, + ) -> pyo3::PyResult<(pyo3::Py, pyo3::Py)> { let mut lock = self.raw.lock(); match lock.popitem(py)? { @@ -183,9 +196,9 @@ impl FIFOCache { fn setdefault( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - default: pyo3::PyObject, - ) -> pyo3::PyResult { + key: pyo3::Py, + default: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -214,7 +227,7 @@ impl FIFOCache { pyo3::Py::new(slf.py(), result) } - fn get_index(&self, py: pyo3::Python<'_>, index: usize) -> Option { + fn get_index(&self, py: pyo3::Python<'_>, index: usize) -> Option> { let lock = self.raw.lock(); lock.get_index(index).map(|(key, _)| key.obj.clone_ref(py)) @@ -224,7 +237,7 @@ impl FIFOCache { (0,) } - fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult { + fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult> { let lock = self.raw.lock(); let state = unsafe { @@ -267,7 +280,11 @@ impl FIFOCache { Ok(unsafe { pyo3::Py::from_owned_ptr(py, state) }) } - pub fn __setstate__(&self, py: pyo3::Python<'_>, state: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn __setstate__( + &self, + py: pyo3::Python<'_>, + state: pyo3::Py, + ) -> pyo3::PyResult<()> { let mut lock = self.raw.lock(); lock.from_pickle(py, state.as_ptr()) } diff --git a/src/bridge/lfucache.rs b/src/bridge/lfucache.rs index eed90ec..a287482 100644 --- a/src/bridge/lfucache.rs +++ b/src/bridge/lfucache.rs @@ -46,11 +46,14 @@ impl LFUCache { fn __sizeof__(&self) -> usize { let lock = self.raw.lock(); - lock.capacity() - * (std::mem::size_of::() + std::mem::size_of::()) + lock.capacity() * (size_of::() + size_of::()) } - fn __contains__(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn __contains__( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -72,10 +75,10 @@ impl LFUCache { fn insert( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - value: pyo3::PyObject, + key: pyo3::Py, + value: pyo3::Py, freq: usize, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult>> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -88,7 +91,11 @@ impl LFUCache { } } - fn get(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn get( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -98,7 +105,11 @@ impl LFUCache { } } - fn peek(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn peek( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -111,7 +122,7 @@ impl LFUCache { fn update( slf: pyo3::PyRef<'_, Self>, py: pyo3::Python<'_>, - iterable: pyo3::PyObject, + iterable: pyo3::Py, ) -> pyo3::PyResult<()> { if slf.as_ptr() == iterable.as_ptr() { return Ok(()); @@ -123,7 +134,7 @@ impl LFUCache { fn __richcmp__( slf: pyo3::PyRef<'_, Self>, - other: pyo3::PyObject, + other: pyo3::Py, op: pyo3::class::basic::CompareOp, ) -> pyo3::PyResult { let other = other.extract::>(slf.py())?; @@ -153,7 +164,11 @@ impl LFUCache { } } - fn remove(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn remove( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -166,7 +181,7 @@ impl LFUCache { } } - fn popitem(&self) -> pyo3::PyResult<(pyo3::PyObject, pyo3::PyObject)> { + fn popitem(&self) -> pyo3::PyResult<(pyo3::Py, pyo3::Py)> { let mut lock = self.raw.lock(); match lock.popitem() { @@ -193,10 +208,10 @@ impl LFUCache { fn setdefault( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - default: pyo3::PyObject, + key: pyo3::Py, + default: pyo3::Py, freq: usize, - ) -> pyo3::PyResult { + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -225,7 +240,11 @@ impl LFUCache { pyo3::Py::new(slf.py(), result) } - pub fn least_frequently_used(&self, py: pyo3::Python<'_>, n: usize) -> Option { + pub fn least_frequently_used( + &self, + py: pyo3::Python<'_>, + n: usize, + ) -> Option> { let mut lock = self.raw.lock(); lock.least_frequently_used(n) .map(|x| unsafe { x.as_ref().0.obj.clone_ref(py) }) @@ -235,7 +254,7 @@ impl LFUCache { (0,) } - fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult { + fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult> { let mut lock = self.raw.lock(); let state = unsafe { @@ -287,7 +306,11 @@ impl LFUCache { Ok(unsafe { pyo3::Py::from_owned_ptr(py, state) }) } - pub fn __setstate__(&self, py: pyo3::Python<'_>, state: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn __setstate__( + &self, + py: pyo3::Python<'_>, + state: pyo3::Py, + ) -> pyo3::PyResult<()> { let mut lock = self.raw.lock(); lock.from_pickle(py, state.as_ptr()) } diff --git a/src/bridge/lrucache.rs b/src/bridge/lrucache.rs index 70c7020..99f894d 100644 --- a/src/bridge/lrucache.rs +++ b/src/bridge/lrucache.rs @@ -46,11 +46,14 @@ impl LRUCache { fn __sizeof__(&self) -> usize { let lock = self.raw.lock(); - lock.capacity() - * (std::mem::size_of::() + std::mem::size_of::()) + lock.capacity() * (size_of::() + size_of::()) } - fn __contains__(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn __contains__( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -71,9 +74,9 @@ impl LRUCache { fn insert( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - value: pyo3::PyObject, - ) -> pyo3::PyResult> { + key: pyo3::Py, + value: pyo3::Py, + ) -> pyo3::PyResult>> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -86,7 +89,11 @@ impl LRUCache { } } - fn get(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn get( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -96,7 +103,11 @@ impl LRUCache { } } - fn peek(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn peek( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -109,7 +120,7 @@ impl LRUCache { fn update( slf: pyo3::PyRef<'_, Self>, py: pyo3::Python<'_>, - iterable: pyo3::PyObject, + iterable: pyo3::Py, ) -> pyo3::PyResult<()> { if slf.as_ptr() == iterable.as_ptr() { return Ok(()); @@ -121,7 +132,7 @@ impl LRUCache { fn __richcmp__( slf: pyo3::PyRef<'_, Self>, - other: pyo3::PyObject, + other: pyo3::Py, op: pyo3::class::basic::CompareOp, ) -> pyo3::PyResult { let other = other.extract::>(slf.py())?; @@ -151,7 +162,11 @@ impl LRUCache { } } - fn remove(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn remove( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -164,7 +179,7 @@ impl LRUCache { } } - fn popitem(&self) -> pyo3::PyResult<(pyo3::PyObject, pyo3::PyObject)> { + fn popitem(&self) -> pyo3::PyResult<(pyo3::Py, pyo3::Py)> { let mut lock = self.raw.lock(); match lock.popitem() { @@ -190,9 +205,9 @@ impl LRUCache { fn setdefault( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - default: pyo3::PyObject, - ) -> pyo3::PyResult { + key: pyo3::Py, + default: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -221,12 +236,12 @@ impl LRUCache { pyo3::Py::new(slf.py(), result) } - fn least_recently_used(&self, py: pyo3::Python<'_>) -> Option { + fn least_recently_used(&self, py: pyo3::Python<'_>) -> Option> { let lock = self.raw.lock(); lock.least_recently_used().map(|x| x.0.obj.clone_ref(py)) } - fn most_recently_used(&self, py: pyo3::Python<'_>) -> Option { + fn most_recently_used(&self, py: pyo3::Python<'_>) -> Option> { let lock = self.raw.lock(); lock.most_recently_used().map(|x| x.0.obj.clone_ref(py)) } @@ -235,7 +250,7 @@ impl LRUCache { (0,) } - fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult { + fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult> { let lock = self.raw.lock(); let state = unsafe { @@ -280,7 +295,11 @@ impl LRUCache { Ok(unsafe { pyo3::Py::from_owned_ptr(py, state) }) } - pub fn __setstate__(&self, py: pyo3::Python<'_>, state: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn __setstate__( + &self, + py: pyo3::Python<'_>, + state: pyo3::Py, + ) -> pyo3::PyResult<()> { let mut lock = self.raw.lock(); lock.from_pickle(py, state.as_ptr()) } diff --git a/src/bridge/mod.rs b/src/bridge/mod.rs index 5f85d87..9b6e391 100644 --- a/src/bridge/mod.rs +++ b/src/bridge/mod.rs @@ -32,16 +32,16 @@ impl BaseCacheImpl { #[classmethod] pub fn __class_getitem__( cls: &pyo3::Bound<'_, pyo3::types::PyType>, - args: pyo3::PyObject, - ) -> pyo3::PyObject { + args: pyo3::Py, + ) -> pyo3::Py { cls.clone().into() } } #[pyo3::pyclass(module = "cachebox._core", frozen)] pub struct TTLPair { - key: pyo3::PyObject, - value: pyo3::PyObject, + key: pyo3::Py, + value: pyo3::Py, duration: std::time::Duration, } @@ -69,11 +69,11 @@ impl From for TTLPair { #[pyo3::pymethods] impl TTLPair { - fn key(slf: pyo3::PyRef<'_, Self>) -> pyo3::PyObject { + fn key(slf: pyo3::PyRef<'_, Self>) -> pyo3::Py { slf.key.clone_ref(slf.py()) } - fn value(slf: pyo3::PyRef<'_, Self>) -> pyo3::PyObject { + fn value(slf: pyo3::PyRef<'_, Self>) -> pyo3::Py { slf.value.clone_ref(slf.py()) } @@ -81,11 +81,11 @@ impl TTLPair { slf.duration.as_secs_f64() } - fn pack2(slf: pyo3::PyRef<'_, Self>) -> (pyo3::PyObject, pyo3::PyObject) { + fn pack2(slf: pyo3::PyRef<'_, Self>) -> (pyo3::Py, pyo3::Py) { (slf.key.clone_ref(slf.py()), slf.value.clone_ref(slf.py())) } - fn pack3(slf: pyo3::PyRef<'_, Self>) -> (pyo3::PyObject, pyo3::PyObject, f64) { + fn pack3(slf: pyo3::PyRef<'_, Self>) -> (pyo3::Py, pyo3::Py, f64) { ( slf.key.clone_ref(slf.py()), slf.value.clone_ref(slf.py()), diff --git a/src/bridge/rrcache.rs b/src/bridge/rrcache.rs index 2c7f6f7..ebd746d 100644 --- a/src/bridge/rrcache.rs +++ b/src/bridge/rrcache.rs @@ -39,11 +39,14 @@ impl RRCache { fn __sizeof__(&self) -> usize { let lock = self.raw.lock(); - lock.capacity() - * (std::mem::size_of::() + std::mem::size_of::()) + lock.capacity() * (size_of::() + size_of::()) } - fn __contains__(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn __contains__( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -64,9 +67,9 @@ impl RRCache { fn insert( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - value: pyo3::PyObject, - ) -> pyo3::PyResult> { + key: pyo3::Py, + value: pyo3::Py, + ) -> pyo3::PyResult>> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -79,7 +82,11 @@ impl RRCache { } } - fn get(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn get( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -92,7 +99,7 @@ impl RRCache { fn update( slf: pyo3::PyRef<'_, Self>, py: pyo3::Python<'_>, - iterable: pyo3::PyObject, + iterable: pyo3::Py, ) -> pyo3::PyResult<()> { if slf.as_ptr() == iterable.as_ptr() { return Ok(()); @@ -104,7 +111,7 @@ impl RRCache { fn __richcmp__( slf: pyo3::PyRef<'_, Self>, - other: pyo3::PyObject, + other: pyo3::Py, op: pyo3::class::basic::CompareOp, ) -> pyo3::PyResult { let other = other.extract::>(slf.py())?; @@ -133,7 +140,11 @@ impl RRCache { } } - fn remove(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn remove( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -146,7 +157,7 @@ impl RRCache { } } - fn popitem(&self) -> pyo3::PyResult<(pyo3::PyObject, pyo3::PyObject)> { + fn popitem(&self) -> pyo3::PyResult<(pyo3::Py, pyo3::Py)> { let mut lock = self.raw.lock(); match lock.popitem()? { @@ -172,9 +183,9 @@ impl RRCache { fn setdefault( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - default: pyo3::PyObject, - ) -> pyo3::PyResult { + key: pyo3::Py, + default: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -203,7 +214,7 @@ impl RRCache { pyo3::Py::new(slf.py(), result) } - fn random_key(&self, py: pyo3::Python<'_>) -> pyo3::PyResult { + fn random_key(&self, py: pyo3::Python<'_>) -> pyo3::PyResult> { let lock = self.raw.lock(); match lock.random_key() { Some(x) => Ok(x.obj.clone_ref(py)), @@ -215,7 +226,7 @@ impl RRCache { (0,) } - fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult { + fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult> { let lock = self.raw.lock(); unsafe { let state = { @@ -246,7 +257,11 @@ impl RRCache { } } - pub fn __setstate__(&self, py: pyo3::Python<'_>, state: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn __setstate__( + &self, + py: pyo3::Python<'_>, + state: pyo3::Py, + ) -> pyo3::PyResult<()> { let mut lock = self.raw.lock(); lock.from_pickle(py, state.as_ptr()) } diff --git a/src/bridge/ttlcache.rs b/src/bridge/ttlcache.rs index e4e6b5c..ee2d4ae 100644 --- a/src/bridge/ttlcache.rs +++ b/src/bridge/ttlcache.rs @@ -53,13 +53,15 @@ impl TTLCache { let lock = self.raw.lock(); let capacity = lock.capacity(); - capacity.0 * std::mem::size_of::() - + capacity.1 - * (std::mem::size_of::() - + std::mem::size_of::()) + capacity.0 * size_of::() + + capacity.1 * (size_of::() + size_of::()) } - fn __contains__(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn __contains__( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -80,9 +82,9 @@ impl TTLCache { fn insert( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - value: pyo3::PyObject, - ) -> pyo3::PyResult> { + key: pyo3::Py, + value: pyo3::Py, + ) -> pyo3::PyResult>> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -95,7 +97,11 @@ impl TTLCache { } } - fn get(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn get( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -108,7 +114,7 @@ impl TTLCache { fn update( slf: pyo3::PyRef<'_, Self>, py: pyo3::Python<'_>, - iterable: pyo3::PyObject, + iterable: pyo3::Py, ) -> pyo3::PyResult<()> { if slf.as_ptr() == iterable.as_ptr() { return Ok(()); @@ -120,7 +126,7 @@ impl TTLCache { fn __richcmp__( slf: pyo3::PyRef<'_, Self>, - other: pyo3::PyObject, + other: pyo3::Py, op: pyo3::class::basic::CompareOp, ) -> pyo3::PyResult { let other = other.extract::>(slf.py())?; @@ -150,7 +156,11 @@ impl TTLCache { } } - fn remove(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn remove( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -189,9 +199,9 @@ impl TTLCache { fn setdefault( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - default: pyo3::PyObject, - ) -> pyo3::PyResult { + key: pyo3::Py, + default: pyo3::Py, + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -221,7 +231,7 @@ impl TTLCache { pyo3::Py::new(slf.py(), result) } - fn get_index(&self, py: pyo3::Python<'_>, index: usize) -> Option { + fn get_index(&self, py: pyo3::Python<'_>, index: usize) -> Option> { let lock = self.raw.lock(); lock.get_index(index).map(|pair| pair.key.obj.clone_ref(py)) } @@ -236,7 +246,7 @@ impl TTLCache { (0, 0.0f64) } - fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult { + fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult> { let lock = self.raw.lock(); let state = unsafe { @@ -285,7 +295,11 @@ impl TTLCache { Ok(unsafe { pyo3::Py::from_owned_ptr(py, state) }) } - pub fn __setstate__(&self, py: pyo3::Python<'_>, state: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn __setstate__( + &self, + py: pyo3::Python<'_>, + state: pyo3::Py, + ) -> pyo3::PyResult<()> { let mut lock = self.raw.lock(); lock.from_pickle(py, state.as_ptr()) } diff --git a/src/bridge/vttlcache.rs b/src/bridge/vttlcache.rs index 00bf778..1ea7a36 100644 --- a/src/bridge/vttlcache.rs +++ b/src/bridge/vttlcache.rs @@ -48,11 +48,14 @@ impl VTTLCache { fn __sizeof__(&self) -> usize { let lock = self.raw.lock(); - lock.capacity() - * (std::mem::size_of::() + std::mem::size_of::()) + lock.capacity() * (size_of::() + size_of::()) } - fn __contains__(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn __contains__( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -74,10 +77,10 @@ impl VTTLCache { fn insert( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - value: pyo3::PyObject, + key: pyo3::Py, + value: pyo3::Py, ttl: Option, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult>> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -90,7 +93,11 @@ impl VTTLCache { } } - fn get(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn get( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult { let key = PreHashObject::from_pyobject(py, key)?; let lock = self.raw.lock(); @@ -104,7 +111,7 @@ impl VTTLCache { fn update( slf: pyo3::PyRef<'_, Self>, py: pyo3::Python<'_>, - iterable: pyo3::PyObject, + iterable: pyo3::Py, ttl: Option, ) -> pyo3::PyResult<()> { if slf.as_ptr() == iterable.as_ptr() { @@ -117,7 +124,7 @@ impl VTTLCache { fn __richcmp__( slf: pyo3::PyRef<'_, Self>, - other: pyo3::PyObject, + other: pyo3::Py, op: pyo3::class::basic::CompareOp, ) -> pyo3::PyResult { let other = other.extract::>(slf.py())?; @@ -147,7 +154,11 @@ impl VTTLCache { } } - fn remove(&self, py: pyo3::Python<'_>, key: pyo3::PyObject) -> pyo3::PyResult { + fn remove( + &self, + py: pyo3::Python<'_>, + key: pyo3::Py, + ) -> pyo3::PyResult { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -187,10 +198,10 @@ impl VTTLCache { fn setdefault( &self, py: pyo3::Python<'_>, - key: pyo3::PyObject, - default: pyo3::PyObject, + key: pyo3::Py, + default: pyo3::Py, ttl: Option, - ) -> pyo3::PyResult { + ) -> pyo3::PyResult> { let key = PreHashObject::from_pyobject(py, key)?; let mut lock = self.raw.lock(); @@ -230,7 +241,7 @@ impl VTTLCache { (0,) } - fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult { + fn __getstate__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult> { let mut lock = self.raw.lock(); lock.expire(); @@ -288,7 +299,11 @@ impl VTTLCache { Ok(unsafe { pyo3::Py::from_owned_ptr(py, state) }) } - pub fn __setstate__(&self, py: pyo3::Python<'_>, state: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn __setstate__( + &self, + py: pyo3::Python<'_>, + state: pyo3::Py, + ) -> pyo3::PyResult<()> { let mut lock = self.raw.lock(); lock.from_pickle(py, state.as_ptr()) } diff --git a/src/common.rs b/src/common.rs index 58d7326..d90aded 100644 --- a/src/common.rs +++ b/src/common.rs @@ -74,7 +74,7 @@ macro_rules! extract_pickle_tuple { } // Tuple returns borrowed reference - pyo3::PyObject::from_borrowed_ptr($py, obj) + pyo3::Py::::from_borrowed_ptr($py, obj) }; let capacity = { @@ -109,7 +109,7 @@ macro_rules! extract_pickle_tuple { } // Tuple returns borrowed reference - pyo3::PyObject::from_borrowed_ptr($py, obj) + pyo3::Py::::from_borrowed_ptr($py, obj) }; let capacity = { @@ -166,7 +166,7 @@ fn convert_isize_to_u64(v: &isize) -> u64 { /// A precomputed hash is a cryptographic hash value that's calculated in advance /// and stored for later use, rather than being computed on demand when needed. pub struct PreHashObject { - pub obj: pyo3::PyObject, + pub obj: pyo3::Py, pub hash: u64, } @@ -198,7 +198,7 @@ pub struct NoLifetimeSliceIter { /// A pair representing a key-value entry with a time-to-live (TTL) expiration. pub struct TimeToLivePair { pub key: PreHashObject, - pub value: pyo3::PyObject, + pub value: pyo3::Py, pub expire_at: Option, } @@ -219,13 +219,16 @@ pub enum AbsentSituation { impl PreHashObject { /// Creates a new [`PreHashObject`] #[inline] - pub fn new(obj: pyo3::PyObject, hash: u64) -> Self { + pub fn new(obj: pyo3::Py, hash: u64) -> Self { Self { obj, hash } } /// Calculates the hash of `object` and creates a new [`PreHashObject`] #[inline] - pub fn from_pyobject(py: pyo3::Python<'_>, object: pyo3::PyObject) -> pyo3::PyResult { + pub fn from_pyobject( + py: pyo3::Python<'_>, + object: pyo3::Py, + ) -> pyo3::PyResult { unsafe { let py_hash = pyo3::ffi::PyObject_Hash(object.as_ptr()); @@ -456,7 +459,7 @@ impl TimeToLivePair { #[inline] pub fn new( key: PreHashObject, - value: pyo3::PyObject, + value: pyo3::Py, expire_at: Option, ) -> Self { Self { diff --git a/src/lib.rs b/src/lib.rs index 1add7e5..44e3749 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -13,7 +13,7 @@ mod policies; /// cachebox core ( written in Rust ) #[pymodule(gil_used = false)] #[cold] -fn _core(py: pyo3::Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> { +fn _core(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> { m.add("__author__", env!("CARGO_PKG_AUTHORS"))?; m.add("__version__", env!("CARGO_PKG_VERSION"))?; diff --git a/src/linked_list.rs b/src/linked_list.rs index 5cbd819..02a50fb 100644 --- a/src/linked_list.rs +++ b/src/linked_list.rs @@ -20,7 +20,7 @@ pub struct LinkedList { pub struct Node { pub prev: Option>, pub next: Option>, - pub element: (PreHashObject, pyo3::PyObject), + pub element: (PreHashObject, pyo3::Py), } impl LinkedList { @@ -33,7 +33,7 @@ impl LinkedList { } #[inline] - pub fn push_back(&mut self, key: PreHashObject, val: pyo3::PyObject) -> NonNull { + pub fn push_back(&mut self, key: PreHashObject, val: pyo3::Py) -> NonNull { unsafe { let node = NonNull::new_unchecked(Box::into_raw(Box::new(Node { prev: None, @@ -57,7 +57,7 @@ impl LinkedList { } #[inline] - pub fn pop_front(&mut self) -> Option<(PreHashObject, pyo3::PyObject)> { + pub fn pop_front(&mut self) -> Option<(PreHashObject, pyo3::Py)> { unsafe { self.head.map(|node| { let boxed_node = Box::from_raw(node.as_ptr()); @@ -83,7 +83,7 @@ impl LinkedList { } #[inline] - pub unsafe fn remove(&mut self, node: NonNull) -> (PreHashObject, pyo3::PyObject) { + pub unsafe fn remove(&mut self, node: NonNull) -> (PreHashObject, pyo3::Py) { let node = Box::from_raw(node.as_ptr()); let result = node.element; diff --git a/src/policies/fifo.rs b/src/policies/fifo.rs index c3ddd34..f1f4dfd 100644 --- a/src/policies/fifo.rs +++ b/src/policies/fifo.rs @@ -14,7 +14,7 @@ pub struct FIFOPolicy { table: hashbrown::raw::RawTable, /// Keep objects in order. - entries: VecDeque<(PreHashObject, pyo3::PyObject)>, + entries: VecDeque<(PreHashObject, pyo3::Py)>, maxsize: core::num::NonZeroUsize, /// When we pop front an object from entries, two operations have to do: @@ -41,8 +41,8 @@ pub struct FIFOPolicyAbsent<'a> { } pub struct FIFOIterator { - first: NoLifetimeSliceIter<(PreHashObject, pyo3::PyObject)>, - second: NoLifetimeSliceIter<(PreHashObject, pyo3::PyObject)>, + first: NoLifetimeSliceIter<(PreHashObject, pyo3::Py)>, + second: NoLifetimeSliceIter<(PreHashObject, pyo3::Py)>, } impl FIFOPolicy { @@ -114,7 +114,7 @@ impl FIFOPolicy { pub fn popitem( &mut self, py: pyo3::Python<'_>, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult)>> { let ret = self.entries.front(); if ret.is_none() { return Ok(None); @@ -189,7 +189,7 @@ impl FIFOPolicy { &self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult>> { match self .table .try_find(key.hash, |x| { @@ -219,7 +219,7 @@ impl FIFOPolicy { pub fn entries_iter( &self, - ) -> std::collections::vec_deque::Iter<'_, (PreHashObject, pyo3::PyObject)> { + ) -> std::collections::vec_deque::Iter<'_, (PreHashObject, pyo3::Py)> { self.entries.iter() } @@ -255,7 +255,11 @@ impl FIFOPolicy { } #[inline] - pub fn extend(&mut self, py: pyo3::Python<'_>, iterable: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn extend( + &mut self, + py: pyo3::Python<'_>, + iterable: pyo3::Py, + ) -> pyo3::PyResult<()> { use pyo3::types::{PyAnyMethods, PyDictMethods}; if unsafe { pyo3::ffi::PyDict_CheckExact(iterable.as_ptr()) == 1 } { @@ -280,7 +284,8 @@ impl FIFOPolicy { } } else { for pair in iterable.bind(py).try_iter()? { - let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?; + let (key, value) = + pair?.extract::<(pyo3::Py, pyo3::Py)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -322,7 +327,8 @@ impl FIFOPolicy { let mut new = Self::new(maxsize, capacity)?; for pair in iterable.bind(py).try_iter()? { - let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?; + let (key, value) = + pair?.extract::<(pyo3::Py, pyo3::Py)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -340,14 +346,14 @@ impl FIFOPolicy { } #[inline(always)] - pub fn get_index(&self, n: usize) -> Option<&(PreHashObject, pyo3::PyObject)> { + pub fn get_index(&self, n: usize) -> Option<&(PreHashObject, pyo3::Py)> { self.entries.get(n) } } impl<'a> FIFOPolicyOccupied<'a> { #[inline] - pub fn update(self, value: pyo3::PyObject) -> pyo3::PyResult { + pub fn update(self, value: pyo3::Py) -> pyo3::PyResult> { let index = unsafe { self.bucket.as_ref() }; let item = &mut self.instance.entries[index - self.instance.n_shifts]; let old_value = std::mem::replace(&mut item.1, value); @@ -359,7 +365,7 @@ impl<'a> FIFOPolicyOccupied<'a> { } #[inline] - pub fn remove(self) -> (PreHashObject, pyo3::PyObject) { + pub fn remove(self) -> (PreHashObject, pyo3::Py) { let (mut index, _) = unsafe { self.instance.table.remove(self.bucket) }; index -= self.instance.n_shifts; @@ -372,7 +378,7 @@ impl<'a> FIFOPolicyOccupied<'a> { m } - pub fn into_value(self) -> &'a mut (PreHashObject, pyo3::PyObject) { + pub fn into_value(self) -> &'a mut (PreHashObject, pyo3::Py) { let index = unsafe { self.bucket.as_ref() }; &mut self.instance.entries[index - self.instance.n_shifts] } @@ -384,7 +390,7 @@ impl FIFOPolicyAbsent<'_> { self, py: pyo3::Python<'_>, key: PreHashObject, - value: pyo3::PyObject, + value: pyo3::Py, ) -> pyo3::PyResult<()> { if self.instance.table.len() >= self.instance.maxsize.get() { self.instance.popitem(py)?; @@ -419,7 +425,7 @@ impl FIFOPolicyAbsent<'_> { } impl Iterator for FIFOIterator { - type Item = std::ptr::NonNull<(PreHashObject, pyo3::PyObject)>; + type Item = std::ptr::NonNull<(PreHashObject, pyo3::Py)>; #[inline] fn next(&mut self) -> Option { diff --git a/src/policies/lfu.rs b/src/policies/lfu.rs index a03b2a7..ded9296 100644 --- a/src/policies/lfu.rs +++ b/src/policies/lfu.rs @@ -5,7 +5,7 @@ use crate::common::TryFindMethods; use crate::lazyheap; use std::ptr::NonNull; -type TupleValue = (PreHashObject, pyo3::PyObject, usize); +type TupleValue = (PreHashObject, pyo3::Py, usize); pub struct LFUPolicy { table: hashbrown::raw::RawTable>, @@ -132,7 +132,7 @@ impl LFUPolicy { &mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult>> { match self.entry(py, key)? { Entry::Occupied(x) => unsafe { x.bucket.as_mut().as_mut().2 += 1; @@ -148,7 +148,7 @@ impl LFUPolicy { &self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult>> { let result = self .table .try_find(key.hash, |x| unsafe { x.as_ref().0.equal(py, key) })? @@ -204,7 +204,11 @@ impl LFUPolicy { } #[inline] - pub fn extend(&mut self, py: pyo3::Python<'_>, iterable: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn extend( + &mut self, + py: pyo3::Python<'_>, + iterable: pyo3::Py, + ) -> pyo3::PyResult<()> { use pyo3::types::{PyAnyMethods, PyDictMethods}; if unsafe { pyo3::ffi::PyDict_CheckExact(iterable.as_ptr()) == 1 } { @@ -229,7 +233,8 @@ impl LFUPolicy { } } else { for pair in iterable.bind(py).try_iter()? { - let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?; + let (key, value) = + pair?.extract::<(pyo3::Py, pyo3::Py)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -281,7 +286,7 @@ impl LFUPolicy { for pair in iterable.bind(py).try_iter()? { let (key, value, freq) = - pair?.extract::<(pyo3::PyObject, pyo3::PyObject, usize)>()?; + pair?.extract::<(pyo3::Py, pyo3::Py, usize)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -303,7 +308,7 @@ impl LFUPolicy { impl LFUPolicyOccupied<'_> { #[inline] - pub fn update(self, value: pyo3::PyObject) -> pyo3::PyResult { + pub fn update(self, value: pyo3::Py) -> pyo3::PyResult> { let item = unsafe { self.bucket.as_mut() }; unsafe { item.as_mut().2 += 1; @@ -337,7 +342,7 @@ impl LFUPolicyAbsent<'_> { pub fn insert( self, key: PreHashObject, - value: pyo3::PyObject, + value: pyo3::Py, freq: usize, ) -> pyo3::PyResult<()> { if self.instance.table.len() >= self.instance.maxsize.get() { diff --git a/src/policies/lru.rs b/src/policies/lru.rs index fe02a84..cb493da 100644 --- a/src/policies/lru.rs +++ b/src/policies/lru.rs @@ -59,7 +59,7 @@ impl LRUPolicy { } #[inline] - pub fn popitem(&mut self) -> Option<(PreHashObject, pyo3::PyObject)> { + pub fn popitem(&mut self) -> Option<(PreHashObject, pyo3::Py)> { let ret = self.list.head?; unsafe { @@ -130,7 +130,7 @@ impl LRUPolicy { &mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult>> { match self.entry(py, key)? { Entry::Occupied(x) => unsafe { x.instance.list.move_back(*x.bucket.as_ptr()); @@ -145,7 +145,7 @@ impl LRUPolicy { &self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult>> { let result = self .table .try_find(key.hash, |x| unsafe { x.as_ref().element.0.equal(py, key) })? @@ -200,7 +200,11 @@ impl LRUPolicy { } #[inline] - pub fn extend(&mut self, py: pyo3::Python<'_>, iterable: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn extend( + &mut self, + py: pyo3::Python<'_>, + iterable: pyo3::Py, + ) -> pyo3::PyResult<()> { use pyo3::types::{PyAnyMethods, PyDictMethods}; if unsafe { pyo3::ffi::PyDict_CheckExact(iterable.as_ptr()) == 1 } { @@ -225,7 +229,8 @@ impl LRUPolicy { } } else { for pair in iterable.bind(py).try_iter()? { - let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?; + let (key, value) = + pair?.extract::<(pyo3::Py, pyo3::Py)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -247,11 +252,11 @@ impl LRUPolicy { self.list.iter() } - pub fn least_recently_used(&self) -> Option<&(PreHashObject, pyo3::PyObject)> { + pub fn least_recently_used(&self) -> Option<&(PreHashObject, pyo3::Py)> { self.list.head.map(|x| unsafe { &x.as_ref().element }) } - pub fn most_recently_used(&self) -> Option<&(PreHashObject, pyo3::PyObject)> { + pub fn most_recently_used(&self) -> Option<&(PreHashObject, pyo3::Py)> { self.list.tail.map(|x| unsafe { &x.as_ref().element }) } @@ -269,7 +274,8 @@ impl LRUPolicy { let mut new = Self::new(maxsize, capacity)?; for pair in iterable.bind(py).try_iter()? { - let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?; + let (key, value) = + pair?.extract::<(pyo3::Py, pyo3::Py)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -289,7 +295,7 @@ impl LRUPolicy { impl<'a> LRUPolicyOccupied<'a> { #[inline] - pub fn update(self, value: pyo3::PyObject) -> pyo3::PyResult { + pub fn update(self, value: pyo3::Py) -> pyo3::PyResult> { let item = unsafe { self.bucket.as_mut() }; unsafe { self.instance.list.move_back(*item); @@ -302,7 +308,7 @@ impl<'a> LRUPolicyOccupied<'a> { } #[inline] - pub fn remove(self) -> (PreHashObject, pyo3::PyObject) { + pub fn remove(self) -> (PreHashObject, pyo3::Py) { // let (PreHashObject { hash, .. }, _) = &self.instance.entries[self.index - self.instance.n_shifts]; let (item, _) = unsafe { self.instance.table.remove(self.bucket) }; let item = unsafe { self.instance.list.remove(item) }; @@ -311,7 +317,7 @@ impl<'a> LRUPolicyOccupied<'a> { item } - pub fn into_value(self) -> &'a mut (PreHashObject, pyo3::PyObject) { + pub fn into_value(self) -> &'a mut (PreHashObject, pyo3::Py) { unsafe { self.instance.list.move_back(*self.bucket.as_ptr()); } @@ -323,7 +329,7 @@ impl<'a> LRUPolicyOccupied<'a> { impl LRUPolicyAbsent<'_> { #[inline] - pub fn insert(self, key: PreHashObject, value: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn insert(self, key: PreHashObject, value: pyo3::Py) -> pyo3::PyResult<()> { if self.instance.table.len() >= self.instance.maxsize.get() { self.instance.popitem(); } diff --git a/src/policies/nopolicy.rs b/src/policies/nopolicy.rs index f6c543c..ab2e4ec 100644 --- a/src/policies/nopolicy.rs +++ b/src/policies/nopolicy.rs @@ -4,14 +4,14 @@ use crate::common::PreHashObject; use crate::common::TryFindMethods; pub struct NoPolicy { - table: hashbrown::raw::RawTable<(PreHashObject, pyo3::PyObject)>, + table: hashbrown::raw::RawTable<(PreHashObject, pyo3::Py)>, maxsize: std::num::NonZeroUsize, pub observed: Observed, } pub struct NoPolicyOccupied<'a> { instance: &'a mut NoPolicy, - bucket: hashbrown::raw::Bucket<(PreHashObject, pyo3::PyObject)>, + bucket: hashbrown::raw::Bucket<(PreHashObject, pyo3::Py)>, } pub struct NoPolicyAbsent<'a> { @@ -53,7 +53,7 @@ impl NoPolicy { self.table.capacity() } - pub fn iter(&self) -> hashbrown::raw::RawIter<(PreHashObject, pyo3::PyObject)> { + pub fn iter(&self) -> hashbrown::raw::RawIter<(PreHashObject, pyo3::Py)> { unsafe { self.table.iter() } } @@ -104,7 +104,7 @@ impl NoPolicy { &self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult>> { match self.table.try_find(key.hash, |(x, _)| x.equal(py, key))? { Some(x) => Ok(Some(unsafe { &x.as_ref().1 })), None => Ok(None), @@ -165,7 +165,11 @@ impl NoPolicy { } #[inline] - pub fn extend(&mut self, py: pyo3::Python<'_>, iterable: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn extend( + &mut self, + py: pyo3::Python<'_>, + iterable: pyo3::Py, + ) -> pyo3::PyResult<()> { use pyo3::types::{PyAnyMethods, PyDictMethods}; if unsafe { pyo3::ffi::PyDict_CheckExact(iterable.as_ptr()) == 1 } { @@ -190,7 +194,8 @@ impl NoPolicy { } } else { for pair in iterable.bind(py).try_iter()? { - let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?; + let (key, value) = + pair?.extract::<(pyo3::Py, pyo3::Py)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -248,7 +253,7 @@ impl NoPolicy { impl<'a> NoPolicyOccupied<'a> { #[inline] - pub fn update(self, value: pyo3::PyObject) -> pyo3::PyResult { + pub fn update(self, value: pyo3::Py) -> pyo3::PyResult> { unsafe { // In update we don't need to change this; because this does not change the memory address ranges // self.instance.observed.change(); @@ -258,20 +263,20 @@ impl<'a> NoPolicyOccupied<'a> { } #[inline] - pub fn remove(self) -> (PreHashObject, pyo3::PyObject) { + pub fn remove(self) -> (PreHashObject, pyo3::Py) { let (x, _) = unsafe { self.instance.table.remove(self.bucket) }; self.instance.observed.change(); x } - pub fn into_value(self) -> &'a mut (PreHashObject, pyo3::PyObject) { + pub fn into_value(self) -> &'a mut (PreHashObject, pyo3::Py) { unsafe { self.bucket.as_mut() } } } impl NoPolicyAbsent<'_> { #[inline] - pub fn insert(self, key: PreHashObject, value: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn insert(self, key: PreHashObject, value: pyo3::Py) -> pyo3::PyResult<()> { if self.instance.table.len() >= self.instance.maxsize.get() { // There's no algorithm for removing a key-value pair, so we raise PyOverflowError. return Err(pyo3::PyErr::new::( diff --git a/src/policies/random.rs b/src/policies/random.rs index efce243..2740b9e 100644 --- a/src/policies/random.rs +++ b/src/policies/random.rs @@ -4,14 +4,14 @@ use crate::common::PreHashObject; use crate::common::TryFindMethods; pub struct RandomPolicy { - table: hashbrown::raw::RawTable<(PreHashObject, pyo3::PyObject)>, + table: hashbrown::raw::RawTable<(PreHashObject, pyo3::Py)>, maxsize: std::num::NonZeroUsize, pub observed: Observed, } pub struct RandomPolicyOccupied<'a> { instance: &'a mut RandomPolicy, - bucket: hashbrown::raw::Bucket<(PreHashObject, pyo3::PyObject)>, + bucket: hashbrown::raw::Bucket<(PreHashObject, pyo3::Py)>, } pub struct RandomPolicyAbsent<'a> { @@ -53,12 +53,12 @@ impl RandomPolicy { self.table.capacity() } - pub fn iter(&self) -> hashbrown::raw::RawIter<(PreHashObject, pyo3::PyObject)> { + pub fn iter(&self) -> hashbrown::raw::RawIter<(PreHashObject, pyo3::Py)> { unsafe { self.table.iter() } } #[inline] - pub fn popitem(&mut self) -> pyo3::PyResult> { + pub fn popitem(&mut self) -> pyo3::PyResult)>> { if self.table.is_empty() { Ok(None) } else { @@ -119,7 +119,7 @@ impl RandomPolicy { &self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult>> { match self.table.try_find(key.hash, |(x, _)| x.equal(py, key))? { Some(x) => Ok(Some(unsafe { &x.as_ref().1 })), None => Ok(None), @@ -180,7 +180,11 @@ impl RandomPolicy { } #[inline] - pub fn extend(&mut self, py: pyo3::Python<'_>, iterable: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn extend( + &mut self, + py: pyo3::Python<'_>, + iterable: pyo3::Py, + ) -> pyo3::PyResult<()> { use pyo3::types::{PyAnyMethods, PyDictMethods}; if unsafe { pyo3::ffi::PyDict_CheckExact(iterable.as_ptr()) == 1 } { @@ -205,7 +209,8 @@ impl RandomPolicy { } } else { for pair in iterable.bind(py).try_iter()? { - let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?; + let (key, value) = + pair?.extract::<(pyo3::Py, pyo3::Py)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -276,7 +281,7 @@ impl RandomPolicy { impl<'a> RandomPolicyOccupied<'a> { #[inline] - pub fn update(self, value: pyo3::PyObject) -> pyo3::PyResult { + pub fn update(self, value: pyo3::Py) -> pyo3::PyResult> { unsafe { let old_value = std::mem::replace(&mut self.bucket.as_mut().1, value); @@ -288,20 +293,20 @@ impl<'a> RandomPolicyOccupied<'a> { } #[inline] - pub fn remove(self) -> (PreHashObject, pyo3::PyObject) { + pub fn remove(self) -> (PreHashObject, pyo3::Py) { let (x, _) = unsafe { self.instance.table.remove(self.bucket) }; self.instance.observed.change(); x } - pub fn into_value(self) -> &'a mut (PreHashObject, pyo3::PyObject) { + pub fn into_value(self) -> &'a mut (PreHashObject, pyo3::Py) { unsafe { self.bucket.as_mut() } } } impl RandomPolicyAbsent<'_> { #[inline] - pub fn insert(self, key: PreHashObject, value: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn insert(self, key: PreHashObject, value: pyo3::Py) -> pyo3::PyResult<()> { if self.instance.table.len() >= self.instance.maxsize.get() { self.instance.popitem()?; } diff --git a/src/policies/ttl.rs b/src/policies/ttl.rs index 9b9d549..f857aa9 100644 --- a/src/policies/ttl.rs +++ b/src/policies/ttl.rs @@ -257,7 +257,11 @@ impl TTLPolicy { } #[inline] - pub fn extend(&mut self, py: pyo3::Python<'_>, iterable: pyo3::PyObject) -> pyo3::PyResult<()> { + pub fn extend( + &mut self, + py: pyo3::Python<'_>, + iterable: pyo3::Py, + ) -> pyo3::PyResult<()> { use pyo3::types::{PyAnyMethods, PyDictMethods}; if unsafe { pyo3::ffi::PyDict_CheckExact(iterable.as_ptr()) == 1 } { @@ -282,7 +286,8 @@ impl TTLPolicy { } } else { for pair in iterable.bind(py).try_iter()? { - let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?; + let (key, value) = + pair?.extract::<(pyo3::Py, pyo3::Py)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -394,7 +399,7 @@ impl TTLPolicy { for pair in iterable.bind(py).try_iter()? { let (key, value, timestamp) = - pair?.extract::<(pyo3::PyObject, pyo3::PyObject, f64)>()?; + pair?.extract::<(pyo3::Py, pyo3::Py, f64)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -421,7 +426,7 @@ impl TTLPolicy { impl<'a> TTLPolicyOccupied<'a> { #[inline] - pub fn update(self, value: pyo3::PyObject) -> pyo3::PyResult { + pub fn update(self, value: pyo3::Py) -> pyo3::PyResult> { // We have to move the value to the end of the vector let (mut index, slot) = unsafe { self.instance.table.remove(self.bucket.clone()) }; index -= self.instance.n_shifts; @@ -473,7 +478,7 @@ impl TTLPolicyAbsent<'_> { unsafe fn pickle_insert( self, key: PreHashObject, - value: pyo3::PyObject, + value: pyo3::Py, expire_at: std::time::SystemTime, ) -> pyo3::PyResult<()> { match self.situation { @@ -509,7 +514,7 @@ impl TTLPolicyAbsent<'_> { self, py: pyo3::Python<'_>, key: PreHashObject, - value: pyo3::PyObject, + value: pyo3::Py, ) -> pyo3::PyResult<()> { let expire_at = std::time::SystemTime::now() + self.instance.ttl; diff --git a/src/policies/vttl.rs b/src/policies/vttl.rs index edb0bbf..aa7541e 100644 --- a/src/policies/vttl.rs +++ b/src/policies/vttl.rs @@ -263,7 +263,7 @@ impl VTTLPolicy { pub fn extend( &mut self, py: pyo3::Python<'_>, - iterable: pyo3::PyObject, + iterable: pyo3::Py, ttl: Option, ) -> pyo3::PyResult<()> { use pyo3::types::{PyAnyMethods, PyDictMethods}; @@ -290,7 +290,8 @@ impl VTTLPolicy { } } else { for pair in iterable.bind(py).try_iter()? { - let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?; + let (key, value) = + pair?.extract::<(pyo3::Py, pyo3::Py)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -331,7 +332,7 @@ impl VTTLPolicy { for pair in iterable.bind(py).try_iter()? { let (key, value, timestamp) = - pair?.extract::<(pyo3::PyObject, pyo3::PyObject, f64)>()?; + pair?.extract::<(pyo3::Py, pyo3::Py, f64)>()?; let hk = PreHashObject::from_pyobject(py, key)?; @@ -362,7 +363,11 @@ impl VTTLPolicy { impl VTTLPolicyOccupied<'_> { #[inline] - pub fn update(self, value: pyo3::PyObject, ttl: Option) -> pyo3::PyResult { + pub fn update( + self, + value: pyo3::Py, + ttl: Option, + ) -> pyo3::PyResult> { let item = unsafe { self.bucket.as_mut() }; unsafe { @@ -396,7 +401,7 @@ impl VTTLPolicyAbsent<'_> { unsafe fn pickle_insert( self, key: PreHashObject, - value: pyo3::PyObject, + value: pyo3::Py, expire_at: Option, ) -> pyo3::PyResult<()> { match self.situation { @@ -431,7 +436,7 @@ impl VTTLPolicyAbsent<'_> { pub fn insert( self, key: PreHashObject, - value: pyo3::PyObject, + value: pyo3::Py, ttl: Option, ) -> pyo3::PyResult<()> { let expire_at = From 7070fffbe7030040991b5df142f1e41ed0e678cb Mon Sep 17 00:00:00 2001 From: chiri Date: Thu, 11 Sep 2025 19:00:43 +0300 Subject: [PATCH 4/6] add 3.14rc2 for tests --- .github/workflows/python-test.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/python-test.yml b/.github/workflows/python-test.yml index 7dfd6aa..f90c12a 100644 --- a/.github/workflows/python-test.yml +++ b/.github/workflows/python-test.yml @@ -20,6 +20,7 @@ jobs: - '3.11' - '3.12' - '3.13' + - '3.14rc2' - 'pypy3.9' - 'pypy3.10' From 45d6b58d41f511c2eac472750e99b4c342215072 Mon Sep 17 00:00:00 2001 From: chiri Date: Thu, 11 Sep 2025 19:06:45 +0300 Subject: [PATCH 5/6] run tests in PR --- .github/workflows/python-test.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/python-test.yml b/.github/workflows/python-test.yml index f90c12a..707bcb1 100644 --- a/.github/workflows/python-test.yml +++ b/.github/workflows/python-test.yml @@ -2,6 +2,7 @@ name: python-test on: push: + pull_request: permissions: contents: read From 8de348f00e679a77dc811b29b0a100ea267fd8ff Mon Sep 17 00:00:00 2001 From: chiri Date: Thu, 11 Sep 2025 20:30:52 +0300 Subject: [PATCH 6/6] fix `warning: hiding a lifetime that's elided elsewhere is confusing` --- src/policies/fifo.rs | 6 +++--- src/policies/lfu.rs | 8 ++++---- src/policies/lru.rs | 8 ++++---- src/policies/nopolicy.rs | 8 ++++---- src/policies/random.rs | 8 ++++---- src/policies/ttl.rs | 6 +++--- src/policies/vttl.rs | 8 ++++---- 7 files changed, 26 insertions(+), 26 deletions(-) diff --git a/src/policies/fifo.rs b/src/policies/fifo.rs index f1f4dfd..1bd3806 100644 --- a/src/policies/fifo.rs +++ b/src/policies/fifo.rs @@ -145,7 +145,7 @@ impl FIFOPolicy { &mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, FIFOPolicyAbsent<'_>>> { match self .table .try_find(key.hash, |x| self.entries[(*x) - self.n_shifts].0.equal(py, key))? @@ -166,10 +166,10 @@ impl FIFOPolicy { #[inline] #[rustfmt::skip] pub fn entry_with_slot( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, FIFOPolicyAbsent<'_>>> { match self.table.try_find_or_find_insert_slot( key.hash, |x| self.entries[(*x) - self.n_shifts].0.equal(py, key), diff --git a/src/policies/lfu.rs b/src/policies/lfu.rs index ded9296..5f2e356 100644 --- a/src/policies/lfu.rs +++ b/src/policies/lfu.rs @@ -81,10 +81,10 @@ impl LFUPolicy { #[inline] #[rustfmt::skip] pub fn entry( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, LFUPolicyAbsent<'_>>> { match self .table .try_find(key.hash, |ptr| unsafe { ptr.as_ref().0.equal(py, key) })? @@ -105,10 +105,10 @@ impl LFUPolicy { #[inline] #[rustfmt::skip] pub fn entry_with_slot( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, LFUPolicyAbsent<'_>>> { match self.table.try_find_or_find_insert_slot( key.hash, |ptr| unsafe { ptr.as_ref().0.equal(py, key) }, diff --git a/src/policies/lru.rs b/src/policies/lru.rs index cb493da..59ccb3c 100644 --- a/src/policies/lru.rs +++ b/src/policies/lru.rs @@ -77,10 +77,10 @@ impl LRUPolicy { #[inline] #[rustfmt::skip] pub fn entry( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, LRUPolicyAbsent<'_>>> { match self .table .try_find(key.hash, |x| unsafe { x.as_ref().element.0.equal(py, key) })? @@ -101,10 +101,10 @@ impl LRUPolicy { #[inline] #[rustfmt::skip] pub fn entry_with_slot( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, LRUPolicyAbsent<'_>>> { match self .table .try_find_or_find_insert_slot( diff --git a/src/policies/nopolicy.rs b/src/policies/nopolicy.rs index ab2e4ec..f707a54 100644 --- a/src/policies/nopolicy.rs +++ b/src/policies/nopolicy.rs @@ -60,10 +60,10 @@ impl NoPolicy { #[inline] #[rustfmt::skip] pub fn entry( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, NoPolicyAbsent<'_>>> { match self.table.try_find(key.hash, |(x, _)| x.equal(py, key))? { Some(bucket) => { Ok( @@ -81,10 +81,10 @@ impl NoPolicy { #[inline] #[rustfmt::skip] pub fn entry_with_slot( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, NoPolicyAbsent<'_>>> { match self.table.try_find_or_find_insert_slot( key.hash, |(x, _)| x.equal(py, key), diff --git a/src/policies/random.rs b/src/policies/random.rs index 2740b9e..90bce8e 100644 --- a/src/policies/random.rs +++ b/src/policies/random.rs @@ -75,10 +75,10 @@ impl RandomPolicy { #[inline] #[rustfmt::skip] pub fn entry( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, RandomPolicyAbsent<'_>>> { match self.table.try_find(key.hash, |(x, _)| x.equal(py, key))? { Some(bucket) => { Ok( @@ -96,10 +96,10 @@ impl RandomPolicy { #[inline] #[rustfmt::skip] pub fn entry_with_slot( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, RandomPolicyAbsent<'_>>> { match self.table.try_find_or_find_insert_slot( key.hash, |(x, _)| x.equal(py, key), diff --git a/src/policies/ttl.rs b/src/policies/ttl.rs index f857aa9..e612c60 100644 --- a/src/policies/ttl.rs +++ b/src/policies/ttl.rs @@ -159,10 +159,10 @@ impl TTLPolicy { #[inline] #[rustfmt::skip] pub fn entry( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, TTLPolicyAbsent<'_>>> { match self .table .try_find(key.hash, |x| self.entries[(*x) - self.n_shifts].key.equal(py, key))? @@ -190,7 +190,7 @@ impl TTLPolicy { &mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, TTLPolicyAbsent<'_>>> { match self.table.try_find_or_find_insert_slot( key.hash, |x| self.entries[(*x) - self.n_shifts].key.equal(py, key), diff --git a/src/policies/vttl.rs b/src/policies/vttl.rs index aa7541e..71a2fef 100644 --- a/src/policies/vttl.rs +++ b/src/policies/vttl.rs @@ -124,10 +124,10 @@ impl VTTLPolicy { #[inline] #[rustfmt::skip] pub fn entry( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, VTTLPolicyAbsent<'_>>> { match self .table .try_find(key.hash, |ptr| unsafe { ptr.as_ref().key.equal(py, key) })? @@ -152,10 +152,10 @@ impl VTTLPolicy { #[inline] #[rustfmt::skip] pub fn entry_with_slot( - &mut self, + &'_ mut self, py: pyo3::Python<'_>, key: &PreHashObject, - ) -> pyo3::PyResult> { + ) -> pyo3::PyResult, VTTLPolicyAbsent<'_>>> { match self .table .try_find_or_find_insert_slot(