Support free-threading, __str__ changed to __repr__, and dependencies updated

Author: awolverp

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 4.3.1 - 2024-11-18
+### Changed
+- `__str__` changed to `__repr__`
+- Free-threading is supported now
+- Dependencies updated
+
 ## 4.3.0 - 2024-11-08
 ### Added
 - Add `always_copy` parameter to `cached` and `cachedmethod` decorators

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cachebox"
-version = "4.3.0"
+version = "4.3.1"
 edition = "2021"
 description = "The fastest memoizing and caching Python library written in Rust"
 readme = "README.md"
@@ -23,14 +23,14 @@ strip = "symbols"
 [dependencies]
 hashbrown = { version = "^0.14", default-features = false, features=["inline-more", "raw"]}
 fastrand = "^2.1"
-pyo3 = { version = "0.22.6", default-features = false, features=["macros", "extension-module"] }
+pyo3 = { version = "0.23.1", default-features = false, features=["macros", "extension-module"] }
 cfg-if = "1.0"
 parking_lot_core = { version = "^0.9", default-features = false }
 lock_api = { version = "^0.4", default-features = false }
 fxhash = {version = "^0.2"}
 
 [build-dependencies]
-pyo3-build-config = { version = "0.22.6", features = ["resolve-config"] }
+pyo3-build-config = { version = "0.23.1", features = ["resolve-config"] }
 
 [lints.clippy]
 dbg_macro = "warn"

Cargo.toml

@@ -62,7 +62,7 @@ def __delitem__(self, key: KT) -> VT:
 
         raise TypeError("This cache is frozen.")
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         return f"<Frozen: {self.__cache}>"
 
     def __iter__(self) -> typing.Iterator[KT]:

cachebox/utils.py

@@ -11,7 +11,7 @@ use crate::util::_KeepForIter;
 /// - it supports useful and new methods for managing memory, while `dict` does not.
 /// - it does not support `popitem`, while `dict` does.
 /// - You can limit the size of [`Cache`], but you cannot for `dict`.
-#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl)]
+#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl, frozen)]
 pub struct Cache {
     // Why [`Box`]? We using [`Box`] here so that there's no need for `&mut self`
     // in this struct; so RuntimeError never occurred for using this class in multiple threads.
@@ -127,8 +127,8 @@ impl Cache {
         }
     }
 
