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

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

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

@@ -95,46 +95,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.2 → fastapi_cachex-0.1.4}/fastapi_cachex/backends/memory.py

@@ -15,7 +15,7 @@ class MemoryBackend(BaseCacheBackend):
         self.cache: dict[str, CacheItem] = {}
         self.lock = asyncio.Lock()
         self.cleanup_interval = 60
-        self._cleanup_task: Optional[asyncio.Task] = None
+        self._cleanup_task: Optional[asyncio.Task[None]] = None
 
     def start_cleanup(self) -> None:
         """Start the cleanup task if it's not already running."""
@@ -42,7 +42,7 @@ class MemoryBackend(BaseCacheBackend):
         self, key: str, value: ETagContent, ttl: Optional[int] = None
     ) -> None:
         async with self.lock:
-            expiry = time.time() + ttl if ttl is not None else None
+            expiry: Optional[int] = int(time.time() + ttl) if ttl is not None else None
             self.cache[key] = CacheItem(value=value, expiry=expiry)
 
     async def delete(self, key: str) -> None:

fastapi_cachex-0.1.4/fastapi_cachex/cache.py

@@ -0,0 +1,248 @@
+import hashlib
+import inspect
+from collections.abc import Awaitable
+from collections.abc import Callable
+from functools import update_wrapper
+from functools import wraps
+from inspect import Parameter
+from inspect import Signature
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Literal
+from typing import Optional
+from typing import TypeVar
+from typing import Union
+
+from fastapi import Request
+from fastapi import Response
+from fastapi.datastructures import DefaultPlaceholder
+from starlette.status import HTTP_304_NOT_MODIFIED
+
+from fastapi_cachex.backends import MemoryBackend
+from fastapi_cachex.directives import DirectiveType
+from fastapi_cachex.exceptions import BackendNotFoundError
+from fastapi_cachex.exceptions import CacheXError
+from fastapi_cachex.exceptions import RequestNotFoundError
+from fastapi_cachex.proxy import BackendProxy
+from fastapi_cachex.types import ETagContent
+
+if TYPE_CHECKING:
+    from fastapi.routing import APIRoute
+
+T = TypeVar("T", bound=Response)
+AsyncCallable = Callable[..., Awaitable[T]]
+SyncCallable = Callable[..., T]
+AnyCallable = Union[AsyncCallable[T], SyncCallable[T]]  # noqa: UP007
+
+
+class CacheControl:
+    def __init__(self) -> None:
+        self.directives: list[str] = []
+
+    def add(self, directive: DirectiveType, value: Optional[int] = None) -> None:
+        if value is not None:
+            self.directives.append(f"{directive.value}={value}")
+        else:
+            self.directives.append(directive.value)
+
+    def __str__(self) -> str:
+        return ", ".join(self.directives)
+
+
+async def get_response(
+    __func: AnyCallable[Response], __request: Request, *args: Any, **kwargs: Any
+) -> Response:
+    """Get the response from the function."""
+    if inspect.iscoroutinefunction(__func):
+        result = await __func(*args, **kwargs)
+    else:
+        result = __func(*args, **kwargs)
+
+    # If already a Response object, return it directly
+    if isinstance(result, Response):
+        return result
+
+    # Get response_class from route if available
+    route: APIRoute | None = __request.scope.get("route")
+    if route is None:  # pragma: no cover
+        raise CacheXError("Route not found in request scope")
+
+    if isinstance(route.response_class, DefaultPlaceholder):
+        response_class: type[Response] = route.response_class.value
+
+    else:
+        response_class = route.response_class
+
+    # Convert non-Response result to Response using appropriate response_class
+    return response_class(content=result)
+
+
+def cache(  # noqa: C901
+    ttl: Optional[int] = None,
+    stale_ttl: Optional[int] = None,
+    stale: Literal["error", "revalidate"] | None = None,
+    no_cache: bool = False,
+    no_store: bool = False,
+    public: bool = False,
+    private: bool = False,
+    immutable: bool = False,
+    must_revalidate: bool = False,
+) -> Callable[[AnyCallable[Response]], AsyncCallable[Response]]:
+    def decorator(func: AnyCallable[Response]) -> AsyncCallable[Response]:  # noqa: C901
+        try:
+            cache_backend = BackendProxy.get_backend()
+        except BackendNotFoundError:
+            # Fallback to memory backend if no backend is set
+            cache_backend = MemoryBackend()
+            BackendProxy.set_backend(cache_backend)
+
+        # Analyze the original function's signature
+        sig: Signature = inspect.signature(func)
+        params: list[Parameter] = list(sig.parameters.values())
+
+        # Check if Request is already in the parameters
+        found_request: Parameter | None = next(
+            (param for param in params if param.annotation == Request), None
+        )
+
+        # Add Request parameter if it's not present
+        if not found_request:
+            request_name: str = "__cachex_request"
+
+            request_param = inspect.Parameter(
+                request_name,
+                inspect.Parameter.KEYWORD_ONLY,
+                annotation=Request,
+            )
+
+            sig = sig.replace(parameters=[*params, request_param])
+
+        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:
+                req: Request | None = kwargs.get(request_name)
+            else:
+                req = kwargs.pop(request_name, None)
+
+            if not req:  # pragma: no cover
+                # Skip coverage for this case, as it should not happen
+                raise RequestNotFoundError()
+
+            # Only cache GET requests
+            if req.method != "GET":
+                return await get_response(func, req, *args, **kwargs)
+
+            # Generate cache key and prepare headers
+            cache_key = f"{req.url.path}:{req.query_params}"
+            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:
+                response = await get_response(func, req, *args, **kwargs)
+                cc = CacheControl()
+                cc.add(DirectiveType.NO_STORE)
+                response.headers["Cache-Control"] = str(cc)
+                return response
+
+            # Check cache and handle ETag validation
+            cached_data = await cache_backend.get(cache_key)
+
+            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
+                )
+
+            current_response.headers["Cache-Control"] = cache_control
+            return current_response
+
+        # Update the wrapper with the new signature
+        update_wrapper(wrapper, func)
+        wrapper.__signature__ = sig  # type: ignore
+
+        return wrapper
+
+    return decorator

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

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

