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

fastapi_cachex/__init__.py

@@ -1,2 +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/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/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/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/cache.py

@@ -120,6 +120,43 @@ def cache(  # noqa: C901
         else:
             request_name = found_request.name
 
+        async def get_cache_control(cache_control: CacheControl) -> str:  # noqa: C901
+            # Set Cache-Control headers
+            if no_cache:
+                cache_control.add(DirectiveType.NO_CACHE)
+                if must_revalidate:
+                    cache_control.add(DirectiveType.MUST_REVALIDATE)
+            else:
+                # Handle normal cache control cases
+                # 1. Access scope (public/private)
+                if public:
+                    cache_control.add(DirectiveType.PUBLIC)
+                elif private:
+                    cache_control.add(DirectiveType.PRIVATE)
+
+                # 2. Cache time settings
+                if ttl is not None:
+                    cache_control.add(DirectiveType.MAX_AGE, ttl)
+
+                # 3. Validation related
+                if must_revalidate:
+                    cache_control.add(DirectiveType.MUST_REVALIDATE)
+
+                # 4. Stale response handling
+                if stale is not None and stale_ttl is None:
+                    raise CacheXError("stale_ttl must be set if stale is used")
+
+                if stale == "revalidate":
+                    cache_control.add(DirectiveType.STALE_WHILE_REVALIDATE, stale_ttl)
+                elif stale == "error":
+                    cache_control.add(DirectiveType.STALE_IF_ERROR, stale_ttl)
+
+                # 5. Special flags
+                if immutable:
+                    cache_control.add(DirectiveType.IMMUTABLE)
+
+            return str(cache_control)
+
         @wraps(func)
         async def wrapper(*args: Any, **kwargs: Any) -> Response:  # noqa: C901
             if found_request:
@@ -135,79 +172,72 @@ def cache(  # noqa: C901
             if req.method != "GET":
                 return await get_response(func, req, *args, **kwargs)
 
-            # Generate cache key
+            # Generate cache key and prepare headers
             cache_key = f"{req.url.path}:{req.query_params}"
-
-            # Check if the data is already in the cache
-            cached_data = await cache_backend.get(cache_key)
-
-            if cached_data and cached_data.etag == req.headers.get("if-none-match"):
-                return Response(
-                    status_code=HTTP_304_NOT_MODIFIED,
-                    headers={"ETag": cached_data.etag},
-                )
-
-            # Get the response
-            response = await get_response(func, req, *args, **kwargs)
-
-            # Generate ETag (hash based on response content)
-            etag = f'W/"{hashlib.md5(response.body).hexdigest()}"'  # noqa: S324
-
-            # Add ETag to response headers
-            response.headers["ETag"] = etag
-
-            # Handle Cache-Control header
-            cache_control = CacheControl()
+            client_etag = req.headers.get("if-none-match")
+            cache_control = await get_cache_control(CacheControl())
 
             # Handle special case: no-store (highest priority)
             if no_store:
-                cache_control.add(DirectiveType.NO_STORE)
-                response.headers["Cache-Control"] = str(cache_control)
+                response = await get_response(func, req, *args, **kwargs)
+                cc = CacheControl()
+                cc.add(DirectiveType.NO_STORE)
+                response.headers["Cache-Control"] = str(cc)
                 return response
 
-            # Handle special case: no-cache
-            if no_cache:
-                cache_control.add(DirectiveType.NO_CACHE)
-                if must_revalidate:
-                    cache_control.add(DirectiveType.MUST_REVALIDATE)
-                response.headers["Cache-Control"] = str(cache_control)
-                return response
+            # Check cache and handle ETag validation
+            cached_data = await cache_backend.get(cache_key)
 
-            # Handle normal cache control cases
-            # 1. Access scope (public/private)
-            if public:
-                cache_control.add(DirectiveType.PUBLIC)
-            elif private:
-                cache_control.add(DirectiveType.PRIVATE)
-
-            # 2. Cache time settings
-            if ttl is not None:
-                cache_control.add(DirectiveType.MAX_AGE, ttl)
-
-            # 3. Validation related
-            if must_revalidate:
-                cache_control.add(DirectiveType.MUST_REVALIDATE)
-
-            # 4. Stale response handling
-            if stale is not None and stale_ttl is None:
-                raise CacheXError("stale_ttl must be set if stale is used")
-
-            if stale == "revalidate":
-                cache_control.add(DirectiveType.STALE_WHILE_REVALIDATE, stale_ttl)
-            elif stale == "error":
-                cache_control.add(DirectiveType.STALE_IF_ERROR, stale_ttl)
-
-            # 5. Special flags
-            if immutable:
-                cache_control.add(DirectiveType.IMMUTABLE)
-
-            # Store the data in the cache
-            await cache_backend.set(
-                cache_key, ETagContent(etag, response.body), ttl=ttl
-            )
+            current_response = None
+            current_etag = None
+
+            if client_etag:
+                if no_cache:
+                    # Get fresh response first if using no-cache
+                    current_response = await get_response(func, req, *args, **kwargs)
+                    current_etag = (
+                        f'W/"{hashlib.md5(current_response.body).hexdigest()}"'  # noqa: S324
+                    )
+
+                    if client_etag == current_etag:
+                        # For no-cache, compare fresh data with client's ETag
+                        return Response(
+                            status_code=HTTP_304_NOT_MODIFIED,
+                            headers={
+                                "ETag": current_etag,
+                                "Cache-Control": cache_control,
+                            },
+                        )
+
+                # Compare with cached ETag
+                elif (
+                    cached_data and client_etag == cached_data.etag
+                ):  # pragma: no branch
+                    return Response(
+                        status_code=HTTP_304_NOT_MODIFIED,
+                        headers={
+                            "ETag": cached_data.etag,
+                            "Cache-Control": cache_control,
+                        },
+                    )
+
+            if not current_response or not current_etag:
+                # Retrieve the current response if not already done
+                current_response = await get_response(func, req, *args, **kwargs)
+                current_etag = f'W/"{hashlib.md5(current_response.body).hexdigest()}"'  # noqa: S324
+
+            # Set ETag header
+            current_response.headers["ETag"] = current_etag
+
+            # Update cache if needed
+            if not cached_data or cached_data.etag != current_etag:
+                # Store in cache if data changed
+                await cache_backend.set(
+                    cache_key, ETagContent(current_etag, current_response.body), ttl=ttl
+                )
 
-            response.headers["Cache-Control"] = str(cache_control)
-            return response
+            current_response.headers["Cache-Control"] = cache_control
+            return current_response
 
         # Update the wrapper with the new signature
         update_wrapper(wrapper, func)

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.3.dist-info → fastapi_cachex-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachex
-Version: 0.1.3
+Version: 0.1.5
 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
@@ -126,46 +126,10 @@ BackendProxy.set_backend(backend)
 
 Redis support is under development and will be available in future releases.
 
-## Development Guide
+## Documentation
 
-### Running Tests
-
-1. Run unit tests:
-
-```bash
-pytest
-```
-
-2. Run tests with coverage report:
-
-```bash
-pytest --cov=fastapi_cachex
-```
-
-### Using tox
-
-tox ensures the code works across different Python versions (3.10-3.13).
-
-1. Install all Python versions
-2. Run tox:
-
-```bash
-tox
-```
-
-To run for a specific Python version:
-
-```bash
-tox -e py310  # only run for Python 3.10
-```
-
-## Contributing
-
-1. Fork the project
-2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
-3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
-4. Push to the branch (`git push origin feature/AmazingFeature`)
-5. Open a Pull Request
+- [Development Guide](docs/DEVELOPMENT.md)
+- [Contributing Guidelines](docs/CONTRIBUTING.md)
 
 ## License
 

fastapi_cachex-0.1.5.dist-info/RECORD

@@ -0,0 +1,17 @@
+fastapi_cachex/__init__.py,sha256=_g7ewsAAjvbeMoDOttsfSD-G5ebPCN7MVPl-p2fY0tU,202
+fastapi_cachex/cache.py,sha256=b-55IR0kdcVj4yUk8dplqqUy2avW49P-oI01ART9pyU,9174
+fastapi_cachex/dependencies.py,sha256=K4565NSU7j8ktqe5ib_hs-fBB6IbIrM0nw6pTHpjLc4,385
+fastapi_cachex/directives.py,sha256=kJCmsbyQ89m6tsWo_c1vVJn3rk0pD5JZaY8xtNLcRh0,530
+fastapi_cachex/exceptions.py,sha256=coYct4u6uK_pdjetUWDwM5OUCfhql0OkTECynMRUq4M,379
+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/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-0.1.3.dist-info/RECORD

@@ -1,16 +0,0 @@
-fastapi_cachex/__init__.py,sha256=K8zRD7pEOo77Ged7SJQ-BFNMe6Pnz8yM5ePFq97nI_s,82
-fastapi_cachex/cache.py,sha256=V6RhNRZuhb4vR9LBk03DJ-HGnOSTpi3uTBms9rFov8E,7587
-fastapi_cachex/directives.py,sha256=kJCmsbyQ89m6tsWo_c1vVJn3rk0pD5JZaY8xtNLcRh0,530
-fastapi_cachex/exceptions.py,sha256=coYct4u6uK_pdjetUWDwM5OUCfhql0OkTECynMRUq4M,379
-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/base.py,sha256=eGfn0oZNQ8_drNHz4ZtqBVFSxKxEwW8y4ojw5iShgLQ,707
-fastapi_cachex/backends/memcached.py,sha256=g3184fHpFK7LH1UY9xfzRszBBzqmzeaLG806B5MsZDM,2190
-fastapi_cachex/backends/memory.py,sha256=7KFSn5e1CvDzflZ5zqUPDQsBf6emcV0ob_tCsLQcDLw,2445
-fastapi_cachex-0.1.3.dist-info/licenses/LICENSE,sha256=asJkHbd10YDSnjeAOIlKafh7E_exwtKXY5rA-qc_Mno,11339
-fastapi_cachex-0.1.3.dist-info/METADATA,sha256=-aKGoO1RcxqXe5DZepZOJprK-cm0Xo4He_3ESVZGs6k,5224
-fastapi_cachex-0.1.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-fastapi_cachex-0.1.3.dist-info/top_level.txt,sha256=97FfG5FDycd3hks-_JznEr-5lUOgg8AZd8pqK5imWj0,15
-fastapi_cachex-0.1.3.dist-info/RECORD,,