rust-py-cache 0.2.0__tar.gz → 0.2.1__tar.gz

rust_py_cache-0.2.1/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+Todas as mudanças relevantes deste projeto são registradas aqui.
+
+O formato segue [Keep a Changelog](https://keepachangelog.com/pt-BR/1.1.0/),
+e o versionamento segue [SemVer](https://semver.org/lang/pt-BR/).
+
+## [0.2.1] - 2026-08-11
+
+### Corrigido
+
+- `@cache.cached` sobre função `async def` guardava no cache o objeto coroutine
+  em vez do resultado do `await`, quebrando o decorator já na primeira chamada
+  com `TypeError: cannot pickle 'coroutine' object`. O decorator agora detecta
+  `inspect.iscoroutinefunction` e gera um wrapper `async` que faz o `await`
+  antes do `set`. (BACKLOG2 P0-2)
+
+## [0.2.0]
+
+### Adicionado
+
+- Expiração em background via `Sweeper` (thread dedicada com `Weak<T>`,
+  encerramento limpo no `Drop`).
+- Evicção por `max_size` com política LRU.
+- Exemplos para FastAPI e Django.
+
+## [0.1.x]
+
+### Adicionado
+
+- `Cache` com `set` / `get(default=...)` / `delete` / `exists` / `keys` /
+  `len` / `clear` / `cleanup_expired` / `stats`.
+- TTL por entrada com expiração preguiçosa.
+- `stats()` cumulativo baseado em `AtomicU64`.
+- Decorator de memoização `@cache.cached(ttl=..., key=...)`.
+- Core em Rust sobre `DashMap`, valores serializados com `pickle`.

{rust_py_cache-0.2.0 → rust_py_cache-0.2.1}/Cargo.lock

@@ -202,7 +202,7 @@ dependencies = [
 
 [[package]]
 name = "rust_py_cache"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "dashmap",
  "pyo3",

{rust_py_cache-0.2.0 → rust_py_cache-0.2.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rust_py_cache"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 readme = "README.md"
 

{rust_py_cache-0.2.0 → rust_py_cache-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rust-py-cache
-Version: 0.2.0
+Version: 0.2.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython

{rust_py_cache-0.2.0 → rust_py_cache-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rust-py-cache"
-version = "0.2.0"
+version = "0.2.1"
 description = "An ultra-fast local cache for Python, powered by Rust."
 readme = "README.md"
 requires-python = ">=3.10"

{rust_py_cache-0.2.0 → rust_py_cache-0.2.1}/python/rust_py_cache/__init__.py

@@ -19,4 +19,4 @@ class Cache(_RustCache):
 
 
 __all__ = ["Cache", "hello"]
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{rust_py_cache-0.2.0 → rust_py_cache-0.2.1}/python/rust_py_cache/decorators.py

@@ -6,6 +6,7 @@ chave e `functools.wraps` — tudo muito mais natural aqui.
 """
 
 import functools
+import inspect
 
 # Sentinela para distinguir "ausente no cache" de "valor None legítimo".
 # `cache.get(key, _MISSING)` devolve `_MISSING` só quando a chave não existe.
@@ -37,25 +38,52 @@ def cached(self, ttl=None, key=None):
         @cache.cached(ttl=60)
         def soma(a, b):
             return a + b
+
+        @cache.cached(ttl=60)
+        async def busca(id):
+            return await api.get(id)
+
+    Funções `async def` são detectadas e recebem um wrapper `async`, que guarda
+    no cache o resultado do `await` — não o objeto coroutine. Cachear a coroutine
+    faria a segunda chamada levantar `RuntimeError: cannot reuse already awaited
+    coroutine`.
     """
 
+    def _resolve_key(func, args, kwargs):
+        if key is None:
+            return _default_key(func, args, kwargs)
+        if callable(key):
+            return key(*args, **kwargs)
+        return key
+
     def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            if key is None:
-                cache_key = _default_key(func, args, kwargs)
-            elif callable(key):
-                cache_key = key(*args, **kwargs)
-            else:
-                cache_key = key
-
-            hit = self.get(cache_key, _MISSING)
-            if hit is not _MISSING:
-                return hit
-
-            result = func(*args, **kwargs)
-            self.set(cache_key, result, ttl=ttl)
-            return result
+        if inspect.iscoroutinefunction(func):
+
+            @functools.wraps(func)
+            async def wrapper(*args, **kwargs):
+                cache_key = _resolve_key(func, args, kwargs)
+
+                hit = self.get(cache_key, _MISSING)
+                if hit is not _MISSING:
+                    return hit
+
+                result = await func(*args, **kwargs)
+                self.set(cache_key, result, ttl=ttl)
+                return result
+
+        else:
+
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                cache_key = _resolve_key(func, args, kwargs)
+
+                hit = self.get(cache_key, _MISSING)
+                if hit is not _MISSING:
+                    return hit
+
+                result = func(*args, **kwargs)
+                self.set(cache_key, result, ttl=ttl)
+                return result
 
         # Expõe a chave-base para inspeção/invalidação manual em testes.
         wrapper.__wrapped__ = func

{rust_py_cache-0.2.0 → rust_py_cache-0.2.1}/tests/test_features.py

@@ -1,5 +1,6 @@
 """Testes de exists/keys/stats/cleanup_expired/clear e decorator — Etapas 8-17."""
 
+import asyncio
 import time
 
 from rust_py_cache import Cache
@@ -110,3 +111,63 @@ def test_decorator_caches_none_result():
     assert returns_none() is None
     assert returns_none() is None
     assert calls["n"] == 1  # None foi cacheado, não recomputou
+
+
+def test_decorator_caches_async_function():
+    """P0-2: `@cached` sobre `async def` deve cachear o RESULTADO do await.
+
+    Antes da correção, o wrapper síncrono guardava o objeto coroutine: a
+    primeira chamada devolvia o valor certo e a segunda levantava
+    `RuntimeError: cannot reuse already awaited coroutine`.
+    """
+    cache = Cache()
+    calls = {"n": 0}
+
+    @cache.cached(ttl=60)
+    async def busca(x):
+        calls["n"] += 1
+        return x * 2
+
+    async def cenario():
+        # Duas chamadas no mesmo event loop — é aqui que o bug aparecia.
+        primeira = await busca(21)
+        segunda = await busca(21)
+        terceira = await busca(10)  # args diferentes -> recomputa
+        return primeira, segunda, terceira
+
+    primeira, segunda, terceira = asyncio.run(cenario())
+
+    assert primeira == 42
+    assert segunda == 42
+    assert terceira == 20
+    assert calls["n"] == 2  # busca(21) rodou uma vez só
+
+
+def test_decorator_async_keeps_coroutine_function():
+    """O wrapper de uma `async def` continua sendo uma coroutine function."""
+    cache = Cache()
+
+    @cache.cached()
+    async def f():
+        return 1
+
+    assert asyncio.iscoroutinefunction(f)
+    assert f.__name__ == "f"
+
+
+def test_decorator_async_caches_none_result():
+    cache = Cache()
+    calls = {"n": 0}
+
+    @cache.cached()
+    async def returns_none():
+        calls["n"] += 1
+        return None
+
+    async def cenario():
+        return await returns_none(), await returns_none()
+
+    a, b = asyncio.run(cenario())
+    assert a is None
+    assert b is None
+    assert calls["n"] == 1