Update changelog, readme; Fix __repr__

Author: awolverp

CHANGELOG.md

@@ -6,12 +6,29 @@ 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).
 
 ## v5.0.0 - Unreleased
-### Targets:
-- Update `hashbrown` dependency
-- Make 2x faster by changing my *`isize` to `u64` strategy* in Rust.
-- Rewrite cache classes API in Python; this help users to use classes as subclass and customize them.
-- Make benchmarks better
-- Make error handlings better
+### Added
+- A new method named `random_key` added to `RRCache`.
+- A new method named `expire` added to `TTLCache`.
+- Some new methods added to `VTTLCache`: `expire`, `items_with_expire`.
+- `TTLCache` now supports `timedelta` as ttl.
+- `VTTLCache` now supports `timedelta` and `datetime` as ttl.
+- A new method `copy` added to all caches.
+
+### Changed
+- The core codes (rust code) renamed from `_cachebox` to `_core`. Instead of that, all of classes
+  implemented in Python which are using the core's classes. This change can help to customize the alghoritms.
+- Now the errors which occurred while doing `__eq__` operations will not be ignored.
+- Docstrings is now more complete.
+- The strictness in `__eq__` methods was reduced.
+- Add more strictness for loading pickle objects.
+- `LFUCache` now uses `VecDeque` instead of `Vec` (improves performance).
+- The `CacheInfo.cachememory` renamed to `CacheInfo.memory`.
+- *`isize` to `u64` strategy* changed in Rust.
+- `__repr__` methods refactored.
+
+### Removed
+- The `n` parameter of the `LRUCache.least_recently_used` method has been removed.
+- The deprecated `always_copy` parameter of the `cached` and `cachedmethod` decorators has been removed.
 
 ## 4.5.3 - 2025-03-31
 ### Changed

README.md

@@ -840,15 +840,17 @@ assert c.capacity() == loaded.capacity()
 * * *
 
 #### How to copy the caches?
-Use `copy.deepcopy` or `copy.copy` for copying caches. For example:
+You can use `copy.deepcopy` or `cache.copy` for copying caches. For example:
 ```python
-import cachebox, copy
-c = cachebox.LRUCache(100, {i:i for i in range(78)})
+import cachebox
+cache = cachebox.LRUCache(100, {i:i for i in range(78)})
 
-copied = copy.copy(c)
+# shallow copy
+shallow = cache.copy()
 
-assert c == copied
-assert c.capacity() == copied.capacity()
+# deep copy
+import copy
+deep = copy.deepcopy(cache)
 ```
 
 ## License

python/cachebox/_cachebox.py

@@ -1,6 +1,7 @@
 from . import _core
 from ._core import BaseCacheImpl
 from datetime import timedelta, datetime
+import copy as _std_copy
 import typing
 
 
@@ -11,7 +12,7 @@
 
 def _items_to_str(items, length):
     if length <= 50:
-        return "{" + ", ".join(f"{k}: {v}" for k, v in items) + "}"
+        return "{" + ", ".join(f"{k!r}: {v!r}" for k, v in items) + "}"
 
     c = 0
     left = []
@@ -20,7 +21,7 @@ def _items_to_str(items, length):
         k, v = next(items)
 
         if c <= 50:
-            left.append(f"{k}: {v}")
+            left.append(f"{k!r}: {v!r}")
 
         else:
             break
@@ -251,6 +252,22 @@ def values(self) -> IteratorView[VT]:
         """
         return IteratorView(self._raw.items(), lambda x: x[1])
 
+    def copy(self) -> "Cache[KT, VT]":
+        """Returns a shallow copy of the cache"""
+        return self.__copy__()
+
+    def __copy__(self) -> "Cache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.copy(self._raw)
+        return copied
+
+    def __deepcopy__(self, memo) -> "Cache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.deepcopy(self._raw, memo)
+        return copied
+
     def __iter__(self) -> IteratorView[KT]:
         return self.keys()
 
@@ -501,6 +518,22 @@ def last(self) -> typing.Optional[KT]:
         """
         return self._raw.get_index(len(self._raw) - 1)
 
+    def copy(self) -> "FIFOCache[KT, VT]":
+        """Returns a shallow copy of the cache"""
+        return self.__copy__()
+
+    def __copy__(self) -> "FIFOCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.copy(self._raw)
+        return copied
+
+    def __deepcopy__(self, memo) -> "FIFOCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.deepcopy(self._raw, memo)
+        return copied
+
     def __iter__(self) -> IteratorView[KT]:
         return self.keys()
 
@@ -739,6 +772,22 @@ def values(self) -> IteratorView[VT]:
         """
         return IteratorView(self._raw.items(), lambda x: x[1])
 
+    def copy(self) -> "RRCache[KT, VT]":
+        """Returns a shallow copy of the cache"""
+        return self.__copy__()
+
+    def __copy__(self) -> "RRCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.copy(self._raw)
+        return copied
+
+    def __deepcopy__(self, memo) -> "RRCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.deepcopy(self._raw, memo)
+        return copied
+
     def __iter__(self) -> IteratorView[KT]:
         return self.keys()
 
@@ -995,6 +1044,22 @@ def most_recently_used(self) -> typing.Optional[KT]:
         """
         return self._raw.most_recently_used()
 
+    def copy(self) -> "LRUCache[KT, VT]":
+        """Returns a shallow copy of the cache"""
+        return self.__copy__()
+
+    def __copy__(self) -> "LRUCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.copy(self._raw)
+        return copied
+
+    def __deepcopy__(self, memo) -> "LRUCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.deepcopy(self._raw, memo)
+        return copied
+
     def __iter__(self) -> IteratorView[KT]:
         return self.keys()
 
@@ -1264,6 +1329,22 @@ def least_frequently_used(self, n: int = 0) -> typing.Optional[KT]:
 
         return self._raw.least_frequently_used(n)
 
+    def copy(self) -> "LFUCache[KT, VT]":
+        """Returns a shallow copy of the cache"""
+        return self.__copy__()
+
+    def __copy__(self) -> "LFUCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.copy(self._raw)
+        return copied
+
+    def __deepcopy__(self, memo) -> "LFUCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.deepcopy(self._raw, memo)
+        return copied
+
     def __iter__(self) -> IteratorView[KT]:
         return self.keys()
 
@@ -1605,6 +1686,22 @@ def expire(self) -> None:  # pragma: no cover
         """
         self._raw.expire()
 
+    def copy(self) -> "TTLCache[KT, VT]":
+        """Returns a shallow copy of the cache"""
+        return self.__copy__()
+
+    def __copy__(self) -> "TTLCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.copy(self._raw)
+        return copied
+
+    def __deepcopy__(self, memo) -> "TTLCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.deepcopy(self._raw, memo)
+        return copied
+
     def __iter__(self) -> IteratorView[KT]:
         return self.keys()
 
@@ -1982,6 +2079,22 @@ def expire(self) -> None:  # pragma: no cover
         """
         self._raw.expire()
 
+    def copy(self) -> "VTTLCache[KT, VT]":
+        """Returns a shallow copy of the cache"""
+        return self.__copy__()
+
+    def __copy__(self) -> "VTTLCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.copy(self._raw)
+        return copied
+
+    def __deepcopy__(self, memo) -> "VTTLCache[KT, VT]":
+        cls = type(self)
+        copied = cls.__new__(cls)
+        copied._raw = _std_copy.deepcopy(self._raw, memo)
+        return copied
+
     def __iter__(self) -> IteratorView[KT]:
         return self.keys()