fastapi-cachex 0.1.4__tar.gz → 0.1.6__tar.gz

{fastapi_cachex-0.1.4 → fastapi_cachex-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachex
-Version: 0.1.4
+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.6/README.md

@@ -0,0 +1,142 @@
+# FastAPI-Cache X
+
+[![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/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)
+[![Monthly downloads](https://static.pepy.tech/badge/fastapi-cachex/month)](https://pepy.tech/project/fastapi-cachex)
+
+[![PyPI version](https://img.shields.io/pypi/v/fastapi-cachex.svg?logo=pypi&logoColor=gold&label=PyPI)](https://pypi.org/project/fastapi-cachex)
+[![Python Versions](https://img.shields.io/pypi/pyversions/fastapi-cachex.svg?logo=python&label=Python&logoColor=gold)](https://pypi.org/project/fastapi-cachex/)
+
+[English](README.md) | [繁體中文](docs/README.zh-TW.md)
+
+A high-performance caching extension for FastAPI, providing comprehensive HTTP caching support.
+
+## Features
+
+- Support for HTTP caching headers
+    - `Cache-Control`
+    - `ETag`
+    - `If-None-Match`
+- Multiple backend cache support
+    - Redis
+    - Memcached
+    - In-memory cache
+- 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
+
+```bash
+pip install fastapi-cachex
+```
+
+### Using uv (recommended)
+
+```bash
+uv pip install fastapi-cachex
+```
+
+## Quick Start
+
+```python
+from fastapi import FastAPI
+from fastapi_cachex import cache
+from fastapi_cachex import CacheBackend
+
+app = FastAPI()
+
+
+@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 (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
+from fastapi_cachex import BackendProxy
+
+backend = MemoryBackend()
+BackendProxy.set_backend(backend)
+```
+
+### Memcached
+
+```python
+from fastapi_cachex.backends import MemcachedBackend
+from fastapi_cachex import BackendProxy
+
+backend = MemcachedBackend(servers=["localhost:11211"])
+BackendProxy.set_backend(backend)
+```
+
+### Redis
+
+```python
+from fastapi_cachex.backends import AsyncRedisCacheBackend
+from fastapi_cachex import BackendProxy
+
+backend = AsyncRedisCacheBackend(host="127.0.1", port=6379, db=0)
+BackendProxy.set_backend(backend)
+```
+
+## Documentation
+
+- [Development Guide](docs/DEVELOPMENT.md)
+- [Contributing Guidelines](docs/CONTRIBUTING.md)
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

fastapi_cachex-0.1.6/fastapi_cachex/__init__.py

@@ -0,0 +1,4 @@
+from .cache import cache as cache
+from .dependencies import CacheBackend as CacheBackend
+from .dependencies import get_cache_backend as get_cache_backend
+from .proxy import BackendProxy as BackendProxy

fastapi_cachex-0.1.6/fastapi_cachex/backends/__init__.py

@@ -0,0 +1,11 @@
+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-0.1.4 → fastapi_cachex-0.1.6}/fastapi_cachex/backends/base.py

@@ -25,3 +25,26 @@ class BaseCacheBackend(ABC):
     @abstractmethod
     async def clear(self) -> None:
         """Clear all cached responses."""
+
+    @abstractmethod
+    async def clear_path(self, path: str, include_params: bool = False) -> int:
+        """Clear cached responses for a specific path.
+
+        Args:
+            path: The path to clear cache for
+            include_params: Whether to clear all parameter variations of the path
+
+        Returns:
+            Number of cache entries cleared
+        """
+
+    @abstractmethod
+    async def clear_pattern(self, pattern: str) -> int:
+        """Clear cached responses matching a pattern.
+
+        Args:
+            pattern: A glob pattern to match cache keys against (e.g., "/users/*")
+
+        Returns:
+            Number of cache entries cleared
+        """

{fastapi_cachex-0.1.4 → fastapi_cachex-0.1.6}/fastapi_cachex/backends/memcached.py

@@ -1,4 +1,5 @@
 import ast
+import warnings
 from typing import Optional
 
 from fastapi_cachex.backends.base import BaseCacheBackend
@@ -25,7 +26,7 @@ class MemcachedBackend(BaseCacheBackend):
                 "pymemcache is not installed. Please install it with 'pip install pymemcache'"
             )
 
-        self.client = HashClient(servers)
+        self.client = HashClient(servers, connect_timeout=5, timeout=5)
 
     async def get(self, key: str) -> Optional[ETagContent]:
         """Get value from cache.
@@ -72,3 +73,29 @@ class MemcachedBackend(BaseCacheBackend):
     async def clear(self) -> None:
         """Clear all values from cache."""
         self.client.flush_all()
+
+    async def clear_path(self, path: str, include_params: bool = False) -> int:
+        """Clear cached responses for a specific path."""
+        if include_params:
+            warnings.warn(
+                "Memcached backend does not support pattern-based key clearing. "
+                "The include_params option will have no effect.",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+            return 0
+
+        # If we're not including params, we can just try to delete the exact path
+        if self.client.delete(path, noreply=False):
+            return 1
+        return 0
+
+    async def clear_pattern(self, pattern: str) -> int:  # noqa: ARG002
+        """Clear cached responses matching a pattern."""
+        warnings.warn(
+            "Memcached backend does not support pattern matching. "
+            "Pattern-based cache clearing is not available.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+        return 0

{fastapi_cachex-0.1.4 → fastapi_cachex-0.1.6}/fastapi_cachex/backends/memory.py

@@ -53,6 +53,40 @@ class MemoryBackend(BaseCacheBackend):
         async with self.lock:
             self.cache.clear()
 
+    async def clear_path(self, path: str, include_params: bool = False) -> int:
+        """Clear cached responses for a specific path."""
+        cleared_count = 0
+        async with self.lock:
+            keys_to_delete = []
+            for key in self.cache:
+                cache_path, *params = key.split(":", 1)
+                if cache_path == path and (include_params or not params):
+                    keys_to_delete.append(key)
+                    cleared_count += 1
+
+            for key in keys_to_delete:
+                del self.cache[key]
+
+        return cleared_count
+
+    async def clear_pattern(self, pattern: str) -> int:
+        """Clear cached responses matching a pattern."""
+        import fnmatch
+
+        cleared_count = 0
+        async with self.lock:
+            keys_to_delete = []
+            for key in self.cache:
+                cache_path = key.split(":", 1)[0]  # Get path part only
+                if fnmatch.fnmatch(cache_path, pattern):
+                    keys_to_delete.append(key)
+                    cleared_count += 1
+
+            for key in keys_to_delete:
+                del self.cache[key]
+
+        return cleared_count
+
     async def _cleanup_task_impl(self) -> None:
         try:
             while True:

fastapi_cachex-0.1.6/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.6/fastapi_cachex/dependencies.py

@@ -0,0 +1,14 @@
+from typing import Annotated
+
+from fastapi import Depends
+
+from fastapi_cachex.backends.base import BaseCacheBackend
+from fastapi_cachex.proxy import BackendProxy
+
+
+def get_cache_backend() -> BaseCacheBackend:
+    """Dependency to get the current cache backend instance."""
+    return BackendProxy.get_backend()
+
+
+CacheBackend = Annotated[BaseCacheBackend, Depends(get_cache_backend)]

{fastapi_cachex-0.1.4 → fastapi_cachex-0.1.6}/fastapi_cachex.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachex
-Version: 0.1.4
+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.4 → fastapi_cachex-0.1.6}/fastapi_cachex.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 fastapi_cachex/__init__.py
 fastapi_cachex/cache.py
+fastapi_cachex/dependencies.py
 fastapi_cachex/directives.py
 fastapi_cachex/exceptions.py
 fastapi_cachex/proxy.py
@@ -17,5 +18,7 @@ fastapi_cachex/backends/__init__.py
 fastapi_cachex/backends/base.py
 fastapi_cachex/backends/memcached.py
 fastapi_cachex/backends/memory.py
+fastapi_cachex/backends/redis.py
 tests/test_cache.py
+tests/test_dependencies.py
 tests/test_proxybackend.py

{fastapi_cachex-0.1.4 → fastapi_cachex-0.1.6}/fastapi_cachex.egg-info/requires.txt

@@ -1,5 +1,8 @@
 fastapi
-httpx
 
 [memcache]
 pymemcache
+
+[redis]
+redis[hiredis]
+orjson

{fastapi_cachex-0.1.4 → fastapi_cachex-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-cachex"
-version = "0.1.4" # Initial release version
+version = "0.1.6" # Initial release version
 description = "A caching library for FastAPI with support for Cache-Control, ETag, and multiple backends."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -25,7 +25,6 @@ classifiers = [
 keywords = ["fastapi", "cache", "etag", "cache-control", "redis", "memcached", "in-memory"]
 dependencies = [
     "fastapi",
-    "httpx",
 ]
 
 [project.urls]
@@ -36,25 +35,31 @@ Issues = "https://github.com/allen0099/FastAPI-CacheX/issues"
 [dependency-groups]
 dev = [
     "coverage>=7.8.0",
+    "httpx>=0.28.1",
     "mypy>=1.15.0",
+    "orjson>=3.10.16",
     "pre-commit>=4.2.0",
     "pymemcache>=4.0.0",
     "pytest>=8.3.5",
     "pytest-asyncio>=0.26.0",
     "pytest-cov>=6.1.0",
+    "redis[hiredis]>=5.2.1",
     "ruff>=0.11.2",
     "tox>=4.25.0",
+    "types-orjson>=3.6.2",
+    "types-redis>=4.6.0.20241004",
 ]
 
 [project.optional-dependencies]
 memcache = ["pymemcache"]
+redis = ["redis[hiredis]", "orjson"]
 
 [tool.setuptools]
-package-data = {"fastapi_cachex" = ["py.typed"]}
+package-data = { "fastapi_cachex" = ["py.typed"] }
 
 [tool.pytest.ini_options]
 pythonpath = [
-  "."
+    "."
 ]
 asyncio_default_fixture_loop_scope = "function"
 

fastapi_cachex-0.1.6/tests/test_dependencies.py

@@ -0,0 +1,38 @@
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from fastapi_cachex import BackendProxy
+from fastapi_cachex import CacheBackend
+from fastapi_cachex.backends import MemoryBackend
+from fastapi_cachex.exceptions import BackendNotFoundError
+
+# Setup FastAPI application
+app = FastAPI()
+client = TestClient(app)
+
+
+# Define test endpoint (not a test function)
+@app.get("/test-backend")
+async def backend_endpoint(backend: CacheBackend):
+    return {"backend_type": backend.__class__.__name__}
+
+
+# Actual test functions
+@pytest.mark.asyncio
+async def test_get_cache_backend_no_backend():
+    """Test that get_cache_backend raises BackendNotFoundError when no backend is set."""
+    BackendProxy.set_backend(None)
+    with pytest.raises(BackendNotFoundError):
+        client.get("/test-backend")
+
+
+@pytest.mark.asyncio
+async def test_get_cache_backend_with_memory_backend():
+    """Test that get_cache_backend returns the configured backend."""
+    backend = MemoryBackend()
+    BackendProxy.set_backend(backend)
+
+    response = client.get("/test-backend")
+    assert response.status_code == 200
+    assert response.json() == {"backend_type": "MemoryBackend"}

fastapi_cachex-0.1.4/README.md

@@ -1,105 +0,0 @@
-# FastAPI-Cache X
-
-[![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)
-
-[![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)
-[![Monthly downloads](https://static.pepy.tech/badge/fastapi-cachex/month)](https://pepy.tech/project/fastapi-cachex)
-
-[![PyPI version](https://img.shields.io/pypi/v/fastapi-cachex.svg?logo=pypi&logoColor=gold&label=PyPI)](https://pypi.org/project/fastapi-cachex)
-[![Python Versions](https://img.shields.io/pypi/pyversions/fastapi-cachex.svg?logo=python&label=Python&logoColor=gold)](https://pypi.org/project/fastapi-cachex/)
-
-[English](README.md) | [繁體中文](docs/README.zh-TW.md)
-
-A high-performance caching extension for FastAPI, providing comprehensive HTTP caching support.
-
-## Features
-
-- Support for HTTP caching headers
-    - `Cache-Control`
-    - `ETag`
-    - `If-None-Match`
-- Multiple backend cache support
-    - Redis
-    - Memcached
-    - In-memory cache
-- Complete Cache-Control directive implementation
-- Easy-to-use `@cache` decorator
-
-## Installation
-
-### Using pip
-
-```bash
-pip install fastapi-cachex
-```
-
-### Using uv (recommended)
-
-```bash
-uv pip install fastapi-cachex
-```
-
-## Quick Start
-
-```python
-from fastapi import FastAPI
-from fastapi_cachex import cache, BackendProxy
-from fastapi_cachex.backends import MemoryBackend, MemcachedBackend
-
-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"}
-```
-
-## Backend Configuration
-
-FastAPI-CacheX supports multiple caching backends. You can easily switch between them using the `BackendProxy`.
-
-### In-Memory Cache
-
-```python
-from fastapi_cachex.backends import MemoryBackend
-from fastapi_cachex import BackendProxy
-
-backend = MemoryBackend()
-BackendProxy.set_backend(backend)
-```
-
-### Memcached
-
-```python
-from fastapi_cachex.backends import MemcachedBackend
-from fastapi_cachex import BackendProxy
-
-backend = MemcachedBackend(servers=["localhost:11211"])
-BackendProxy.set_backend(backend)
-```
-
-### Redis (Coming Soon)
-
-Redis support is under development and will be available in future releases.
-
-## Documentation
-
-- [Development Guide](docs/DEVELOPMENT.md)
-- [Contributing Guidelines](docs/CONTRIBUTING.md)
-
-## License
-
-This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

fastapi_cachex-0.1.4/fastapi_cachex/__init__.py

@@ -1,2 +0,0 @@
-from .cache import cache as cache
-from .proxy import BackendProxy as BackendProxy

fastapi_cachex-0.1.4/fastapi_cachex/backends/__init__.py

@@ -1,3 +0,0 @@
-from .base import BaseCacheBackend as BaseCacheBackend
-from .memcached import MemcachedBackend as MemcachedBackend
-from .memory import MemoryBackend as MemoryBackend