fastapi-cachekit 0.1.2__tar.gz → 0.1.3__tar.gz

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachekit
-Version: 0.1.2
+Version: 0.1.3
 Summary: High-performance caching solution for FastAPI applications
 Author-email: Bijay Nayak <bijay6779@gmail.com>
 License-Expression: MIT
@@ -37,12 +37,15 @@ Requires-Dist: aiomcache>=0.8.1; extra == "memcached"
 Requires-Dist: pymemcache>=4.0.0; extra == "memcached"
 Provides-Extra: mongodb
 Requires-Dist: pymongo[gssapi,snappy,srv]>=4.6.0; extra == "mongodb"
+Provides-Extra: firestore
+Requires-Dist: google-cloud-firestore>=2.3.0; extra == "firestore"
 Provides-Extra: all
 Requires-Dist: redis>=4.2.0; extra == "all"
 Requires-Dist: psycopg[pool]>=3.2.9; extra == "all"
 Requires-Dist: aiomcache>=0.8.1; extra == "all"
 Requires-Dist: pymemcache>=4.0.0; extra == "all"
 Requires-Dist: pymongo[gssapi,snappy,srv]>=4.6.0; extra == "all"
+Requires-Dist: google-cloud-firestore>=2.3.0; extra == "all"
 Dynamic: license-file
 
 # fastapi-cachekit
@@ -58,7 +61,7 @@ A high-performance, flexible caching solution for FastAPI applications. fastapi-
 ## Features
 
 - ✅ Full async/sync support for all operations
-- ✅ Redis backend with connection pooling
+- ✅ Multiple backend Support So you can use the same tech stack as your app
 - ✅ Function result caching with decorator syntax
 - ✅ FastAPI dependency injection support
 - ✅ Namespace support for isolating cache entries
@@ -67,13 +70,14 @@ A high-performance, flexible caching solution for FastAPI applications. fastapi-
 - ✅ Expiration time support (seconds or timedelta)
 
 ## 📦 Backends & Sync/Async Support
-
-| Backend            | Sync API | Async API | Install Extra         |
-|--------------------|:--------:|:---------:|----------------------|
-| `InMemoryBackend`  |   ✅     |    ✅     | _built-in_           |
-| `RedisBackend`     |   ✅     |    ✅     | `redis`              |
-| `PostgresBackend`  |   ✅     |    ✅     | `postgres`           |
-| `MemcachedBackend` |   ✅     |    ✅     | `memcached`          |
+| Backend            | Sync API | Async API | Install Extra |
+|--------------------|:--------:|:---------:|---------------|
+| `InMemoryBackend`  |   ✅     |    ✅     | _built-in_    |
+| `RedisBackend`     |   ✅     |    ✅     | `redis`       |
+| `PostgresBackend`  |   ✅     |    ✅     | `postgres`    |
+| `MemcachedBackend` |   ✅     |    ✅     | `memcached`   |
+| `MongoDB`          |   ✅     |    ✅     | `mongodb`     |
+| `FireStore`        |   ✅     |    ✅     | `firestore`   |
 
 ---
 
@@ -98,6 +102,15 @@ pip install fastapi-cachekit[postgres]
 ```bash
 pip install fastapi-cachekit[memcached]
 ```
+**With MongoDB:**
+```bash
+pip install fastapi-cachekit[mongodb]
+```
+
+**With FireStore:**
+```bash
+pip install fastapi-cachekit[firestore]
+```
 
 **All backends:**
 ```bash

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/README.md

@@ -11,7 +11,7 @@ A high-performance, flexible caching solution for FastAPI applications. fastapi-
 ## Features
 
 - ✅ Full async/sync support for all operations
-- ✅ Redis backend with connection pooling
+- ✅ Multiple backend Support So you can use the same tech stack as your app
 - ✅ Function result caching with decorator syntax
 - ✅ FastAPI dependency injection support
 - ✅ Namespace support for isolating cache entries
@@ -20,13 +20,14 @@ A high-performance, flexible caching solution for FastAPI applications. fastapi-
 - ✅ Expiration time support (seconds or timedelta)
 
 ## 📦 Backends & Sync/Async Support
-
-| Backend            | Sync API | Async API | Install Extra         |
-|--------------------|:--------:|:---------:|----------------------|
-| `InMemoryBackend`  |   ✅     |    ✅     | _built-in_           |
-| `RedisBackend`     |   ✅     |    ✅     | `redis`              |
-| `PostgresBackend`  |   ✅     |    ✅     | `postgres`           |
-| `MemcachedBackend` |   ✅     |    ✅     | `memcached`          |
+| Backend            | Sync API | Async API | Install Extra |
+|--------------------|:--------:|:---------:|---------------|
+| `InMemoryBackend`  |   ✅     |    ✅     | _built-in_    |
+| `RedisBackend`     |   ✅     |    ✅     | `redis`       |
+| `PostgresBackend`  |   ✅     |    ✅     | `postgres`    |
+| `MemcachedBackend` |   ✅     |    ✅     | `memcached`   |
+| `MongoDB`          |   ✅     |    ✅     | `mongodb`     |
+| `FireStore`        |   ✅     |    ✅     | `firestore`   |
 
 ---
 
@@ -51,6 +52,15 @@ pip install fastapi-cachekit[postgres]
 ```bash
 pip install fastapi-cachekit[memcached]
 ```
+**With MongoDB:**
+```bash
+pip install fastapi-cachekit[mongodb]
+```
+
+**With FireStore:**
+```bash
+pip install fastapi-cachekit[firestore]
+```
 
 **All backends:**
 ```bash

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/fast_cache/__init__.py

