fastapi-cachex 0.1.1__tar.gz → 0.1.3__tar.gz

{fastapi_cachex-0.1.1 → fastapi_cachex-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachex
-Version: 0.1.1
+Version: 0.1.3
 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
@@ -25,6 +25,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastapi
 Requires-Dist: httpx
+Provides-Extra: memcache
+Requires-Dist: pymemcache; extra == "memcache"
 Dynamic: license-file
 
 # FastAPI-Cache X
@@ -34,8 +36,12 @@ Dynamic: license-file
 [![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)
 
-[![PyPI version](https://badge.fury.io/py/fastapi-cachex.svg)](https://badge.fury.io/py/fastapi-cachex)
-[![Python Versions](https://img.shields.io/pypi/pyversions/fastapi-cachex.svg)](https://pypi.org/project/fastapi-cachex/)
+[![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)
 
@@ -72,17 +78,54 @@ uv pip install fastapi-cachex
 
 ```python
 from fastapi import FastAPI
-from fastapi_cachex import cache
+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()
+@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.
+
 ## Development Guide
 
 ### Running Tests

{fastapi_cachex-0.1.1 → fastapi_cachex-0.1.3}/README.md

@@ -5,8 +5,12 @@
 [![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)
 
-[![PyPI version](https://badge.fury.io/py/fastapi-cachex.svg)](https://badge.fury.io/py/fastapi-cachex)
-[![Python Versions](https://img.shields.io/pypi/pyversions/fastapi-cachex.svg)](https://pypi.org/project/fastapi-cachex/)
+[![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)
 
@@ -43,17 +47,54 @@ uv pip install fastapi-cachex
 
 ```python
 from fastapi import FastAPI
-from fastapi_cachex import cache
+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()
+@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.
+
 ## Development Guide
 
 ### Running Tests

{fastapi_cachex-0.1.1 → fastapi_cachex-0.1.3}/fastapi_cachex/backends/__init__.py

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

fastapi_cachex-0.1.3/fastapi_cachex/backends/memcached.py

@@ -0,0 +1,74 @@
+import ast
+from typing import Optional
+
+from fastapi_cachex.backends.base import BaseCacheBackend
+from fastapi_cachex.exceptions import CacheXError
+from fastapi_cachex.types import ETagContent
+
+
+class MemcachedBackend(BaseCacheBackend):
+    """Memcached backend implementation."""
+
+    def __init__(self, servers: list[str]) -> None:
+        """Initialize the Memcached backend.
+
+        Args:
+            servers: List of Memcached servers in format ["host:port", ...]
+
+        Raises:
+            CacheXError: If pymemcache is not installed
+        """
+        try:
+            from pymemcache import HashClient
+        except ImportError:
+            raise CacheXError(
+                "pymemcache is not installed. Please install it with 'pip install pymemcache'"
+            )
+
+        self.client = HashClient(servers)
+
+    async def get(self, key: str) -> Optional[ETagContent]:
+        """Get value from cache.
+
+        Args:
+            key: Cache key to retrieve
+
+        Returns:
+            Optional[ETagContent]: Cached value with ETag if exists, None otherwise
+        """
+        value = self.client.get(key)
+        if value is None:
+            return None
+
+        # Memcached stores data as bytes
+        # Convert string back to dictionary
+        value_dict = ast.literal_eval(value.decode("utf-8"))
+        return ETagContent(etag=value_dict["etag"], content=value_dict["content"])
+
+    async def set(
+        self, key: str, value: ETagContent, ttl: Optional[int] = None
+    ) -> None:
+        """Set value in cache.
+
+        Args:
+            key: Cache key
+            value: ETagContent to store
+            ttl: Time to live in seconds
+        """
+        # Store as dictionary in string format
+        data = {"etag": value.etag, "content": value.content}
+        self.client.set(
+            key, str(data).encode("utf-8"), expire=ttl if ttl is not None else 0
+        )
+
+    async def delete(self, key: str) -> None:
+        """Delete value from cache.
+
+        Args:
+            key: Cache key to delete
+        """
+        self.client.delete(key)
+
+    async def clear(self) -> None:
+        """Clear all values from cache."""
+        self.client.flush_all()

{fastapi_cachex-0.1.1 → fastapi_cachex-0.1.3}/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.1 → fastapi_cachex-0.1.3}/fastapi_cachex/cache.py

@@ -1,16 +1,21 @@
 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.responses import JSONResponse
+from fastapi.datastructures import DefaultPlaceholder
 from starlette.status import HTTP_304_NOT_MODIFIED
 
 from fastapi_cachex.backends import MemoryBackend
@@ -21,10 +26,18 @@ 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 = []
+        self.directives: list[str] = []
 
     def add(self, directive: DirectiveType, value: Optional[int] = None) -> None:
         if value is not None:
@@ -36,12 +49,32 @@ class CacheControl:
         return ", ".join(self.directives)
 
 
-async def get_response(func: Callable, *args: Any, **kwargs: Any) -> Response:
+async def get_response(
+    __func: AnyCallable[Response], __request: Request, *args: Any, **kwargs: Any
+) -> Response:
     """Get the response from the function."""
-    if inspect.iscoroutinefunction(func):
-        return await func(*args, **kwargs)
+    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:
-        return func(*args, **kwargs)
+        response_class = route.response_class
+
+    # Convert non-Response result to Response using appropriate response_class
+    return response_class(content=result)
 
 
 def cache(  # noqa: C901
@@ -54,8 +87,8 @@ def cache(  # noqa: C901
     private: bool = False,
     immutable: bool = False,
     must_revalidate: bool = False,
-) -> Callable:
-    def decorator(func: Callable) -> Callable:  # noqa: C901
+) -> Callable[[AnyCallable[Response]], AsyncCallable[Response]]:
+    def decorator(func: AnyCallable[Response]) -> AsyncCallable[Response]:  # noqa: C901
         try:
             cache_backend = BackendProxy.get_backend()
         except BackendNotFoundError:
@@ -87,52 +120,38 @@ def cache(  # noqa: C901
         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)
+                req: Request | None = kwargs.get(request_name)
             else:
-                request: Request | None = kwargs.pop(request_name, None)
+                req = kwargs.pop(request_name, None)
 
-            if not request:  # pragma: no cover
+            if not req:  # 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)
+            if req.method != "GET":
+                return await get_response(func, req, *args, **kwargs)
 
             # Generate cache key
-            cache_key = f"{request.url.path}:{request.query_params}"
+            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 == (
-                request.headers.get("if-none-match")
-            ):
+            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, *args, **kwargs)
+            response = await get_response(func, req, *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
+            etag = f'W/"{hashlib.md5(response.body).hexdigest()}"'  # noqa: S324
 
             # Add ETag to response headers
             response.headers["ETag"] = etag
@@ -183,11 +202,17 @@ def cache(  # noqa: C901
                 cache_control.add(DirectiveType.IMMUTABLE)
 
             # Store the data in the cache
-            await cache_backend.set(cache_key, ETagContent(etag, content), ttl=ttl)
+            await cache_backend.set(
+                cache_key, ETagContent(etag, response.body), ttl=ttl
+            )
 
             response.headers["Cache-Control"] = str(cache_control)
             return 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.1 → fastapi_cachex-0.1.3}/fastapi_cachex/proxy.py

@@ -1,7 +1,9 @@
+from typing import Optional
+
 from fastapi_cachex.backends import BaseCacheBackend
 from fastapi_cachex.exceptions import BackendNotFoundError
 
-_default_backend: BaseCacheBackend | None = None
+_default_backend: Optional[BaseCacheBackend] = None
 
 
 class BackendProxy:
@@ -17,7 +19,11 @@ class BackendProxy:
         return _default_backend
 
     @staticmethod
-    def set_backend(backend: BaseCacheBackend) -> None:
-        """Set the backend for caching."""
+    def set_backend(backend: Optional[BaseCacheBackend]) -> None:
+        """Set the backend for caching.
+
+        Args:
+            backend: The backend to use for caching, or None to clear the current backend
+        """
         global _default_backend
         _default_backend = backend

{fastapi_cachex-0.1.1 → fastapi_cachex-0.1.3}/fastapi_cachex.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachex
-Version: 0.1.1
+Version: 0.1.3
 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
@@ -25,6 +25,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastapi
 Requires-Dist: httpx
+Provides-Extra: memcache
+Requires-Dist: pymemcache; extra == "memcache"
 Dynamic: license-file
 
 # FastAPI-Cache X
@@ -34,8 +36,12 @@ Dynamic: license-file
 [![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)
 
-[![PyPI version](https://badge.fury.io/py/fastapi-cachex.svg)](https://badge.fury.io/py/fastapi-cachex)
-[![Python Versions](https://img.shields.io/pypi/pyversions/fastapi-cachex.svg)](https://pypi.org/project/fastapi-cachex/)
+[![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)
 
@@ -72,17 +78,54 @@ uv pip install fastapi-cachex
 
 ```python
 from fastapi import FastAPI
-from fastapi_cachex import cache
+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()
+@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.
+
 ## Development Guide
 
 ### Running Tests

{fastapi_cachex-0.1.1 → fastapi_cachex-0.1.3}/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
@@ -14,5 +15,7 @@ fastapi_cachex.egg-info/requires.txt
 fastapi_cachex.egg-info/top_level.txt
 fastapi_cachex/backends/__init__.py
 fastapi_cachex/backends/base.py
+fastapi_cachex/backends/memcached.py
 fastapi_cachex/backends/memory.py
-tests/test_cache.py
+tests/test_cache.py
+tests/test_proxybackend.py

fastapi_cachex-0.1.3/fastapi_cachex.egg-info/requires.txt

@@ -0,0 +1,5 @@
+fastapi
+httpx
+
+[memcache]
+pymemcache

{fastapi_cachex-0.1.1 → fastapi_cachex-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-cachex"
-version = "0.1.1" # Initial release version
+version = "0.1.3" # 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,7 +36,9 @@ 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",
     "pytest-asyncio>=0.26.0",
     "pytest-cov>=6.1.0",
@@ -44,6 +46,12 @@ dev = [
     "tox>=4.25.0",
 ]
 
+[project.optional-dependencies]
+memcache = ["pymemcache"]
+
+[tool.setuptools]
+package-data = {"fastapi_cachex" = ["py.typed"]}
+
 [tool.pytest.ini_options]
 pythonpath = [
   "."
@@ -121,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.1 → fastapi_cachex-0.1.3}/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
 
@@ -276,3 +278,69 @@ 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

fastapi_cachex-0.1.3/tests/test_proxybackend.py

@@ -0,0 +1,101 @@
+import asyncio
+
+import pytest
+import pytest_asyncio
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from fastapi.testclient import TestClient
+
+from fastapi_cachex import BackendProxy
+from fastapi_cachex import cache
+from fastapi_cachex.backends import MemoryBackend
+from fastapi_cachex.exceptions import BackendNotFoundError
+from fastapi_cachex.types import ETagContent
+
+app = FastAPI()
+client = TestClient(app)
+
+
+@pytest_asyncio.fixture(autouse=True)
+async def cleanup():
+    # Reset backend before each test
+    try:
+        backend = BackendProxy.get_backend()
+        if isinstance(backend, MemoryBackend):
+            backend.stop_cleanup()
+        # Reset backend by setting it to None
+        BackendProxy.set_backend(None)
+    except BackendNotFoundError:
+        pass
+
+    yield
+
+    # Clean up after each test
+    try:
+        backend = BackendProxy.get_backend()
+        if isinstance(backend, MemoryBackend):
+            await backend.clear()  # Clear all cached data
+            backend.stop_cleanup()
+        # Reset backend by setting it to None
+        BackendProxy.set_backend(None)
+    except BackendNotFoundError:
+        pass
+
+
+def test_backend_switching():
+    # Initial state should have no backend
+    with pytest.raises(BackendNotFoundError):
+        BackendProxy.get_backend()
+
+    # Set up MemoryBackend
+    memory_backend = MemoryBackend()
+    BackendProxy.set_backend(memory_backend)
+    assert isinstance(BackendProxy.get_backend(), MemoryBackend)
+
+
+def test_memory_cache():
+    @app.get("/test")
+    @cache(ttl=60)
+    async def test_endpoint():
+        return JSONResponse(content={"message": "test"})
+
+    # Use MemoryBackend
+    memory_backend = MemoryBackend()
+    BackendProxy.set_backend(memory_backend)
+
+    # First request should return 200
+    response1 = client.get("/test")
+    assert response1.status_code == 200
+    etag1 = response1.headers["ETag"]
+
+    # Request with same ETag should return 304
+    response2 = client.get("/test", headers={"If-None-Match": etag1})
+    assert response2.status_code == 304
+
+
+@pytest.mark.asyncio
+async def test_backend_cleanup():
+    # Run cleanup task in async environment
+    memory_backend = MemoryBackend()
+    BackendProxy.set_backend(memory_backend)
+
+    # Verify initial state
+    assert memory_backend._cleanup_task is None
+
+    # Set test data
+    test_value = ETagContent(etag="test-etag", content="test_value")
+    await memory_backend.set("test_key", test_value, ttl=1)
+
+    # Verify data is stored correctly
+    cached_value = await memory_backend.get("test_key")
+    assert cached_value is not None
+    assert cached_value.content == "test_value"
+
+    # Wait for data to expire (1 second + extra time)
+    await asyncio.sleep(1.1)
+
+    # Execute cleanup
+    await memory_backend.cleanup()
+
+    # Verify data has been cleaned up
+    assert await memory_backend.get("test_key") is None

fastapi_cachex-0.1.1/fastapi_cachex.egg-info/requires.txt

@@ -1,2 +0,0 @@
-fastapi
-httpx