Optimize dependencies profiles

Fix some bugs
Write tests for FIFOCache and Cache
Optimize some operations
Write FIFOCache

Author: awolverp

.gitignore

@@ -2,4 +2,5 @@
 /target
 __pycache__
 *.so
-/.caches.rs
+/.coverage
+/.pytest_cache

Cargo.toml

@@ -41,6 +41,9 @@ version = "1.0.0"
 version = "0.12.3"
 default-features = false
 
+[profile.release.package."*"]
+codegen-units = 1 # better optimizations
+
 [build-dependencies.pyo3-build-config]
 version = "0.24.1"
 features = ["resolve-config"]

pyproject.toml

@@ -44,9 +44,13 @@ Homepage = 'https://github.com/awolverp/cachebox'
 [project.optional-dependencies]
 tests = [
     "pytest",
+    "pytest-asyncio",
     "coverage",
 ]
 
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "function"
+
 [tool.maturin]
 python-source = "python"
 features = ["pyo3/extension-module"]

python/cachebox/__init__.py

@@ -1,4 +1,6 @@
 from ._cachebox import (
     Cache as Cache,
+    FIFOCache as FIFOCache,
     BaseCacheImpl as BaseCacheImpl,
+    IteratorView as IteratorView,
 )

python/cachebox/_cachebox.py

@@ -6,29 +6,26 @@
 VT = typing.TypeVar("VT")
 DT = typing.TypeVar("DT")
 
-_sential = object()
 
-
-def _items_to_str(items, length, max_len=50):
-    if length <= max_len:
+def _items_to_str(items, length):
+    if length <= 50:
         return "{" + ", ".join(f"{k}: {v}" for k, v in items) + "}"
 
     c = 0
     left = []
-    right = []
 
     while c < length:
         k, v = next(items)
 
-        if c <= 20:
+        if c <= 50:
             left.append(f"{k}: {v}")
 
-        elif (length - c) <= 20:
-            right.append(f"{k}: {v}")
+        else:
+            break
 
         c += 1
 
-    return "{" + ", ".join(left) + " ... truncated ... " + ", ".join(right) + "}"
+    return "{%s, ... %d more ...}" % (", ".join(left), length - c)
 
 
 class BaseCacheImpl(typing.Generic[KT, VT]):
@@ -129,13 +126,19 @@ def insert(self, key: KT, value: VT) -> typing.Optional[VT]:
 
     def get(self, key: KT, default: typing.Optional[DT] = None) -> typing.Union[VT, DT]:
         """Equals to `self[key]`, but returns `default` if the cache don't have this key present."""
-        return self._raw.get(key, default)
+        try:
+            return self._raw.get(key)
+        except _core.CoreKeyError:
+            return default
 
     def pop(self, key: KT, default: typing.Optional[DT] = None) -> typing.Union[VT, DT]:
         """
         Removes specified key and return the corresponding value. If the key is not found, returns the `default`.
         """
-        return self._raw.pop(key, default)
+        try:
+            return self._raw.remove(key)
+        except _core.CoreKeyError:
+            return default
 
     def setdefault(self, key: KT, default: typing.Optional[DT] = None) -> typing.Union[VT, DT]:
         """
@@ -165,22 +168,28 @@ def __setitem__(self, key: KT, value: VT) -> None:
         self.insert(key, value)
 
     def __getitem__(self, key: KT) -> VT:
-        val = self._raw.get(key, _sential)
-        if val is _sential:
-            raise KeyError(key)
-
-        return val
+        try:
+            return self._raw.get(key)
+        except _core.CoreKeyError:
+            raise KeyError(key) from None
 
     def __delitem__(self, key: KT) -> None:
-        val = self._raw.pop(key, _sential)
-        if val is _sential:
-            raise KeyError(key)
+        try:
+            self._raw.remove(key)
+        except _core.CoreKeyError:
+            raise KeyError(key) from None
 
     def __eq__(self, other) -> bool:
-        return self._raw == other
+        if not isinstance(other, Cache):
+            return False
+
+        return self._raw == other._raw
 
     def __ne__(self, other) -> bool:
-        return self._raw != other
+        if not isinstance(other, Cache):
+            return False
+
+        return self._raw != other._raw
 
     def shrink_to_fit(self) -> None:
         """Shrinks the cache to fit len(self) elements."""
@@ -278,16 +287,25 @@ def insert(self, key: KT, value: VT) -> typing.Optional[VT]:
         return self._raw.insert(key, value)
 
     def get(self, key: KT, default: typing.Optional[DT] = None) -> typing.Union[VT, DT]:
-        return self._raw.get(key, default)
+        try:
+            return self._raw.get(key)
+        except _core.CoreKeyError:
+            return default
 
     def pop(self, key: KT, default: typing.Optional[DT] = None) -> typing.Union[VT, DT]:
-        return self._raw.pop(key, default)
+        try:
+            return self._raw.remove(key)
+        except _core.CoreKeyError:
+            return default
 
     def setdefault(self, key: KT, default: typing.Optional[DT] = None) -> typing.Union[VT, DT]:
         return self._raw.setdefault(key, default)
 
     def popitem(self) -> typing.Tuple[KT, VT]:
-        return self._raw.popitem()
+        try:
+            return self._raw.popitem()
+        except _core.CoreKeyError:
+            raise KeyError() from None
 
     def drain(self, n: int) -> int:
         if n == 0:
@@ -296,7 +314,7 @@ def drain(self, n: int) -> int:
         for i in range(n):
             try:
                 self._raw.popitem()
-            except KeyError:
+            except _core.CoreKeyError:
                 return i
 
         return i
@@ -311,22 +329,28 @@ def __setitem__(self, key: KT, value: VT) -> None:
         self.insert(key, value)
 
     def __getitem__(self, key: KT) -> VT:
-        val = self._raw.get(key, _sential)
-        if val is _sential:
-            raise KeyError(key)
-
-        return val
+        try:
+            return self._raw.get(key)
+        except _core.CoreKeyError:
+            raise KeyError(key) from None
 
     def __delitem__(self, key: KT) -> None:
-        val = self._raw.pop(key, _sential)
-        if val is _sential:
-            raise KeyError(key)
+        try:
+            self._raw.remove(key)
+        except _core.CoreKeyError:
+            raise KeyError(key) from None
 
     def __eq__(self, other) -> bool:
-        return self._raw == other
+        if not isinstance(other, FIFOCache):
+            return False
+
+        return self._raw == other._raw
 
     def __ne__(self, other) -> bool:
-        return self._raw != other
+        if not isinstance(other, FIFOCache):
+            return False
+
+        return self._raw != other._raw
 
     def shrink_to_fit(self) -> None:
         self._raw.shrink_to_fit()
@@ -343,6 +367,18 @@ def keys(self) -> IteratorView[KT]:
     def values(self) -> IteratorView[VT]:
         return IteratorView(self._raw.items(), lambda x: x[1])
 
+    def first(self, n: int = 0) -> typing.Optional[KT]:
+        if n < 0:
+            n = len(self._raw) + n
+
+        if n < 0:
+            return None
+
+        return self._raw.get_index(n)
+
+    def last(self) -> typing.Optional[KT]:
+        return self._raw.get_index(len(self._raw) - 1)
+
     def __iter__(self) -> IteratorView[KT]:
         return self.keys()