fastapi-cachex 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

fastapi_cachex/backends/__init__.py

@@ -1,3 +1,11 @@
-from .base import BaseCacheBackend as BaseCacheBackend
-from .memcached import MemcachedBackend as MemcachedBackend
-from .memory import MemoryBackend as MemoryBackend
+from fastapi_cachex.backends.base import BaseCacheBackend
+from fastapi_cachex.backends.memcached import MemcachedBackend
+from fastapi_cachex.backends.memory import MemoryBackend
+from fastapi_cachex.backends.redis import AsyncRedisCacheBackend
+
+__all__ = [
+    "AsyncRedisCacheBackend",
+    "BaseCacheBackend",
+    "MemcachedBackend",
+    "MemoryBackend",
+]

fastapi_cachex/backends/redis.py

@@ -0,0 +1,137 @@
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Literal
+from typing import Optional
+
+from fastapi_cachex.backends.base import BaseCacheBackend
+from fastapi_cachex.exceptions import CacheXError
+from fastapi_cachex.types import ETagContent
+
+if TYPE_CHECKING:
+    from redis.asyncio import Redis as AsyncRedis
+
+try:
+    import orjson as json
+
+except ImportError:  # pragma: no cover
+    import json  # type: ignore[no-redef]
+
+
+class AsyncRedisCacheBackend(BaseCacheBackend):
+    """Async Redis cache backend implementation."""
+
+    client: "AsyncRedis[str]"
+
+    def __init__(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 6379,
+        password: Optional[str] = None,
+        db: int = 0,
+        encoding: str = "utf-8",
+        decode_responses: Literal[True] = True,
+        socket_timeout: float = 1.0,
+        socket_connect_timeout: float = 1.0,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize async Redis cache backend.
+
+        Args:
+            host: Redis host
+            port: Redis port
+            password: Redis password
+            db: Redis database number
+            encoding: Character encoding to use
+            decode_responses: Whether to decode response automatically
+            socket_timeout: Timeout for socket operations (in seconds)
+            socket_connect_timeout: Timeout for socket connection (in seconds)
+            **kwargs: Additional arguments to pass to Redis client
+        """
+        try:
+            from redis.asyncio import Redis as AsyncRedis
+        except ImportError:
+            raise CacheXError(
+                "redis[hiredis] is not installed. Please install it with 'pip install \"redis[hiredis]\"'"
+            )
+
+        self.client = AsyncRedis(
+            host=host,
+            port=port,
+            password=password,
+            db=db,
+            encoding=encoding,
+            decode_responses=decode_responses,
+            socket_timeout=socket_timeout,
+            socket_connect_timeout=socket_connect_timeout,
+            **kwargs,
+        )
+
+    def _serialize(self, value: ETagContent) -> str:
+        """Serialize ETagContent to JSON string."""
+        serialized = json.dumps(
+            {
+                "etag": value.etag,
+                "content": value.content.decode()
+                if isinstance(value.content, bytes)
+                else value.content,
+            }
+        )
+
+        if isinstance(serialized, bytes):
+            # If using orjson, it returns bytes
+            return serialized.decode()
+
+        return serialized  # type: ignore[unreachable]
+
+    def _deserialize(self, value: Optional[str]) -> Optional[ETagContent]:
+        """Deserialize JSON string to ETagContent."""
+        if value is None:
+            return None
+        try:
+            data = json.loads(value)
+            return ETagContent(
+                etag=data["etag"],
+                content=data["content"].encode()
+                if isinstance(data["content"], str)
+                else data["content"],
+            )
+        except (json.JSONDecodeError, KeyError):
+            return None
+
+    async def get(self, key: str) -> Optional[ETagContent]:
+        """Retrieve a cached response."""
+        result = await self.client.get(key)
+        return self._deserialize(result)
+
+    async def set(
+        self, key: str, value: ETagContent, ttl: Optional[int] = None
+    ) -> None:
+        """Store a response in the cache."""
+        serialized = self._serialize(value)
+        if ttl is not None:
+            await self.client.setex(key, ttl, serialized)
+        else:
+            await self.client.set(key, serialized)
+
+    async def delete(self, key: str) -> None:
+        """Remove a response from the cache."""
+        await self.client.delete(key)
+
+    async def clear(self) -> None:
+        """Clear all cached responses."""
+        await self.client.flushdb()
+
+    async def clear_path(self, path: str, include_params: bool = False) -> int:
+        """Clear cached responses for a specific path."""
+        pattern = f"{path}*" if include_params else path
+        keys = await self.client.keys(pattern)
+        if keys:
+            return await self.client.delete(*keys)
+        return 0
+
+    async def clear_pattern(self, pattern: str) -> int:
+        """Clear cached responses matching a pattern."""
+        keys = await self.client.keys(pattern)
+        if keys:
+            return await self.client.delete(*keys)
+        return 0

{fastapi_cachex-0.1.5.dist-info → fastapi_cachex-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachex
-Version: 0.1.5
+Version: 0.1.6
 Summary: A caching library for FastAPI with support for Cache-Control, ETag, and multiple backends.
 Author-email: Allen <s96016641@gmail.com>
 License-Expression: Apache-2.0
@@ -24,9 +24,11 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastapi
-Requires-Dist: httpx
 Provides-Extra: memcache
 Requires-Dist: pymemcache; extra == "memcache"
+Provides-Extra: redis
+Requires-Dist: redis[hiredis]; extra == "redis"
+Requires-Dist: orjson; extra == "redis"
 Dynamic: license-file
 
 # FastAPI-Cache X
@@ -34,7 +36,7 @@ Dynamic: license-file
 [![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![Tests](https://github.com/allen0099/FastAPI-CacheX/actions/workflows/test.yml/badge.svg)](https://github.com/allen0099/FastAPI-CacheX/actions/workflows/test.yml)
-[![Coverage Status](https://raw.githubusercontent.com/allen0099/FastAPI-CacheX/coverage-badge/coverage.svg)](https://github.com/allen0099/FastAPI-CacheX/actions/workflows/test.yml)
+[![Coverage Status](https://raw.githubusercontent.com/allen0099/FastAPI-CacheX/coverage-badge/coverage.svg)](https://github.com/allen0099/FastAPI-CacheX/actions/workflows/coverage.yml)
 
 [![Downloads](https://static.pepy.tech/badge/fastapi-cachex)](https://pepy.tech/project/fastapi-cachex)
 [![Weekly downloads](https://static.pepy.tech/badge/fastapi-cachex/week)](https://pepy.tech/project/fastapi-cachex)
@@ -60,6 +62,24 @@ A high-performance caching extension for FastAPI, providing comprehensive HTTP c
 - Complete Cache-Control directive implementation
 - Easy-to-use `@cache` decorator
 
+### Cache-Control Directives
+
+| Directive                | Supported          | Description                                                                                             |
+|--------------------------|--------------------|---------------------------------------------------------------------------------------------------------|
+| `max-age`                | :white_check_mark: | Specifies the maximum amount of time a resource is considered fresh.                                    |
+| `s-maxage`               | :x:                | Specifies the maximum amount of time a resource is considered fresh for shared caches.                  |
+| `no-cache`               | :white_check_mark: | Forces caches to submit the request to the origin server for validation before releasing a cached copy. |
+| `no-store`               | :white_check_mark: | Instructs caches not to store any part of the request or response.                                      |
+| `no-transform`           | :x:                | Instructs caches not to transform the response content.                                                 |
+| `must-revalidate`        | :white_check_mark: | Forces caches to revalidate the response with the origin server after it becomes stale.                 |
+| `proxy-revalidate`       | :x:                | Similar to `must-revalidate`, but only for shared caches.                                               |
+| `must-understand`        | :x:                | Indicates that the recipient must understand the directive or treat it as an error.                     |
+| `private`                | :white_check_mark: | Indicates that the response is intended for a single user and should not be stored by shared caches.    |
+| `public`                 | :white_check_mark: | Indicates that the response may be cached by any cache, even if it is normally non-cacheable.           |
+| `immutable`              | :white_check_mark: | Indicates that the response body will not change over time, allowing for longer caching.                |
+| `stale-while-revalidate` | :white_check_mark: | Indicates that a cache can serve a stale response while it revalidates the response in the background.  |
+| `stale-if-error`         | :white_check_mark: | Indicates that a cache can serve a stale response if the origin server is unavailable.                  |
+
 ## Installation
 
 ### Using pip
@@ -78,31 +98,44 @@ uv pip install fastapi-cachex
 
 ```python
 from fastapi import FastAPI
-from fastapi_cachex import cache, BackendProxy
-from fastapi_cachex.backends import MemoryBackend, MemcachedBackend
+from fastapi_cachex import cache
+from fastapi_cachex import CacheBackend
 
 app = FastAPI()
 
-# Configure your cache backend
-memory_backend = MemoryBackend()  # In-memory cache
-# or
-memcached_backend = MemcachedBackend(servers=["localhost:11211"])  # Memcached
-
-# Set the backend you want to use
-BackendProxy.set_backend(memory_backend)  # or memcached_backend
-
 
 @app.get("/")
 @cache(ttl=60)  # Cache for 60 seconds
 async def read_root():
     return {"Hello": "World"}
+
+
+@app.get("/no-cache")
+@cache(no_cache=True)  # Mark this endpoint as non-cacheable
+async def non_cache_endpoint():
+    return {"Hello": "World"}
+
+
+@app.get("/no-store")
+@cache(no_store=True)  # Mark this endpoint as non-cacheable
+async def non_store_endpoint():
+    return {"Hello": "World"}
+
+
+@app.get("/clear_cache")
+async def remove_cache(cache: CacheBackend):
+    await cache.clear_path("/path/to/clear")  # Clear cache for a specific path
+    await cache.clear_pattern("/path/to/clear/*")  # Clear cache for a specific pattern
 ```
 
 ## Backend Configuration
 
 FastAPI-CacheX supports multiple caching backends. You can easily switch between them using the `BackendProxy`.
 
-### In-Memory Cache
+### In-Memory Cache (default)
+
+If you don't specify a backend, FastAPI-CacheX will use the in-memory cache by default.
+This is suitable for development and testing purposes.
 
 ```python
 from fastapi_cachex.backends import MemoryBackend
@@ -122,9 +155,15 @@ backend = MemcachedBackend(servers=["localhost:11211"])
 BackendProxy.set_backend(backend)
 ```
 
-### Redis (Coming Soon)
+### Redis
+
+```python
+from fastapi_cachex.backends import AsyncRedisCacheBackend
+from fastapi_cachex import BackendProxy
 
-Redis support is under development and will be available in future releases.
+backend = AsyncRedisCacheBackend(host="127.0.1", port=6379, db=0)
+BackendProxy.set_backend(backend)
+```
 
 ## Documentation
 

{fastapi_cachex-0.1.5.dist-info → fastapi_cachex-0.1.6.dist-info}/RECORD

@@ -6,12 +6,13 @@ fastapi_cachex/exceptions.py,sha256=coYct4u6uK_pdjetUWDwM5OUCfhql0OkTECynMRUq4M,
 fastapi_cachex/proxy.py,sha256=vFShY7_xp4Sh1XU9dJzsBv2ICN8Rtwx6g1qCcCvmdf8,810
 fastapi_cachex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastapi_cachex/types.py,sha256=YkXlBARIr5lHQE4PYQrwXjEoLHdz9CIjfX7V-S9N8p0,328
-fastapi_cachex/backends/__init__.py,sha256=U65JrCeh1eusklqUfV5yvZGK7Kfy5RctzfVrRfFPuaI,166
+fastapi_cachex/backends/__init__.py,sha256=KJHzYs2NZLl-LDAz-VIynaDhZ8XCXKrcnVG-j3sYMRI,357
 fastapi_cachex/backends/base.py,sha256=oBoHUaejZNQ_ex1n1YrpUP4CU94w2TbsXd6qau0F_T8,1383
 fastapi_cachex/backends/memcached.py,sha256=vy7isgu2qW2odBPTl8Q8ulqUo36KIsnZ3YVCr3sflfc,3211
 fastapi_cachex/backends/memory.py,sha256=4TBdvxnjMY0BnN1Gjr93rJllWJjU055RxG12QJixrrM,3611
-fastapi_cachex-0.1.5.dist-info/licenses/LICENSE,sha256=asJkHbd10YDSnjeAOIlKafh7E_exwtKXY5rA-qc_Mno,11339
-fastapi_cachex-0.1.5.dist-info/METADATA,sha256=OoxnkzzbW8iLikvibtF0Oud0xEUPwZDx9XIGMVNqmLM,4669
-fastapi_cachex-0.1.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-fastapi_cachex-0.1.5.dist-info/top_level.txt,sha256=97FfG5FDycd3hks-_JznEr-5lUOgg8AZd8pqK5imWj0,15
-fastapi_cachex-0.1.5.dist-info/RECORD,,
+fastapi_cachex/backends/redis.py,sha256=bCfF0GHBaLXkfQiwciaAtZFD0fWCcv0wNihuDGzdtUI,4489
+fastapi_cachex-0.1.6.dist-info/licenses/LICENSE,sha256=asJkHbd10YDSnjeAOIlKafh7E_exwtKXY5rA-qc_Mno,11339
+fastapi_cachex-0.1.6.dist-info/METADATA,sha256=6f_-B8g8b6DoEWK-GXNoGjQ5cWplWw59wTw9AQyjqZE,7634
+fastapi_cachex-0.1.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+fastapi_cachex-0.1.6.dist-info/top_level.txt,sha256=97FfG5FDycd3hks-_JznEr-5lUOgg8AZd8pqK5imWj0,15
+fastapi_cachex-0.1.6.dist-info/RECORD,,