@@ -6,8 +6,19 @@ from .backends.memory import InMemoryBackend
 from .backends.postgres import PostgresBackend
 from .backends.memcached import MemcachedBackend
 from .backends.mongodb import MongoDBBackend
+from .backends.google_firestore import FirestoreBackend
 
-__all__ = ["FastAPICache", "RedisBackend", "CacheBackend", "InMemoryBackend","PostgresBackend", "cache","MemcachedBackend", "MongoDBBackend" ]
+__all__ = [
+    "FastAPICache",
+    "RedisBackend",
+    "CacheBackend",
+    "InMemoryBackend",
+    "PostgresBackend",
+    "cache",
+    "MemcachedBackend",
+    "MongoDBBackend",
+    "FirestoreBackend"
+]
 
 
 # Create global cache instance

fastapi_cachekit-0.1.3/fast_cache/backends/google_firestore.py

@@ -0,0 +1,351 @@
+import asyncio
+import inspect
+import pickle
+import time
+from functools import wraps
+from typing import Any, Optional, Union
+from datetime import timedelta
+
+from .backend import CacheBackend
+
+
+def ensure_cleanup_task(method):
+    @wraps(method)
+    def sync_wrapper(self, *args, **kwargs):
+        self._ensure_cleanup_task()
+        return method(self, *args, **kwargs)
+
+    @wraps(method)
+    async def async_wrapper(self, *args, **kwargs):
+        self._ensure_cleanup_task()
+        return await method(self, *args, **kwargs)
+
+    if inspect.iscoroutinefunction(method):
+        return async_wrapper
+    else:
+        return sync_wrapper
+
+class FirestoreBackend(CacheBackend):
+    """
+    Firebase Firestore cache backend with both sync and async support.
+    Uses a 'expires_at' field for manual expiration checks.
+    """
+
+    def __init__(
+        self,
+        credential_path: Optional[str] = None,
+        namespace: Optional[str] = "fastapi_cache",
+        collection_name: Optional[str] = "cache_entries",
+        cleanup_interval: int = 30,
+        auto_cleanup: bool = True,
+    ) -> None:
+        """
+        Initialize the Firestore backend.
+
+        Args:
+            credential_path (Optional[str]): Path to the Firebase Admin SDK credentials file.
+                                            If None, uses GOOGLE_APPLICATION_CREDENTIALS from env variable.
+            namespace (Optional[str]): Optional prefix for all cache keys. Defaults to "fastapi_cache".
+            collection_name (Optional[str]): Name of the Firestore collection to use. Defaults to "cache_entries".
+        """
+
+        try:
+            from google.oauth2 import service_account
+            from google.cloud import firestore
+            from google.cloud.firestore_v1.async_client import AsyncClient
+            from google.cloud.firestore_v1.client import Client
+        except ImportError:
+            raise ImportError(
+                "FirestoreBackend requires 'google-cloud-firestore'. "
+                "Install with: pip install fastapi-cachekit[firestore]"
+            )
+
+        self._namespace = namespace or "cache"
+        self._collection_name = collection_name or "cache_entries"
+
+        self._cleanup_task = None
+        self._cleanup_interval = cleanup_interval
+        self._auto_cleanup = auto_cleanup
+
+        if credential_path:
+            # Explicitly load credentials from the provided path
+            credentials = service_account.Credentials.from_service_account_file(
+                credential_path
+            )
+            self._sync_db: Client = firestore.Client(credentials=credentials)
+            self._async_db: AsyncClient = firestore.AsyncClient(credentials=credentials)
+        else:
+            # Rely on GOOGLE_APPLICATION_CREDENTIALS
+            self._sync_db: Client = firestore.Client()
+            self._async_db: AsyncClient = firestore.AsyncClient()
+
+    @staticmethod
+    def _compute_expire_at(expire: Optional[Union[int, timedelta]]) -> Optional[int]:
+        if expire is not None:
+            if isinstance(expire, timedelta):
+                return int(time.time() + expire.total_seconds())
+            else:
+                return int(time.time() + expire)
+        return None
+
+    def _make_key(self, key: str) -> str:
+        """
+        Create a namespaced cache key.
+
+        Args:
+            key (str): The original cache key.
+
+        Returns:
+            str: The namespaced cache key.
+        """
+        # Firestore document IDs have limitations, using safe encoding
+        import hashlib
+
+        hashed_key = hashlib.sha256(f"{self._namespace}:{key}".encode()).hexdigest()
+        return hashed_key
+
+    def _is_expired(self, expires_at: Optional[int]) -> bool:
+        """
+        Check if an entry has expired.
+
+        Args:
+            expires_at (Optional[int]): The expiration time in epoch seconds.
+
+        Returns:
+            bool: True if the entry is expired, False otherwise.
+        """
+        return expires_at is not None and expires_at < time.time()
+
+    @ensure_cleanup_task
+    def get(self, key: str) -> Optional[Any]:
+        """
+        Synchronously retrieve a value from the cache.
+
+        Args:
+            key (str): The cache key.
+
+        Returns:
+            Optional[Any]: The cached value, or None if not found or expired.
+        """
+        doc_ref = self._sync_db.collection(self._collection_name).document(
+            self._make_key(key)
+        )
+        doc = doc_ref.get()
+        if doc.exists:
+            data = doc.to_dict()
+            if not self._is_expired(data.get("expires_at")):
+                try:
+                    return pickle.loads(data["value"])
+                except (pickle.UnpicklingError, KeyError):
+                    return None
+        return None
+
+    @ensure_cleanup_task
+    def set(
+        self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
+    ) -> None:
+        """
+        Synchronously set a value in the cache.
+
+        Args:
+            key (str): The cache key.
+            value (Any): The value to cache.
+            expire (Optional[Union[int, timedelta]]): Expiration time in seconds or as timedelta.
+                                                     If None, the entry never expires (or relies on Firestore's max TTL).
+        """
+        doc_ref = self._sync_db.collection(self._collection_name).document(
+            self._make_key(key)
+        )
+        data = {"value": pickle.dumps(value)}
+        exptime = self._compute_expire_at(expire)
+        if exptime is not None:
+            data["expires_at"] = exptime
+
+        doc_ref.set(data)
+
+    def delete(self, key: str) -> None:
+        """
+        Synchronously delete a value from the cache.
+
+        Args:
+            key (str): The cache key.
+        """
+        doc_ref = self._sync_db.collection(self._collection_name).document(
+            self._make_key(key)
+        )
+        doc_ref.delete()
+
+    def clear(self) -> None:
+        """
+        Synchronously clear all values from the namespace.
+        Note: Firestore doesn't have direct namespace-based clearing.
+        This implementation will delete all documents in the collection.
+        Consider adding a query based on a namespaced field if needed.
+        """
+        docs = self._sync_db.collection(self._collection_name).stream()
+        for doc in docs:
+            doc.reference.delete()
+
+    def has(self, key: str) -> bool:
+        """
+        Synchronously check if a key exists in the cache and is not expired.
+
+        Args:
+            key (str): The cache key.
+
+        Returns:
+            bool: True if the key exists and is not expired, False otherwise.
+        """
+        doc_ref = self._sync_db.collection(self._collection_name).document(
+            self._make_key(key)
+        )
+        doc = doc_ref.get()
+        if doc.exists:
+            data = doc.to_dict()
+            return not self._is_expired(data.get("expires_at"))
+        return False
+
+    @ensure_cleanup_task
+    async def aget(self, key: str) -> Optional[Any]:
+        """
+        Asynchronously retrieve a value from the cache.
+
+        Args:
+            key (str): The cache key.
+
+        Returns:
+            Optional[Any]: The cached value, or None if not found or expired.
+        """
+        doc_ref = self._async_db.collection(self._collection_name).document(
+            self._make_key(key)
+        )
+        doc = await doc_ref.get()
+        if doc.exists:
+            data = doc.to_dict()
+            if not self._is_expired(data.get("expires_at")):
+                try:
+                    return pickle.loads(data["value"])
+                except (pickle.UnpicklingError, KeyError):
+                    # Handle potential deserialization errors or missing value field
+                    return None
+        return None
+
+    @ensure_cleanup_task
+    async def aset(
+        self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
+    ) -> None:
+        """
+        Asynchronously set a value in the cache.
+
+        Args:
+            key (str): The cache key.
+            value (Any): The value to cache.
+            expire (Optional[Union[int, timedelta]]): Expiration time in seconds or as timedelta.
+                                                     If None, the entry never expires (or relies on Firestore's max TTL).
+        """
+        doc_ref = self._async_db.collection(self._collection_name).document(
+            self._make_key(key)
+        )
+        data = {"value": pickle.dumps(value)}
+        exptime = self._compute_expire_at(expire)
+
+        if expire is not None:
+            data["expires_at"] = exptime
+
+        await doc_ref.set(data)
+
+    async def adelete(self, key: str) -> None:
+        """
+        Asynchronously delete a value from the cache.
+
+        Args:
+            key (str): The cache key.
+        """
+        doc_ref = self._async_db.collection(self._collection_name).document(
+            self._make_key(key)
+        )
+        await doc_ref.delete()
+
+    async def aclear(self) -> None:
+        """
+        Asynchronously clear all values from the namespace.
+        Note: Firestore doesn't have direct namespace-based clearing.
+        This implementation will delete all documents in the collection.
+        Consider adding a query based on a namespaced field if needed.
+        """
+        docs = self._async_db.collection(self._collection_name).stream()
+        async for doc in docs:
+            await doc.reference.delete()
+
+    async def ahas(self, key: str) -> bool:
+        """
+        Asynchronously check if a key exists in the cache and is not expired.
+
+        Args:
+            key (str): The cache key.
+
+        Returns:
+            bool: True if the key exists and is not expired, False otherwise.
+        """
+        doc_ref = self._async_db.collection(self._collection_name).document(
+            self._make_key(key)
+        )
+        doc = await doc_ref.get()
+        if doc.exists:
+            data = doc.to_dict()
+            return not self._is_expired(data.get("expires_at"))
+        return False
+
+    def close(self) -> None:
+        """
+        Close the synchronous Firestore client.
+        """
+        try:
+            self._sync_db.close()
+        except TypeError as e:
+            return
+
+    async def aclose(self) -> None:
+        """
+        Close the asynchronous Firestore client.
+        """
+        try:
+            await self._async_db.close()
+        except TypeError as e:
+            return
+
+    def _ensure_cleanup_task(self):
+        if (
+            getattr(self, "_auto_cleanup", True)
+            and getattr(self, "_cleanup_task", None) is None
+        ):
+            try:
+                loop = asyncio.get_running_loop()
+                self._cleanup_task = loop.create_task(self.cleanup_expired(self._cleanup_interval))
+            except RuntimeError:
+                pass
+
+    async def cleanup_expired(self, interval_seconds: int = 30):
+        """
+        Periodically delete expired cache entries.
+        Should be run as a background task.
+        Args:
+            interval_seconds (int): How often to run cleanup (default: 1 hour)
+        """
+        while True:
+            now = int(time.time())
+            expired_query = self._async_db.collection(self._collection_name).where(
+                "expires_at", "<", now
+            )
+            batch = self._async_db.batch()
+            count = 0
+            async for doc in expired_query.stream():
+                batch.delete(doc.reference)
+                count += 1
+                if count == 500:
+                    await batch.commit()
+                    batch = self._async_db.batch()
+                    count = 0
+            if count > 0:
+                await batch.commit()
+            await asyncio.sleep(interval_seconds)

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/fast_cache/backends/memcached.py