-    /// Returns str(self)
-    pub fn __str__(&self) -> String {
+    /// Returns repr(self)
+    pub fn __repr__(&self) -> String {
         let lock = self.raw.lock();
 
         format!(

src/bridge/cache.rs

@@ -5,7 +5,7 @@ use crate::{hashedkey::HashedKey, util::_KeepForIter};
 /// FIFO Cache implementation - First-In First-Out Policy (thread-safe).
 ///
 /// In simple terms, the FIFO cache will remove the element that has been in the cache the longest.
-#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl)]
+#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl, frozen)]
 pub struct FIFOCache {
     // Why [`Box`]? We using [`Box`] here so that there's no need for `&mut self`
     // in this struct; so RuntimeError never occurred for using this class in multiple threads.
@@ -119,8 +119,8 @@ impl FIFOCache {
         }
     }
 
-    /// Returns str(self)
-    pub fn __str__(&self) -> String {
+    /// Returns repr(self)
+    pub fn __repr__(&self) -> String {
         let lock = self.raw.lock();
 
         format!(

src/bridge/fifocache.rs

@@ -5,7 +5,7 @@ use crate::{hashedkey::HashedKey, util::_KeepForIter};
 /// LFU Cache implementation - Least frequantly used policy (thread-safe).
 ///
 /// In simple terms, the LFU cache will remove the element in the cache that has been accessed the least, regardless of time
-#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl)]
+#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl, frozen)]
 pub struct LFUCache {
     // Why [`Box`]? We using [`Box`] here so that there's no need for `&mut self`
     // in this struct; so RuntimeError never occurred for using this class in multiple threads.
@@ -126,8 +126,8 @@ impl LFUCache {
         }
     }
 
-    /// Returns str(self)
-    pub fn __str__(&self) -> String {
+    /// Returns repr(self)
+    pub fn __repr__(&self) -> String {
         let lock = self.raw.lock();
 
         format!(

src/bridge/lfucache.rs

@@ -5,7 +5,7 @@ use crate::{hashedkey::HashedKey, util::_KeepForIter};
 /// LRU Cache implementation - Least recently used policy (thread-safe).
 ///
 /// In simple terms, the LRU cache will remove the element in the cache that has not been accessed in the longest time.
-#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl)]
+#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl, frozen)]
 pub struct LRUCache {
     // Why [`Box`]? We using [`Box`] here so that there's no need for `&mut self`
     // in this struct; so RuntimeError never occurred for using this class in multiple threads.
@@ -120,8 +120,8 @@ impl LRUCache {
         }
     }
 
-    /// Returns str(self)
-    pub fn __str__(&self) -> String {
+    /// Returns repr(self)
+    pub fn __repr__(&self) -> String {
         let lock = self.raw.lock();
 
         format!(

src/bridge/lrucache.rs

@@ -42,7 +42,7 @@ macro_rules! insert_rr {
 /// RRCache implementation - Random Replacement policy (thread-safe).
 ///
 /// In simple terms, the RR cache will choice randomly element to remove it to make space when necessary.
-#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl)]
+#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl, frozen)]
 pub struct RRCache {
     // Why [`Box`]? We using [`Box`] here so that there's no need for `&mut self`
     // in this struct; so RuntimeError never occurred for using this class in multiple threads.
@@ -156,8 +156,8 @@ impl RRCache {
         }
     }
 
-    /// Returns str(self)
-    pub fn __str__(&self) -> String {
+    /// Returns repr(self)
+    pub fn __repr__(&self) -> String {
         let lock = self.raw.lock();
 
         format!(
@@ -409,7 +409,7 @@ impl RRCache {
 
             Ok(())
         } else {
-            for pair in iterable.bind(py).iter()? {
+            for pair in iterable.bind(py).try_iter()? {
                 let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?;
 
                 let hk = HashedKey::from_pyobject(py, key)?;

src/bridge/rrcache.rs

@@ -5,7 +5,7 @@ use crate::{hashedkey::HashedKey, internal::TTLElement, util::_KeepForIter};
 /// TTL Cache implementation - Time-To-Live Policy (thread-safe).
 ///
 /// In simple terms, the TTL cache will automatically remove the element in the cache that has expired::
-#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl)]
+#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl, frozen)]
 pub struct TTLCache {
     // Why [`Box`]? We using [`Box`] here so that there's no need for `&mut self`
     // in this struct; so RuntimeError never occurred for using this class in multiple threads.
@@ -138,8 +138,8 @@ impl TTLCache {
         }
     }
 
-    /// Returns str(self)
-    pub fn __str__(&self) -> String {
+    /// Returns repr(self)
+    pub fn __repr__(&self) -> String {
         let mut lock = self.raw.lock();
         lock.expire();
 

src/bridge/ttlcache.rs

@@ -5,7 +5,7 @@ use crate::{hashedkey::HashedKey, internal::VTTLElement, util::_KeepForIter};
 /// VTTL Cache Implementation - Time-To-Live Per-Key Policy (thread-safe).
 ///
 /// In simple terms, the TTL cache will automatically remove the element in the cache that has expired when need.
-#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl)]
+#[pyo3::pyclass(module="cachebox._cachebox", extends=crate::bridge::baseimpl::BaseCacheImpl, frozen)]
 pub struct VTTLCache {
     // Why [`Box`]? We using [`Box`] here so that there's no need for `&mut self`
     // in this struct; so RuntimeError never occurred for using this class in multiple threads.
@@ -125,8 +125,8 @@ impl VTTLCache {
         }
     }
 
-    /// Returns str(self)
-    pub fn __str__(&self) -> String {
+    /// Returns repr(self)
+    pub fn __repr__(&self) -> String {
         let lock = self.raw.lock();
 
         format!(

src/bridge/vttlcache.rs

@@ -203,7 +203,7 @@ impl FIFOPolicy {
 
             Ok(())
         } else {
-            for pair in iterable.bind(py).iter()? {
+            for pair in iterable.bind(py).try_iter()? {
                 let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?;
 
                 let hk = HashedKey::from_pyobject(py, key)?;

src/internal/fifo.rs

@@ -169,7 +169,7 @@ impl LFUPolicy {
 
             Ok(())
         } else {
-            for pair in iterable.bind(py).iter()? {
+            for pair in iterable.bind(py).try_iter()? {
                 let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?;
 
                 let hk = HashedKey::from_pyobject(py, key)?;
@@ -267,7 +267,7 @@ impl LFUPolicy {
 
         let mut new = Self::new(maxsize, capacity)?;
 
-        for pair in iterable.bind(py).iter()? {
+        for pair in iterable.bind(py).try_iter()? {
             let (key, value, fr) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject, usize)>()?;
 
             let hk = HashedKey::from_pyobject(py, key)?;

src/internal/lfu.rs

@@ -162,7 +162,7 @@ impl LRUPolicy {
 
             Ok(())
         } else {
-            for pair in iterable.bind(py).iter()? {
+            for pair in iterable.bind(py).try_iter()? {
                 let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?;
 
                 let hk = HashedKey::from_pyobject(py, key)?;

src/internal/lru.rs

@@ -97,7 +97,7 @@ impl NoPolicy {
 
             Ok(())
         } else {
-            for pair in iterable.bind(py).iter()? {
+            for pair in iterable.bind(py).try_iter()? {
                 let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?;
 
                 let hk = HashedKey::from_pyobject(py, key)?;

src/internal/nopolicy.rs

@@ -233,7 +233,7 @@ impl TTLPolicy {
 
             Ok(())
         } else {
-            for pair in iterable.bind(py).iter()? {
+            for pair in iterable.bind(py).try_iter()? {
                 let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?;
 
                 let hk = HashedKey::from_pyobject(py, key)?;
@@ -344,7 +344,7 @@ impl TTLPolicy {
 
         let mut new = Self::new(maxsize, capacity, ttl)?;
 
-        for pair in iterable.bind(py).iter()? {
+        for pair in iterable.bind(py).try_iter()? {
             let (key, value, timestamp) =
                 pair?.extract::<(pyo3::PyObject, pyo3::PyObject, f64)>()?;
 

src/internal/ttl.rs

@@ -261,7 +261,7 @@ impl VTTLPolicy {
 
             Ok(())
         } else {
-            for pair in iterable.bind(py).iter()? {
+            for pair in iterable.bind(py).try_iter()? {
                 let (key, value) = pair?.extract::<(pyo3::PyObject, pyo3::PyObject)>()?;
 
                 let hk = HashedKey::from_pyobject(py, key)?;
@@ -362,7 +362,7 @@ impl VTTLPolicy {
 
         let mut new = Self::new(maxsize, capacity)?;
 
-        for pair in iterable.bind(py).iter()? {
+        for pair in iterable.bind(py).try_iter()? {
             let (key, value, timestamp) =
                 pair?.extract::<(pyo3::PyObject, pyo3::PyObject, f64)>()?;
 

src/internal/vttl.rs

@@ -41,6 +41,8 @@ pub fn version_info() -> (u8, u8, u8, bool) {
 #[pymodule]
 #[pyo3(name = "_cachebox")]
 fn _cachebox(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.gil_used(false)?;
+
     m.add("__version__", CACHEBOX_VERSION)?;
     m.add("version_info", version_info())?;
     m.add("__author__", "awolverp")?;

src/lib.rs

@@ -1,5 +1,5 @@
 #[allow(unused_imports)]
-use pyo3::IntoPy;
+use pyo3::IntoPyObject;
 
 macro_rules! err {
     ($type:ty, $val:expr) => {
@@ -140,7 +140,7 @@ unsafe fn _get_capacity(
     ) -> pyo3::PyResult<*mut pyo3::ffi::PyObject> {
         cfg_if::cfg_if! {
             if #[cfg(all(Py_3_9, not(any(Py_LIMITED_API, PyPy, GraalPy))))] {
-                let m_name: pyo3::Py<pyo3::types::PyString> = "capacity".into_py(py);
+                let m_name: pyo3::Bound<'_, pyo3::types::PyString> = "capacity".into_pyobject(py)?;
                 Ok(pyo3::ffi::PyObject_CallMethodNoArgs(ptr, m_name.as_ptr()))
             } else {
                 let capacity_fn =

src/util.rs

@@ -151,9 +151,10 @@ def test___setitem__(self):
         with pytest.raises(KeyError):
             cache[2]
 
-    def test___str__(self):
+    def test___repr__(self):
         cache = self.CACHE(2, **self.KWARGS, capacity=2)
-        assert str(cache) != repr(cache)
+        assert str(cache) == repr(cache)
+        assert repr(cache).startswith(self.CACHE.__name__)
 
     def test_insert(self):
         cache = self.CACHE(5, **self.KWARGS, capacity=5)