fixes for

iamsinghrajat#26

Author: doubledare704

cache/__init__.py

@@ -1,2 +1,10 @@
+"""
+Async caching library providing LRU and TTL caching decorators.
+"""
+
 from .async_lru import AsyncLRU
 from .async_ttl import AsyncTTL
+from .types import T, AsyncFunc
+
+__all__ = ['AsyncLRU', 'AsyncTTL']
+__version__ = '1.1.1'

cache/async_lru.py

@@ -1,35 +1,31 @@
+from functools import wraps
+from typing import Optional, Coroutine
+
 from .key import KEY
 from .lru import LRU
+from .types import T, AsyncFunc, Callable, Any
 
 
 class AsyncLRU:
-    def __init__(self, maxsize=128):
-        """
-        :param maxsize: Use maxsize as None for unlimited size cache
-        """
-        self.lru = LRU(maxsize=maxsize)
-        
-    def cache_clear(self):
-        """
-        Clears the LRU cache.
-
-        This method empties the cache, removing all stored
-        entries and effectively resetting the cache.
-
-        :return: None
-        """
-        self.lru.clear()
-
-    def __call__(self, func):
-        async def wrapper(*args, use_cache=True, **kwargs):
-            key = KEY(args, kwargs)
-            if key in self.lru and use_cache:
-                return self.lru[key]
-            else:
-                self.lru[key] = await func(*args, **kwargs)
-                return self.lru[key]
-
-        wrapper.__name__ += func.__name__
-        wrapper.__dict__['cache_clear'] = self.cache_clear
+    """Async Least Recently Used (LRU) cache decorator."""
+
+    def __init__(self, maxsize: Optional[int] = 128) -> None:
+        self.lru: LRU = LRU(maxsize=maxsize)
+
+    def __call__(self, func: AsyncFunc) -> Callable[..., Coroutine[Any, Any, T]]:
+        @wraps(func)
+        async def wrapper(*args: Any, use_cache: bool = True, **kwargs: Any) -> T:
+            if not use_cache:
+                return await func(*args, **kwargs)
+
+            key: KEY = KEY(args, kwargs)
+
+            if await self.lru.contains(key):
+                return await self.lru.get(key)
+
+            result: T = await func(*args, **kwargs)
+            await self.lru.set(key, result)
+            return result
 
+        wrapper.cache_clear = self.lru.clear  # type: ignore
         return wrapper

cache/async_ttl.py

@@ -1,76 +1,69 @@
-import datetime
+import time
+from functools import wraps
+from typing import Dict, Optional, Tuple, Coroutine
 
-from .key import KEY
 from .lru import LRU
+from .types import T, AsyncFunc, Callable, Any
 
 
-class AsyncTTL:
-    class _TTL(LRU):
-        def __init__(self, time_to_live, maxsize):
-            super().__init__(maxsize=maxsize)
-
-            self.time_to_live = (
-                datetime.timedelta(seconds=time_to_live) if time_to_live else None
-            )
+class TTL(LRU):
+    """Time-To-Live (TTL) cache implementation extending LRU cache."""
 
-            self.maxsize = maxsize
+    def __init__(self, maxsize: Optional[int] = 128, time_to_live: int = 0) -> None:
+        super().__init__(maxsize=maxsize)
+        self.time_to_live: int = time_to_live
+        self.timestamps: Dict[Any, float] = {}
 
-        def __contains__(self, key):
-            if key not in self.keys():
+    async def contains(self, key: Any) -> bool:
+        async with self._lock:
+            exists = await super().contains(key)
+            if not exists:
                 return False
-            else:
-                key_expiration = super().__getitem__(key)[1]
-                if key_expiration and key_expiration < datetime.datetime.now():
-                    del self[key]
+            if self.time_to_live:
+                timestamp: float = self.timestamps.get(key, 0)
+                if time.time() - timestamp > self.time_to_live:
+                    del self.cache[key]
+                    del self.timestamps[key]
                     return False
-                else:
-                    return True
+            return True
 
-        def __getitem__(self, key):
-            value = super().__getitem__(key)[0]
-            return value
+    async def set(self, key: Any, value: Any) -> None:
+        async with self._lock:
+            await super().set(key, value)
+            if self.time_to_live:
+                self.timestamps[key] = time.time()
 
-        def __setitem__(self, key, value):
-            ttl_value = (
-                (datetime.datetime.now() + self.time_to_live)
-                if self.time_to_live
-                else None
-            )
-            super().__setitem__(key, (value, ttl_value))
+    async def clear(self) -> None:
+        async with self._lock:
+            await super().clear()
+            self.timestamps.clear()
 
-    def __init__(self, time_to_live=60, maxsize=1024, skip_args: int = 0):
-        """
 
-        :param time_to_live: Use time_to_live as None for non expiring cache
-        :param maxsize: Use maxsize as None for unlimited size cache
-        :param skip_args: Use `1` to skip first arg of func in determining cache key
-        """
-        self.ttl = self._TTL(time_to_live=time_to_live, maxsize=maxsize)
-        self.skip_args = skip_args
-
-    def cache_clear(self):
-        """
-        Clears the TTL cache.
+class AsyncTTL:
+    """Async Time-To-Live (TTL) cache decorator."""
 
-        This method empties the cache, removing all stored
-        entries and effectively resetting the cache.
+    def __init__(self,
+                 time_to_live: int = 0,
+                 maxsize: Optional[int] = 128,
+                 skip_args: int = 0) -> None:
+        self.ttl: TTL = TTL(maxsize=maxsize, time_to_live=time_to_live)
+        self.skip_args: int = skip_args
 
-        :return: None
-        """
-        self.ttl.clear()
+    def __call__(self, func: AsyncFunc) -> Callable[..., Coroutine[Any, Any, T]]:
+        @wraps(func)
+        async def wrapper(*args: Any, use_cache: bool = True, **kwargs: Any) -> T:
+            if not use_cache:
+                return await func(*args, **kwargs)
 