@@ -3,6 +3,7 @@ from typing import Any, Optional, Union, Mapping
 from datetime import timedelta
 from .backend import CacheBackend
 
+
 class MemcachedBackend(CacheBackend):
     """
     Memcached cache backend with both sync and async support.
@@ -56,8 +57,14 @@ class MemcachedBackend(CacheBackend):
         self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
     ) -> None:
         try:
-            exptime = int(expire.total_seconds()) if isinstance(expire, timedelta) else (expire or 0)
-            self._sync_client.set(self._make_key(key), pickle.dumps(value), expire=exptime)
+            exptime = (
+                int(expire.total_seconds())
+                if isinstance(expire, timedelta)
+                else (expire or 0)
+            )
+            self._sync_client.set(
+                self._make_key(key), pickle.dumps(value), expire=exptime
+            )
         except Exception:
             pass
 
@@ -80,7 +87,6 @@ class MemcachedBackend(CacheBackend):
         except Exception:
             return False
 
-
     async def aget(self, key: str) -> Optional[Any]:
         try:
             value = await self._async_client.get(self._make_key(key))
@@ -92,8 +98,14 @@ class MemcachedBackend(CacheBackend):
         self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
     ) -> None:
         try:
-            exptime = int(expire.total_seconds()) if isinstance(expire, timedelta) else (expire or 0)
-            await self._async_client.set(self._make_key(key), pickle.dumps(value), exptime=exptime)
+            exptime = (
+                int(expire.total_seconds())
+                if isinstance(expire, timedelta)
+                else (expire or 0)
+            )
+            await self._async_client.set(
+                self._make_key(key), pickle.dumps(value), exptime=exptime
+            )
         except Exception:
             pass
 
@@ -103,14 +115,12 @@ class MemcachedBackend(CacheBackend):
         except Exception:
             pass
 
-
     async def aclear(self) -> None:
         try:
             await self._async_client.flush_all()
         except Exception:
             pass
 
-
     async def ahas(self, key: str) -> bool:
         try:
             value = await self._async_client.get(self._make_key(key))
@@ -123,4 +133,4 @@ class MemcachedBackend(CacheBackend):
             await self._async_client.close()
             self._sync_client.close()
         except Exception:
-            pass
+            pass

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/fast_cache/backends/memory.py

@@ -1,16 +1,37 @@
 import asyncio
+import inspect
 import threading
 import time
 from collections import OrderedDict
 from datetime import timedelta
-from typing import Any, Dict, Optional, Union, Tuple
+from functools import wraps
+from typing import Any, Optional, Union, Tuple
 from .backend import CacheBackend
 
+def ensure_cleanup_task(method):
+    """
+    Decorator to ensure the background cleanup task is started
+    on first use of any public method (sync or async).
+    """
+    @wraps(method)
+    def sync_wrapper(self, *args, **kwargs):
+        self._ensure_cleanup_task()
+        return method(self, *args, **kwargs)
+
+    @wraps(method)
+    async def async_wrapper(self, *args, **kwargs):
+        self._ensure_cleanup_task()
+        return await method(self, *args, **kwargs)
+
+    if inspect.iscoroutinefunction(method):
+        return async_wrapper
+    else:
+        return sync_wrapper
 
 class InMemoryBackend(CacheBackend):
     """
