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

fastapi_cachex-0.1.2/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: fastapi-cachex
+Version: 0.1.2
+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
+Project-URL: Homepage, https://github.com/allen0099/FastAPI-CacheX
+Project-URL: Repository, https://github.com/allen0099/FastAPI-CacheX.git
+Project-URL: Issues, https://github.com/allen0099/FastAPI-CacheX/issues
+Keywords: fastapi,cache,etag,cache-control,redis,memcached,in-memory
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Framework :: FastAPI
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+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"
+Dynamic: license-file
+
+# 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.
+
+## Development Guide
+
+### 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
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

fastapi_cachex-0.1.0/PKG-INFO → fastapi_cachex-0.1.2/README.md

@@ -1,14 +1,3 @@
-Metadata-Version: 2.4
-Name: fastapi-cachex
-Version: 0.1.0
-Summary: Add your description here
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: fastapi>=0.115.12
-Requires-Dist: httpx>=0.28.1
-Dynamic: license-file
-
 # 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)
@@ -16,8 +5,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)
 
@@ -54,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.0 → fastapi_cachex-0.1.2}/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.2/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.0 → fastapi_cachex-0.1.2}/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.2/fastapi_cachex.egg-info/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: fastapi-cachex
+Version: 0.1.2
+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
+Project-URL: Homepage, https://github.com/allen0099/FastAPI-CacheX
+Project-URL: Repository, https://github.com/allen0099/FastAPI-CacheX.git
+Project-URL: Issues, https://github.com/allen0099/FastAPI-CacheX/issues
+Keywords: fastapi,cache,etag,cache-control,redis,memcached,in-memory
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Framework :: FastAPI
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+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"
+Dynamic: license-file
+
+# 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.
+
+## Development Guide
+
+### 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
+
+## License
+
+This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

{fastapi_cachex-0.1.0 → fastapi_cachex-0.1.2}/fastapi_cachex.egg-info/SOURCES.txt

@@ -14,5 +14,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.2/fastapi_cachex.egg-info/requires.txt

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

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

@@ -1,18 +1,43 @@
 [project]
 name = "fastapi-cachex"
-version = "0.1.0"
-description = "Add your description here"
+version = "0.1.2" # 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"
+license = "Apache-2.0"
+authors = [
+    { name = "Allen", email = "s96016641@gmail.com" }
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3 :: Only",
+    "Framework :: FastAPI",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+]
+keywords = ["fastapi", "cache", "etag", "cache-control", "redis", "memcached", "in-memory"]
 dependencies = [
-    "fastapi>=0.115.12",
-    "httpx>=0.28.1",
+    "fastapi",
+    "httpx",
 ]
 
+[project.urls]
+Homepage = "https://github.com/allen0099/FastAPI-CacheX"
+Repository = "https://github.com/allen0099/FastAPI-CacheX.git"
+Issues = "https://github.com/allen0099/FastAPI-CacheX/issues"
+
 [dependency-groups]
 dev = [
     "coverage>=7.8.0",
     "pre-commit>=4.2.0",
+    "pymemcache>=4.0.0",
     "pytest>=8.3.5",
     "pytest-asyncio>=0.26.0",
     "pytest-cov>=6.1.0",
@@ -20,6 +45,9 @@ dev = [
     "tox>=4.25.0",
 ]
 
+[project.optional-dependencies]
+memcache = ["pymemcache"]
+
 [tool.pytest.ini_options]
 pythonpath = [
   "."

fastapi_cachex-0.1.2/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.0/README.md

@@ -1,100 +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)
-
-[![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/)
-
-[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
-
-app = FastAPI()
-
-
-@app.get("/")
-@cache()
-async def read_root():
-    return {"Hello": "World"}
-```
-
-## Development Guide
-
-### 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
-
-## License
-
-This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

fastapi_cachex-0.1.0/fastapi_cachex.egg-info/PKG-INFO

@@ -1,111 +0,0 @@
-Metadata-Version: 2.4
-Name: fastapi-cachex
-Version: 0.1.0
-Summary: Add your description here
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: fastapi>=0.115.12
-Requires-Dist: httpx>=0.28.1
-Dynamic: license-file
-
-# 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)
-
-[![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/)
-
-[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
-
-app = FastAPI()
-
-
-@app.get("/")
-@cache()
-async def read_root():
-    return {"Hello": "World"}
-```
-
-## Development Guide
-
-### 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
-
-## License
-
-This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

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

@@ -1,2 +0,0 @@
-fastapi>=0.115.12
-httpx>=0.28.1