-    def __call__(self, func):
-        async def wrapper(*args, use_cache=True, **kwargs):
-            key = KEY(args[self.skip_args:], kwargs)
-            if key in self.ttl and use_cache:
-                val = self.ttl[key]
-            else:
-                self.ttl[key] = await func(*args, **kwargs)
-                val = self.ttl[key]
+            key: Tuple[Any, ...] = (*args[self.skip_args:], *sorted(kwargs.items()))
 
-            return val
+            if await self.ttl.contains(key):
+                return await self.ttl.get(key)
 
-        wrapper.__name__ += func.__name__
-        wrapper.__dict__['cache_clear'] = self.cache_clear
+            result: T = await func(*args, **kwargs)
+            await self.ttl.set(key, result)
+            return result
 
+        # Add cache_clear method to the wrapper
+        wrapper.cache_clear = self.ttl.clear  # type: ignore
         return wrapper

cache/key.py

@@ -1,24 +1,31 @@
-from typing import Any
+from typing import Any, Dict, Tuple
+
+from .types import CacheKey
 
 
 class KEY:
-    def __init__(self, *args, **kwargs):
-        self.args = args
-        self.kwargs = kwargs
-        kwargs.pop("use_cache", None)
+    """
+    A hashable key class for cache implementations that handles complex arguments.
+    Supports primitive types, tuples, dictionaries, and objects with __dict__.
+    """
+
+    def __init__(self, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> None:
+        self.args: Tuple[Any, ...] = args
+        self.kwargs: Dict[str, Any] = {k: v for k, v in kwargs.items() if k != "use_cache"}
 
-    def __eq__(self, obj):
-        return hash(self) == hash(obj)
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, KEY):
+            return NotImplemented
+        return hash(self) == hash(other)
 
-    def __hash__(self):
-        def _hash(param: Any):
+    def __hash__(self) -> int:
+        def _hash(param: Any) -> CacheKey:
             if isinstance(param, tuple):
-                return tuple(map(_hash, param))
+                return tuple(_hash(item) for item in param)
             if isinstance(param, dict):
-                return tuple(map(_hash, param.items()))
+                return tuple(sorted((_hash(k), _hash(v)) for k, v in param.items()))
             elif hasattr(param, "__dict__"):
-                return str(vars(param))
-            else:
-                return str(param)
+                return str(sorted(vars(param).items()))
+            return str(param)
 
         return hash(_hash(self.args) + _hash(self.kwargs))

cache/lru.py

@@ -1,19 +1,34 @@
+from asyncio import Lock
 from collections import OrderedDict
-from copy import deepcopy
+from typing import Any, Optional
 
 
-class LRU(OrderedDict):
-    def __init__(self, maxsize, *args, **kwargs):
-        self.maxsize = maxsize
-        super().__init__(*args, **kwargs)
+class LRU:
+    """Thread-safe LRU cache implementation."""
 
-    def __getitem__(self, key):
-        value = deepcopy(super().__getitem__(key))
-        self.move_to_end(key)
-        return value
+    def __init__(self, maxsize: Optional[int] = 128) -> None:
+        self.maxsize: Optional[int] = maxsize
+        self.cache: OrderedDict = OrderedDict()
+        self._lock: Lock = Lock()
 
-    def __setitem__(self, key, value):
-        super().__setitem__(key, deepcopy(value))
-        if self.maxsize and len(self) > self.maxsize:
-            oldest = next(iter(self))
-            del self[oldest]
+    async def contains(self, key: Any) -> bool:
+        async with self._lock:
+            return key in self.cache
+
+    async def get(self, key: Any) -> Any:
+        async with self._lock:
+            value: Any = self.cache.pop(key)
+            self.cache[key] = value
+            return value
+
+    async def set(self, key: Any, value: Any) -> None:
+        async with self._lock:
+            if key in self.cache:
+                self.cache.pop(key)
+            elif self.maxsize and len(self.cache) >= self.maxsize:
+                self.cache.popitem(last=False)
+            self.cache[key] = value
+
+    async def clear(self) -> None:
+        async with self._lock:
+            self.cache.clear()

cache/types.py

@@ -0,0 +1,6 @@
+from typing import TypeVar, Callable, Coroutine, Any, Dict, Tuple, Union
+
+T = TypeVar('T')  # Generic return type
+CacheKey = Union[Tuple[Any, ...], str]
+AsyncFunc = Callable[..., Coroutine[Any, Any, T]]
+CacheDict = Dict[Any, Any]

pyproject.toml

@@ -59,15 +59,27 @@ addopts = """
     --cov-report=term-missing
     --cov-report=xml
     --cov-report=html
+    --timeout=20
     -v
 """
 testpaths = ["tests"]
 python_files = ["*_test.py"]
 asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
 
 [tool.coverage.run]
 branch = true
 source = ["cache"]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if __name__ == .__main__.:",
+    "raise NotImplementedError",
+    "if TYPE_CHECKING:",
+]
+exclude_list = [
+    "tests",
+]
 
 [tool.coverage.report]
 exclude_lines = [

requirements-dev.txt

@@ -3,4 +3,5 @@ pyright==1.1.399
 
 pytest==8.3.5
 pytest-asyncio==0.26.0
-pytest-cov==6.1.1
+pytest-cov==6.1.1
+pytest-timeout==2.3.1