-    In-memory cache backend implementation with namespace support,
-    thread/async safety, and efficient expiration cleanup.
+    In-memory cache backend with namespace support, LRU eviction,
+    thread/async safety, and efficient background expiration cleanup.
 
     Attributes:
         _namespace (str): Namespace prefix for all keys.
@@ -89,19 +110,6 @@ class InMemoryBackend(CacheBackend):
             while len(self._cache) > self._max_size:
                 self._cache.popitem(last=False)  # Remove oldest (LRU)
 
-    def _cleanup(self) -> None:
-        """
-        Remove expired items from the cache.
-        """
-        now = time.monotonic()
-        keys_to_delete = [
-            k
-            for k, (_, exp) in list(self._cache.items())
-            if exp is not None and now > exp
-        ]
-        for k in keys_to_delete:
-            self._cache.pop(k, None)
-
     async def _cleanup_expired(self) -> None:
         """
         Periodically clean up expired items in the background.
@@ -109,8 +117,28 @@ class InMemoryBackend(CacheBackend):
         while True:
             await asyncio.sleep(60)
             async with self._async_lock:
-                self._cleanup()
+                now = time.monotonic()
+                keys_to_delete = [
+                    k
+                    for k, (_, exp) in list(self._cache.items())
+                    if exp is not None and now > exp
+                ]
+                for k in keys_to_delete:
+                    self._cache.pop(k, None)
+
+    def _ensure_cleanup_task(self):
+        """
+        Ensure the background cleanup task is started (if in an event loop).
+        """
+        try:
+            loop = asyncio.get_running_loop()
+            if self._cleanup_task is None or self._cleanup_task.done():
+                self._cleanup_task = loop.create_task(self._cleanup_expired())
+        except RuntimeError:
+            # Not in an event loop (sync context), do nothing
+            pass
 
+    @ensure_cleanup_task
     def get(self, key: str) -> Optional[Any]:
         """
         Synchronously retrieve a value from the cache.