@@ -6,6 +6,7 @@ fastapi_cachex/cache.py
 fastapi_cachex/directives.py
 fastapi_cachex/exceptions.py
 fastapi_cachex/proxy.py
+fastapi_cachex/py.typed
 fastapi_cachex/types.py
 fastapi_cachex.egg-info/PKG-INFO
 fastapi_cachex.egg-info/SOURCES.txt

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

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-cachex"
-version = "0.1.2" # Initial release version
+version = "0.1.4" # 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"
@@ -36,6 +36,7 @@ Issues = "https://github.com/allen0099/FastAPI-CacheX/issues"
 [dependency-groups]
 dev = [
     "coverage>=7.8.0",
+    "mypy>=1.15.0",
     "pre-commit>=4.2.0",
     "pymemcache>=4.0.0",
     "pytest>=8.3.5",
@@ -48,6 +49,9 @@ dev = [
 [project.optional-dependencies]
 memcache = ["pymemcache"]
 
+[tool.setuptools]
+package-data = {"fastapi_cachex" = ["py.typed"]}
+
 [tool.pytest.ini_options]
 pythonpath = [
   "."
@@ -125,3 +129,30 @@ exclude_lines = [
 ]
 fail_under = 90
 show_missing = true
+
+[tool.mypy]
+python_version = "3.10"
+plugins = [
+    "pydantic.mypy"
+]
+warn_redundant_casts = true
+warn_unused_ignores = true
+disallow_any_generics = true
+check_untyped_defs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+warn_return_any = true
+warn_unreachable = true
+strict_optional = true
+strict_equality = true
+
+[[tool.mypy.overrides]]
+module = ["tests.*"]
+disallow_untyped_defs = false
+disallow_incomplete_defs = false
+
+[[tool.mypy.overrides]]
+module = ["pymemcache.*"]
+ignore_missing_imports = true

{fastapi_cachex-0.1.2 → fastapi_cachex-0.1.4}/tests/test_cache.py

@@ -2,7 +2,9 @@ from fastapi import FastAPI
 from fastapi import Response
 from fastapi.testclient import TestClient
 from starlette.requests import Request
+from starlette.responses import HTMLResponse
 from starlette.responses import JSONResponse
+from starlette.responses import PlainTextResponse
 
 from fastapi_cachex.cache import cache
 
@@ -25,6 +27,28 @@ def test_default_cache():
     assert "ETag" in response.headers
 
 
+def test_cache_with_ttl():
+    @app.get("/cache-with-ttl")
+    @cache(ttl=3)
+    async def cache_with_ttl_endpoint():
+        return Response(
+            content=b'{"message": "This endpoint has a TTL of 30 seconds"}',
+            media_type="application/json",
+        )
+
+    response = client.get("/cache-with-ttl")
+    assert response.status_code == 200
+    assert response.headers["Cache-Control"] == "max-age=3"
+    assert "ETag" in response.headers
+
+    response2 = client.get(
+        "/cache-with-ttl", headers={"If-None-Match": response.headers["ETag"]}
+    )
+    assert response2.status_code == 304
+    assert response2.headers["Cache-Control"] == "max-age=3"
+    assert response2.headers["ETag"] == response.headers["ETag"]
+
+
 def test_ttl_endpoint():
     @app.get("/ttl")
     @cache(60)
@@ -276,3 +300,129 @@ def test_post_should_not_cache():
     response = client.post("/post")
     assert response.status_code == 200
     assert "cache-control" not in response.headers
+
+
+def test_use_default_response_class():
+    @app.get("/")
+    @cache()
+    async def default_response_class_endpoint():
+        return {"message": "This endpoint uses the default response class"}
+
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+
+
+def test_response_class_html():
+    @app.get("/html", response_class=HTMLResponse)
+    @cache(ttl=60)
+    async def html_endpoint():
+        return "<h1>Hello World</h1>"
+
+    response = client.get("/html")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert response.text == "<h1>Hello World</h1>"
+
+
+def test_response_class_plain_text():
+    @app.get("/text", response_class=PlainTextResponse)
+    @cache(ttl=60)
+    async def text_endpoint():
+        return "Hello World"
+
+    response = client.get("/text")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/plain; charset=utf-8"
+    assert response.text == "Hello World"
+
+
+def test_response_class_json_with_raw_dict():
+    @app.get("/json-dict", response_class=JSONResponse)
+    @cache(ttl=60)
+    async def json_dict_endpoint():
+        return {"message": "Hello World"}
+
+    response = client.get("/json-dict")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    assert response.json() == {"message": "Hello World"}
+
+
+def test_response_class_with_etag():
+    """Test that different response classes still generate and handle ETags correctly"""
+
+    @app.get("/html-etag", response_class=HTMLResponse)
+    @cache()
+    async def html_etag_endpoint():
+        return "<h1>Hello World</h1>"
+
+    # First request
+    response1 = client.get("/html-etag")
+    assert response1.status_code == 200
+    assert "ETag" in response1.headers
+
+    # Second request with ETag
+    etag = response1.headers["ETag"]
+    response2 = client.get("/html-etag", headers={"If-None-Match": etag})
+    assert response2.status_code == 304  # Not Modified
+
+
+def test_no_cache_with_unchanged_data():
+    """Test no-cache behavior when data hasn't changed."""
+    counter = 0
+
+    @app.get("/no-cache-unchanged")
+    @cache(no_cache=True)
+    async def no_cache_unchanged_endpoint():
+        return {"message": "This endpoint uses no-cache", "counter": counter}
+
+    # First request should return 200
+    response1 = client.get("/no-cache-unchanged")
+    assert response1.status_code == 200
+    assert response1.json() == {"message": "This endpoint uses no-cache", "counter": 0}
+    etag1 = response1.headers["ETag"]
+    assert "no-cache" in response1.headers["Cache-Control"].lower()
+
+    # Second request with ETag should return 304 as data hasn't changed
+    response2 = client.get("/no-cache-unchanged", headers={"If-None-Match": etag1})
+    assert response2.status_code == 304
+    assert "ETag" in response2.headers
+    assert response2.headers["ETag"] == etag1
+
+    # Third request without ETag should return 200 but same data
+    response3 = client.get("/no-cache-unchanged")
+    assert response3.status_code == 200
+    assert response3.json() == {"message": "This endpoint uses no-cache", "counter": 0}
+    assert response3.headers["ETag"] == etag1
+
+
+def test_no_cache_with_changing_data():
+    """Test no-cache behavior when data changes between requests."""
+    counter = {"value": 0}
+
+    @app.get("/no-cache-changing")
+    @cache(no_cache=True)
+    async def no_cache_changing_endpoint():
+        counter["value"] += 1
+        return {"message": "This endpoint uses no-cache", "counter": counter["value"]}
+
+    # First request
+    response1 = client.get("/no-cache-changing")
+    assert response1.status_code == 200
+    assert response1.json() == {"message": "This endpoint uses no-cache", "counter": 1}
+    etag1 = response1.headers["ETag"]
+    assert "no-cache" in response1.headers["Cache-Control"].lower()
+
+    # Second request with previous ETag should still return 200 with new data
+    response2 = client.get("/no-cache-changing", headers={"If-None-Match": etag1})
+    assert response2.status_code == 200  # Not 304 because data changed
+    assert response2.json() == {"message": "This endpoint uses no-cache", "counter": 2}
+    etag2 = response2.headers["ETag"]
+    assert etag2 != etag1  # ETags should be different as content changed
+
+    # Third request with latest ETag
+    response3 = client.get("/no-cache-changing", headers={"If-None-Match": etag2})
+    assert response3.status_code == 200
+    assert response3.json() == {"message": "This endpoint uses no-cache", "counter": 3}
+    assert response3.headers["ETag"] != etag2  # ETag should change again

fastapi_cachex-0.1.2/fastapi_cachex/cache.py

@@ -1,193 +0,0 @@
-import hashlib
-import inspect
-from collections.abc import Callable
-from functools import wraps
-from inspect import Parameter
-from inspect import Signature
-from typing import Any
-from typing import Literal
-from typing import Optional
-
-from fastapi import Request
-from fastapi import Response
-from fastapi.responses import JSONResponse
-from starlette.status import HTTP_304_NOT_MODIFIED
-
-from fastapi_cachex.backends import MemoryBackend
-from fastapi_cachex.directives import DirectiveType
-from fastapi_cachex.exceptions import BackendNotFoundError
-from fastapi_cachex.exceptions import CacheXError
-from fastapi_cachex.exceptions import RequestNotFoundError
-from fastapi_cachex.proxy import BackendProxy
-from fastapi_cachex.types import ETagContent
-
-
-class CacheControl:
-    def __init__(self) -> None:
-        self.directives = []
-
-    def add(self, directive: DirectiveType, value: Optional[int] = None) -> None:
-        if value is not None:
-            self.directives.append(f"{directive.value}={value}")
-        else:
-            self.directives.append(directive.value)
-
-    def __str__(self) -> str:
-        return ", ".join(self.directives)
-
-
-async def get_response(func: Callable, *args: Any, **kwargs: Any) -> Response:
-    """Get the response from the function."""
-    if inspect.iscoroutinefunction(func):
-        return await func(*args, **kwargs)
-    else:
-        return func(*args, **kwargs)
-
-
-def cache(  # noqa: C901
-    ttl: Optional[int] = None,
-    stale_ttl: Optional[int] = None,
-    stale: Literal["error", "revalidate"] | None = None,
-    no_cache: bool = False,
-    no_store: bool = False,
-    public: bool = False,
-    private: bool = False,
-    immutable: bool = False,
-    must_revalidate: bool = False,
-) -> Callable:
-    def decorator(func: Callable) -> Callable:  # noqa: C901
-        try:
-            cache_backend = BackendProxy.get_backend()
-        except BackendNotFoundError:
-            # Fallback to memory backend if no backend is set
-            cache_backend = MemoryBackend()
-            BackendProxy.set_backend(cache_backend)
-
-        # Analyze the original function's signature
-        sig: Signature = inspect.signature(func)
-        params: list[Parameter] = list(sig.parameters.values())
-
-        # Check if Request is already in the parameters
-        found_request: Parameter | None = next(
-            (param for param in params if param.annotation == Request), None
-        )
-
-        # Add Request parameter if it's not present
-        if not found_request:
-            request_name: str = "__cachex_request"
-
-            request_param = inspect.Parameter(
-                request_name,
-                inspect.Parameter.KEYWORD_ONLY,
-                annotation=Request,
-            )
-
-            sig = sig.replace(parameters=[*params, request_param])
-
-        else:
-            request_name = found_request.name
-
-        func.__signature__ = sig
-
-        @wraps(func)
-        async def wrapper(*args: Any, **kwargs: Any) -> Response:  # noqa: C901
-            if found_request:
-                request: Request | None = kwargs.get(request_name)
-            else:
-                request: Request | None = kwargs.pop(request_name, None)
-
-            if not request:  # pragma: no cover
-                # Skip coverage for this case, as it should not happen
-                raise RequestNotFoundError()
-
-            # Only cache GET requests
-            if request.method != "GET":
-                return await get_response(func, *args, **kwargs)
-
-            # Generate cache key
-            cache_key = f"{request.url.path}:{request.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 == (
-                request.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, *args, **kwargs)
-
-            # Generate ETag (hash based on response content)
-            if isinstance(response, JSONResponse):
-                content = response.body
-            else:
-                content = (
-                    response.body
-                    if hasattr(response, "body")
-                    else str(response).encode()
-                )
-
-            # Calculate ETag
-            etag = f'W/"{hashlib.md5(content).hexdigest()}"'  # noqa: S324
-
-            # Add ETag to response headers
-            response.headers["ETag"] = etag
-
-            # Handle Cache-Control header
-            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)
-                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
-
-            # 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, content), ttl=ttl)
-
-            response.headers["Cache-Control"] = str(cache_control)
-            return response
-
-        return wrapper
-
-    return decorator