@@ -127,12 +155,12 @@ class InMemoryBackend(CacheBackend):
             if item:
                 value, expire_time = item
                 if not self._is_expired(expire_time):
-                    # Move to end for LRU
                     self._cache.move_to_end(k)
                     return value
                 self._cache.pop(k, None)
             return None
 
+    @ensure_cleanup_task
     def set(
         self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
     ) -> None:
@@ -150,8 +178,8 @@ class InMemoryBackend(CacheBackend):
             self._cache[k] = (value, expire_time)
             self._cache.move_to_end(k)
             self._evict_if_needed()
-            self._cleanup()
 
+    @ensure_cleanup_task
     def delete(self, key: str) -> None:
         """
         Synchronously delete a value from the cache.
@@ -163,6 +191,7 @@ class InMemoryBackend(CacheBackend):
         with self._lock:
             self._cache.pop(k, None)
 
+    @ensure_cleanup_task
     def clear(self) -> None:
         """
         Synchronously clear all values from the cache.
@@ -173,6 +202,7 @@ class InMemoryBackend(CacheBackend):
             for k in keys_to_delete:
                 self._cache.pop(k, None)
 
+    @ensure_cleanup_task
     def has(self, key: str) -> bool:
         """
         Synchronously check if a key exists in the cache.
@@ -194,6 +224,7 @@ class InMemoryBackend(CacheBackend):
                 self._cache.pop(k, None)
             return False
 
+    @ensure_cleanup_task
     async def aget(self, key: str) -> Optional[Any]:
         """
         Asynchronously retrieve a value from the cache.
@@ -215,6 +246,7 @@ class InMemoryBackend(CacheBackend):
                 self._cache.pop(k, None)
             return None
 
+    @ensure_cleanup_task
     async def aset(
         self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
     ) -> None:
@@ -232,11 +264,8 @@ class InMemoryBackend(CacheBackend):
             self._cache[k] = (value, expire_time)
             self._cache.move_to_end(k)
             self._evict_if_needed()
-            self._cleanup()
-            # Start cleanup task if not already running
-            if self._cleanup_task is None or self._cleanup_task.done():
-                self._cleanup_task = asyncio.create_task(self._cleanup_expired())
 
+    @ensure_cleanup_task
     async def adelete(self, key: str) -> None:
         """
         Asynchronously delete a value from the cache.
@@ -248,6 +277,7 @@ class InMemoryBackend(CacheBackend):
         async with self._async_lock:
             self._cache.pop(k, None)
 
+    @ensure_cleanup_task
     async def aclear(self) -> None:
         """
         Asynchronously clear all values from the cache.
@@ -258,6 +288,7 @@ class InMemoryBackend(CacheBackend):
             for k in keys_to_delete:
                 self._cache.pop(k, None)
 
+    @ensure_cleanup_task
     async def ahas(self, key: str) -> bool:
         """
         Asynchronously check if a key exists in the cache.
@@ -279,13 +310,9 @@ class InMemoryBackend(CacheBackend):
                 self._cache.pop(k, None)
             return False
 
-    async def close(self) -> None:
+    def close(self) -> None:
         """
-        Asynchronously close the backend and cancel the cleanup task if running.
+        Synchronously close the backend and cancel the cleanup task if running.
         """
         if self._cleanup_task and not self._cleanup_task.done():
             self._cleanup_task.cancel()
-            try:
-                await self._cleanup_task
-            except asyncio.CancelledError:
-                pass

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/fast_cache/backends/mongodb.py

@@ -4,6 +4,7 @@ from typing import Any, Optional, Union
 from datetime import timedelta
 from .backend import CacheBackend
 
+
 class MongoDBBackend(CacheBackend):
     """
     MongoDB cache backend with both sync and async support.
@@ -18,11 +19,7 @@ class MongoDBBackend(CacheBackend):
     but expiration is also checked in code to avoid returning stale data.
     """
 
-    def __init__(
-        self,
-        uri: str,
-        namespace: Optional[str] = "fastapi_cache"
-    ) -> None:
+    def __init__(self, uri: str, namespace: Optional[str] = "fastapi_cache") -> None:
         """
         Initialize the MongoDB backend.
 
@@ -76,14 +73,14 @@ class MongoDBBackend(CacheBackend):
         """
         doc = self._sync_collection.find_one({"_id": self._make_key(key)})
         if doc and (doc.get("expires_at", float("inf")) > time.time()):
-            return pickle.loads(doc["value"])
+            try:
+                return pickle.loads(doc["value"])
+            except Exception:
+                return None
         return None
 
     def set(
-        self,
-        key: str,
-        value: Any,
-        expire: Optional[Union[int, timedelta]] = None
+        self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
     ) -> None:
         """
         Synchronously set a value in the cache.
@@ -95,11 +92,8 @@ class MongoDBBackend(CacheBackend):
                                                      If None, the entry never expires.
         """
         update = {"value": pickle.dumps(value)}
-        if expire is not None:
-            if isinstance(expire, timedelta):
-                exptime = int(time.time() + expire.total_seconds())
-            else:
-                exptime = int(time.time() + expire)
+        exptime = self._compute_expire_at(expire)
+        if exptime is not None:
             update["expires_at"] = exptime
 
         self._sync_collection.update_one(
@@ -146,14 +140,14 @@ class MongoDBBackend(CacheBackend):
         """
         doc = await self._async_collection.find_one({"_id": self._make_key(key)})
         if doc and (doc.get("expires_at", float("inf")) > time.time()):
-            return pickle.loads(doc["value"])
+            try:
+                return pickle.loads(doc["value"])
+            except Exception:
+                return None
         return None
 
     async def aset(
-        self,
-        key: str,
-        value: Any,
-        expire: Optional[Union[int, timedelta]] = None
+        self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
     ) -> None:
         """
         Asynchronously set a value in the cache.
@@ -165,17 +159,12 @@ class MongoDBBackend(CacheBackend):
                                                      If None, the entry never expires.
         """
         update = {"value": pickle.dumps(value)}
-        if expire is not None:
-            if isinstance(expire, timedelta):
-                exptime = int(time.time() + expire.total_seconds())
-            else:
-                exptime = int(time.time() + expire)
+        exptime = self._compute_expire_at(expire)
+        if exptime is not None:
             update["expires_at"] = exptime
 
         await self._async_collection.update_one(
-            {"_id": self._make_key(key)},
-            {"$set": update},
-            upsert=True
+            {"_id": self._make_key(key)}, {"$set": update}, upsert=True
         )
 
     async def adelete(self, key: str) -> None:
@@ -191,7 +180,9 @@ class MongoDBBackend(CacheBackend):
         """
         Asynchronously clear all values from the namespace.
         """
-        await self._async_collection.delete_many({"_id": {"$regex": f"^{self._namespace}:"}})
+        await self._async_collection.delete_many(
+            {"_id": {"$regex": f"^{self._namespace}:"}}
+        )
 
     async def ahas(self, key: str) -> bool:
         """
@@ -217,4 +208,13 @@ class MongoDBBackend(CacheBackend):
         Close the asynchronous MongoDB client.
         """
         self._sync_client.close()
-        await self._async_client.close()
+        await self._async_client.close()
+
+    @staticmethod
+    def _compute_expire_at(expire: Optional[Union[int, timedelta]]) -> Optional[int]:
+        if expire is not None:
+            if isinstance(expire, timedelta):
+                return int(time.time() + expire.total_seconds())
+            else:
+                return int(time.time() + expire)
+        return None

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/fast_cache/backends/postgres.py

@@ -1,6 +1,8 @@
+import asyncio
 import pickle
 import re
 from datetime import datetime, timezone, timedelta
+from functools import wraps
 from typing import Any, Optional, Union
 from .backend import CacheBackend
 
@@ -10,6 +12,24 @@ def _validate_namespace(namespace: str) -> str:
         raise ValueError("Invalid namespace: only alphanumeric and underscore allowed")
     return namespace
 
+
+def ensure_cleanup_task(method):
+    @wraps(method)
+    def sync_wrapper(self, *args, **kwargs):
+        self._ensure_cleanup_task()
+        return method(self, *args, **kwargs)
+
+    @wraps(method)
+    async def async_wrapper(self, *args, **kwargs):
+        self._ensure_cleanup_task()
+        return await method(self, *args, **kwargs)
+
+    import inspect
+    if inspect.iscoroutinefunction(method):
+        return async_wrapper
+    else:
+        return sync_wrapper
+
 class PostgresBackend(CacheBackend):
     """
     PostgreSQL cache backend implementation.
@@ -23,6 +43,8 @@ class PostgresBackend(CacheBackend):
         namespace: str = "fastapi",
         min_size: int = 1,
         max_size: int = 10,
+        cleanup_interval: int = 30,
+        auto_cleanup: bool = True,
     ) -> None:
         try:
             from psycopg_pool import AsyncConnectionPool, ConnectionPool
@@ -45,12 +67,11 @@ class PostgresBackend(CacheBackend):
         )
         self._create_unlogged_table_if_not_exists()
 
-    def _validate_namespace(namespace: str) -> str:
-        if not re.match(r"^[A-Za-z0-9_]+$", namespace):
-            raise ValueError(
-                "Invalid namespace: only alphanumeric and underscore allowed"
-            )
-        return namespace
+        # Lazy cleanup task setup
+        self._cleanup_task = None
+        self._cleanup_interval = cleanup_interval
+        self._auto_cleanup = auto_cleanup
+
 
     def _create_unlogged_table_if_not_exists(self):
         """Create the cache table if it doesn't exist."""
@@ -74,22 +95,13 @@ class PostgresBackend(CacheBackend):
         return f"{self._namespace}:{key}"
 
     def _is_expired(self, expire_at: Optional[datetime]) -> bool:
-        return expire_at is not None and expire_at < datetime.now(
-            timezone.utc
-        )
+        return expire_at is not None and expire_at < datetime.now(timezone.utc)
 
+    @ensure_cleanup_task
     def set(
         self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
     ) -> None:
-        expire_at = None
-        if expire:
-            delta = (
-                timedelta(seconds=expire)
-                if isinstance(expire, int)
-                else expire
-            )
-            expire_at = datetime.now(timezone.utc) + delta
-
+        expire_at = self._compute_expire_at(expire)
         with self._sync_pool.connection() as conn:
             with conn.cursor() as cur:
                 cur.execute(
@@ -104,6 +116,7 @@ class PostgresBackend(CacheBackend):
                 )
                 conn.commit()
 
+    @ensure_cleanup_task
     def get(self, key: str) -> Optional[Any]:
         with self._sync_pool.connection() as conn:
             with conn.cursor() as cur:
@@ -152,22 +165,12 @@ class PostgresBackend(CacheBackend):
                 )
                 conn.commit()
 
+    @ensure_cleanup_task
     async def aset(
         self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
     ) -> None:
-
-        if not self._async_pool._opened:
-            await self._async_pool.open()
-
-        expire_at = None
-        if expire:
-            delta = (
-                timedelta(seconds=expire)
-                if isinstance(expire, int)
-                else expire
-            )
-            expire_at = datetime.now(timezone.utc) + delta
-
+        await self._ensure_async_pool_open()
+        expire_at = self._compute_expire_at(expire)
         async with self._async_pool.connection() as conn:
             async with conn.cursor() as cur:
                 await cur.execute(
@@ -182,9 +185,9 @@ class PostgresBackend(CacheBackend):
                 )
                 await conn.commit()
 
+    @ensure_cleanup_task
     async def aget(self, key: str) -> Optional[Any]:
-        if not self._async_pool._opened:
-            await self._async_pool.open()
+        await self._ensure_async_pool_open()
         async with self._async_pool.connection() as conn:
             async with conn.cursor() as cur:
                 await cur.execute(
@@ -201,8 +204,7 @@ class PostgresBackend(CacheBackend):
                 return pickle.loads(value)
 
     async def adelete(self, key: str) -> None:
-        if not self._async_pool._opened:
-            await self._async_pool.open()
+        await self._ensure_async_pool_open()
         async with self._async_pool.connection() as conn:
             async with conn.cursor() as cur:
                 await cur.execute(
@@ -212,8 +214,7 @@ class PostgresBackend(CacheBackend):
                 await conn.commit()
 
     async def ahas(self, key: str) -> bool:
-        if not self._async_pool._opened:
-            await self._async_pool.open()
+        await self._ensure_async_pool_open()
         async with self._async_pool.connection() as conn:
             async with conn.cursor() as cur:
                 await cur.execute(
@@ -227,8 +228,7 @@ class PostgresBackend(CacheBackend):
 
     async def aclear(self) -> None:
         """Asynchronously clear all keys in the current namespace."""
-        if not self._async_pool._opened:
-            await self._async_pool.open()
+        await self._ensure_async_pool_open()
         async with self._async_pool.connection() as conn:
             async with conn.cursor() as cur:
                 # FIX: Use the dynamic table name
@@ -241,3 +241,37 @@ class PostgresBackend(CacheBackend):
     async def close(self) -> None:
         self._sync_pool.close()
         await self._async_pool.close()
+
+    def _ensure_cleanup_task(self):
+        if self._auto_cleanup and self._cleanup_task is None:
+            try:
+                loop = asyncio.get_running_loop()
+                self._cleanup_task = loop.create_task(
+                    self.cleanup_expired(self._cleanup_interval)
+                )
+            except RuntimeError:
+                pass
+
+    async def cleanup_expired(self, interval_seconds: int = 30):
+        while True:
+            await self._ensure_async_pool_open()
+            async with self._async_pool.connection() as conn:
+                async with conn.cursor() as cur:
+                    await cur.execute(
+                        f"DELETE FROM {self._table_name} WHERE expire_at IS NOT NULL AND expire_at < NOW();"
+                    )
+                    await conn.commit()
+            await asyncio.sleep(interval_seconds)
+
+    @staticmethod
+    def _compute_expire_at(
+        expire: Optional[Union[int, timedelta]],
+    ) -> Optional[datetime]:
+        if expire:
+            delta = timedelta(seconds=expire) if isinstance(expire, int) else expire
+            return datetime.now(timezone.utc) + delta
+        return None
+
+    async def _ensure_async_pool_open(self):
+        if not self._async_pool._opened:
+            await self._async_pool.open()

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/fast_cache/integration.py

@@ -1,3 +1,4 @@
+import asyncio
 from contextlib import asynccontextmanager
 from fastapi import FastAPI
 from typing import Optional, Callable, Union, AsyncIterator, Any
@@ -176,9 +177,21 @@ class FastAPICache:
         if not hasattr(app, "state"):
             app.state = {}
         app.state["cache"] = self
-        yield
-        self._backend = None
-        self._app = None
+
+        try:
+            yield
+        finally:
+            if self._backend:
+                close = getattr(self._backend, "aclose", None)
+                if close:
+                    await close()
+                else:
+                    close = getattr(self._backend, "close", None)
+                    if close:
+                        close()
+
+            self._backend = None
+            self._app = None
 
     def init_app(
         self,

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/fastapi_cachekit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachekit
-Version: 0.1.2
+Version: 0.1.3
 Summary: High-performance caching solution for FastAPI applications
 Author-email: Bijay Nayak <bijay6779@gmail.com>
 License-Expression: MIT
@@ -37,12 +37,15 @@ Requires-Dist: aiomcache>=0.8.1; extra == "memcached"
 Requires-Dist: pymemcache>=4.0.0; extra == "memcached"
 Provides-Extra: mongodb
 Requires-Dist: pymongo[gssapi,snappy,srv]>=4.6.0; extra == "mongodb"
+Provides-Extra: firestore
+Requires-Dist: google-cloud-firestore>=2.3.0; extra == "firestore"
 Provides-Extra: all
 Requires-Dist: redis>=4.2.0; extra == "all"
 Requires-Dist: psycopg[pool]>=3.2.9; extra == "all"
 Requires-Dist: aiomcache>=0.8.1; extra == "all"
 Requires-Dist: pymemcache>=4.0.0; extra == "all"
 Requires-Dist: pymongo[gssapi,snappy,srv]>=4.6.0; extra == "all"
+Requires-Dist: google-cloud-firestore>=2.3.0; extra == "all"
 Dynamic: license-file
 
 # fastapi-cachekit
@@ -58,7 +61,7 @@ A high-performance, flexible caching solution for FastAPI applications. fastapi-
 ## Features
 
 - ✅ Full async/sync support for all operations
-- ✅ Redis backend with connection pooling
+- ✅ Multiple backend Support So you can use the same tech stack as your app
 - ✅ Function result caching with decorator syntax
 - ✅ FastAPI dependency injection support
 - ✅ Namespace support for isolating cache entries
@@ -67,13 +70,14 @@ A high-performance, flexible caching solution for FastAPI applications. fastapi-
 - ✅ Expiration time support (seconds or timedelta)
 
 ## 📦 Backends & Sync/Async Support
-
-| Backend            | Sync API | Async API | Install Extra         |
-|--------------------|:--------:|:---------:|----------------------|
-| `InMemoryBackend`  |   ✅     |    ✅     | _built-in_           |
-| `RedisBackend`     |   ✅     |    ✅     | `redis`              |
-| `PostgresBackend`  |   ✅     |    ✅     | `postgres`           |
-| `MemcachedBackend` |   ✅     |    ✅     | `memcached`          |
+| Backend            | Sync API | Async API | Install Extra |
+|--------------------|:--------:|:---------:|---------------|
+| `InMemoryBackend`  |   ✅     |    ✅     | _built-in_    |
+| `RedisBackend`     |   ✅     |    ✅     | `redis`       |
+| `PostgresBackend`  |   ✅     |    ✅     | `postgres`    |
+| `MemcachedBackend` |   ✅     |    ✅     | `memcached`   |
+| `MongoDB`          |   ✅     |    ✅     | `mongodb`     |
+| `FireStore`        |   ✅     |    ✅     | `firestore`   |
 
 ---
 
@@ -98,6 +102,15 @@ pip install fastapi-cachekit[postgres]
 ```bash
 pip install fastapi-cachekit[memcached]
 ```
+**With MongoDB:**
+```bash
+pip install fastapi-cachekit[mongodb]
+```
+
+**With FireStore:**
+```bash
+pip install fastapi-cachekit[firestore]
+```
 
 **All backends:**
 ```bash

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/fastapi_cachekit.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ fast_cache/__init__.py
 fast_cache/integration.py
 fast_cache/backends/__init__.py
 fast_cache/backends/backend.py
+fast_cache/backends/google_firestore.py
 fast_cache/backends/memcached.py
 fast_cache/backends/memory.py
 fast_cache/backends/mongodb.py

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/fastapi_cachekit.egg-info/requires.txt

@@ -6,6 +6,10 @@ psycopg[pool]>=3.2.9
 aiomcache>=0.8.1
 pymemcache>=4.0.0
 pymongo[gssapi,snappy,srv]>=4.6.0
+google-cloud-firestore>=2.3.0
+
+[firestore]
+google-cloud-firestore>=2.3.0
 
 [memcached]
 aiomcache>=0.8.1

{fastapi_cachekit-0.1.2 → fastapi_cachekit-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-cachekit"
-version = "0.1.2"
+version = "0.1.3"
 description = "High-performance caching solution for FastAPI applications"
 readme = "README.md"
 license = "MIT"
@@ -66,12 +66,16 @@ memcached = [
 mongodb = [
     "pymongo[snappy,gssapi,srv]>=4.6.0"
 ]
+firestore = [
+    'google-cloud-firestore>=2.3.0'
+]
 all = [
     "redis>=4.2.0",
     "psycopg[pool]>=3.2.9",
     "aiomcache>=0.8.1",
     "pymemcache>=4.0.0",
-    "pymongo[snappy,gssapi,srv]>=4.6.0"
+    "pymongo[snappy,gssapi,srv]>=4.6.0",
+    'google-cloud-firestore>=2.3.0'
 ]
 
 [dependency-groups]