fastapi-memory 0.1.0__py3-none-any.whl

fastapi_memory/__init__.py

@@ -0,0 +1,74 @@
+"""
+fastapi-memory
+==============
+
+Caching, retry, and resilient-HTTP helpers for FastAPI services.
+
+This package provides response caching, retry policies, a resilient async
+HTTP client, and cached config singletons — all in one import, designed for
+FastAPI services that talk to slower upstream APIs.
+
+Import from this package instead of juggling multiple dependencies directly::
+
+    from fastapi_memory import (
+        FmCacheManager, FmMemoryBackend, memorize,
+        retry, stop_after_retries, exponential_backoff, retry_on_error,
+        fm_lru,
+    )
+
+Higher-level helpers
+---------------------
+On top of the re-exports, fastapi-memory adds a few small conveniences:
+
+- ``init_cache()``              -> one-line ``FmCacheManager`` setup (memory or Redis)
+- ``clear_cache()``              -> ``await FmCacheManager.clear()``
+- ``default_retry()``            -> the "3 attempts, exponential backoff, skip 4xx" policy
+- ``is_retryable_httpx_error``   -> the retry predicate behind ``default_retry``
+- ``cached_singleton``           -> ``@fm_lru(maxsize=1)`` for settings-style singletons
+- ``FmResilientClient``           -> persistent ``httpx.AsyncClient`` + retries + JSON helpers
+
+See the README for full usage examples and a migration guide.
+"""
+
+from .caching import (
+    FmCacheManager,
+    FmMemoryBackend,
+    FmRedisBackend,
+    memorize,
+    clear_cache,
+    init_cache,
+)
+from .config import cached_singleton, fm_lru
+from .http import FmResilientClient
+from .resilience import (
+    default_retry,
+    is_retryable_httpx_error,
+    retry,
+    retry_on_error,
+    stop_after_retries,
+    exponential_backoff,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # caching
+    "FmCacheManager",
+    "FmMemoryBackend",
+    "FmRedisBackend",
+    "memorize",
+    "init_cache",
+    "clear_cache",
+    # resilience
+    "retry",
+    "stop_after_retries",
+    "exponential_backoff",
+    "retry_on_error",
+    "default_retry",
+    "is_retryable_httpx_error",
+    # config
+    "fm_lru",
+    "cached_singleton",
+    # http
+    "FmResilientClient",
+]

fastapi_memory/caching.py

@@ -0,0 +1,117 @@
+"""
+Thin convenience layer around fastapi-cache2.
+
+Re-exports the pieces you already use directly (``FmCacheManager``,
+``FmMemoryBackend``, ``memorize``) and adds two small helpers:
+
+- :func:`init_cache` - one-line setup for an in-memory or Redis-backed cache
+- :func:`clear_cache` - ``await FmCacheManager.clear()``
+
+The Redis backend is optional. Install it with::
+
+    pip install "fastapi-memory[redis]"
+
+If ``redis`` isn't installed, ``FmRedisBackend`` is simply ``None`` and
+``init_cache(backend="redis", ...)`` raises a clear ``RuntimeError``
+explaining how to fix it. The default ``backend="memory"`` works with no
+extra dependencies, exactly like the original::
+
+    FmCacheManager.init(FmMemoryBackend(), prefix="app-cache")
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from fastapi_cache import FastAPICache
+from fastapi_cache.backends.inmemory import InMemoryBackend
+from fastapi_cache.decorator import cache
+
+# Aliases under fastapi-memory namespace
+FmCacheManager = FastAPICache
+FmMemoryBackend = InMemoryBackend
+memorize = cache
+
+try:  # pragma: no cover - exercised only when the `redis` extra is installed
+    from fastapi_cache.backends.redis import RedisBackend
+    from redis.asyncio import from_url as _redis_from_url
+
+    FmRedisBackend = RedisBackend
+    _REDIS_AVAILABLE = True
+except ImportError:  # pragma: no cover - redis extra not installed
+    FmRedisBackend = None  # type: ignore[assignment, misc]
+    _redis_from_url = None
+    _REDIS_AVAILABLE = False
+
+
+def init_cache(
+    backend: str = "memory",
+    *,
+    prefix: str = "fastapi-cache",
+    redis_url: Optional[str] = None,
+) -> None:
+    """
+    Initialise :class:`FmCacheManager` with either an in-memory backend
+    (default) or a Redis backend.
+
+    Call this once during application startup, typically inside a
+    ``lifespan`` handler::
+
+        from contextlib import asynccontextmanager
+        from fastapi import FastAPI
+        from fastapi_memory import init_cache
+
+        @asynccontextmanager
+        async def lifespan(app: FastAPI):
+            init_cache(prefix="app-cache")  # in-memory (default)
+            yield
+
+        app = FastAPI(lifespan=lifespan)
+
+    For Redis, pass ``backend="redis"`` and a connection URL::
+
+        init_cache(backend="redis", prefix="app-cache", redis_url="redis://localhost:6379")
+
+    Parameters
+    ----------
+    backend:
+        ``"memory"`` (default) or ``"redis"``.
+    prefix:
+        Cache-key prefix, passed straight through to ``FmCacheManager.init``.
+    redis_url:
+        Connection string for Redis, e.g. ``redis://localhost:6379``.
+        Required when ``backend="redis"``.
+    """
+    if backend == "memory":
+        FmCacheManager.init(FmMemoryBackend(), prefix=prefix)
+        return
+
+    if backend == "redis":
+        if not _REDIS_AVAILABLE:
+            raise RuntimeError(
+                "Redis backend requested but the 'redis' package is not "
+                "installed. Install it with: pip install fastapi-memory[redis]"
+            )
+        if not redis_url:
+            raise ValueError("redis_url is required when backend='redis'")
+
+        client = _redis_from_url(redis_url, encoding="utf8", decode_responses=False)
+        FmCacheManager.init(FmRedisBackend(client), prefix=prefix)
+        return
+
+    raise ValueError(f"Unknown backend {backend!r}, expected 'memory' or 'redis'")
+
+
+async def clear_cache() -> None:
+    """Clear the entire cache - thin wrapper around ``await FmCacheManager.clear()``."""
+    await FmCacheManager.clear()
+
+
+__all__ = [
+    "FmCacheManager",
+    "FmMemoryBackend",
+    "FmRedisBackend",
+    "memorize",
+    "init_cache",
+    "clear_cache",
+]

fastapi_memory/config.py

@@ -0,0 +1,34 @@
+"""
+Tiny helper built on top of ``functools.lru_cache`` for the
+"build-it-once-and-reuse-it" settings/config pattern.
+
+Re-exports ``lru_cache`` as ``fm_lru``, plus :func:`cached_singleton`, a
+small shorthand for the common::
+
+    @fm_lru(maxsize=1)
+    def get_settings() -> Settings:
+        return Settings()
+
+pattern.
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+# Alias under fastapi-memory namespace
+fm_lru = lru_cache
+
+
+def cached_singleton(func: Callable[[], T]) -> Callable[[], T]:
+    """
+    Shorthand for ``@fm_lru(maxsize=1)`` - turns a zero-argument factory
+    function into a cached singleton getter.
+    """
+    return fm_lru(maxsize=1)(func)
+
+
+__all__ = ["fm_lru", "cached_singleton"]

fastapi_memory/http.py

@@ -0,0 +1,170 @@
+"""
+A small resilient async HTTP client: a persistent ``httpx.AsyncClient`` with
+connection-pooling defaults plus automatic retries via
+:func:`fastapi_memory.resilience.default_retry`.
+
+This mirrors the ``_upstream_get_raw`` / ``_upstream_get`` pattern: a single
+shared client, retried with exponential backoff on network errors and 5xx
+responses, with a thin layer that turns final failures into FastAPI
+``HTTPException``s.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import httpx
+from fastapi import HTTPException
+
+from .resilience import default_retry
+
+
+class FmResilientClient:
+    """
+    A persistent, retrying async HTTP client for talking to an upstream API.
+
+    Example
+    -------
+        from contextlib import asynccontextmanager
+        from fastapi import FastAPI
+        from fastapi_memory import FmResilientClient
+
+        upstream = FmResilientClient(
+            base_url="http://api.example.com:8080",
+            timeout=30.0,
+        )
+
+        @asynccontextmanager
+        async def lifespan(app: FastAPI):
+            await upstream.start()
+            yield
+            await upstream.aclose()
+
+        app = FastAPI(lifespan=lifespan)
+
+        @app.get("/api/data")
+        async def get_data():
+            return await upstream.get_json("data")
+
+    Parameters
+    ----------
+    base_url:
+        Prepended to every ``path`` passed to :meth:`get_raw` / :meth:`get_json`.
+        Leave empty to pass full URLs directly.
+    timeout:
+        Per-request timeout in seconds, forwarded to ``httpx.AsyncClient``.
+    verify:
+        TLS verification, forwarded to ``httpx.AsyncClient``. Set to
+        ``False`` for self-signed/internal endpoints (matches
+        ``httpx.AsyncClient(verify=False)`` in the original code).
+    max_connections / max_keepalive_connections:
+        Forwarded to ``httpx.Limits``.
+    retry_attempts / retry_wait_min / retry_wait_max:
+        Forwarded to :func:`default_retry` for every request made through
+        this client.
+    """
+
+    def __init__(
+        self,
+        base_url: str = "",
+        *,
+        timeout: float = 30.0,
+        verify: bool = True,
+        max_connections: int = 20,
+        max_keepalive_connections: int = 10,
+        retry_attempts: int = 3,
+        retry_wait_min: float = 2,
+        retry_wait_max: float = 10,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._verify = verify
+        self._limits = httpx.Limits(
+            max_connections=max_connections,
+            max_keepalive_connections=max_keepalive_connections,
+        )
+        self._retry_attempts = retry_attempts
+        self._retry_wait_min = retry_wait_min
+        self._retry_wait_max = retry_wait_max
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def start(self) -> None:
+        """Create the underlying ``httpx.AsyncClient``. Call once on startup."""
+        self._client = httpx.AsyncClient(
+            timeout=self._timeout,
+            verify=self._verify,
+            limits=self._limits,
+        )
+
+    async def aclose(self) -> None:
+        """Close the underlying client. Call once on shutdown."""
+        if self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    async def __aenter__(self) -> "FmResilientClient":
+        await self.start()
+        return self
+
+    async def __aexit__(self, *exc_info: object) -> None:
+        await self.aclose()
+
+    @property
+    def client(self) -> httpx.AsyncClient:
+        """The underlying ``httpx.AsyncClient``. Raises if not started yet."""
+        if self._client is None:
+            raise RuntimeError(
+                "FmResilientClient is not started - call `await client.start()` "
+                "during application startup (e.g. in your lifespan handler), "
+                "or use it as `async with FmResilientClient(...) as client:`."
+            )
+        return self._client
+
+    def _url(self, path: str) -> str:
+        if self.base_url and not path.startswith(("http://", "https://")):
+            return f"{self.base_url}/{path.lstrip('/')}"
+        return path
+
+    async def get_raw(self, path: str, params: Optional[dict] = None) -> Any:
+        """
+        ``GET path`` with retries (see :func:`default_retry`).
+
+        Returns the parsed JSON body if possible, otherwise the raw response
+        text. Raises the underlying ``httpx`` exception on final failure -
+        use :meth:`get_json` if you'd rather get a FastAPI ``HTTPException``.
+        """
+
+        @default_retry(
+            attempts=self._retry_attempts,
+            wait_min=self._retry_wait_min,
+            wait_max=self._retry_wait_max,
+        )
+        async def _do_request() -> Any:
+            resp = await self.client.get(self._url(path), params=params)
+            resp.raise_for_status()
+            try:
+                return resp.json()
+            except ValueError:
+                return resp.text or ""
+
+        return await _do_request()
+
+    async def get_json(self, path: str, params: Optional[dict] = None) -> Any:
+        """
+        Like :meth:`get_raw`, but converts ``httpx`` errors (after retries
+        are exhausted) into FastAPI ``HTTPException``s:
+
+        - ``httpx.HTTPStatusError`` -> ``HTTPException(status_code=<upstream status>)``
+        - ``httpx.RequestError``    -> ``HTTPException(status_code=502)``
+        """
+        try:
+            return await self.get_raw(path, params)
+        except httpx.HTTPStatusError as exc:
+            raise HTTPException(
+                status_code=exc.response.status_code, detail="Upstream request failed"
+            ) from exc
+        except httpx.RequestError as exc:
+            raise HTTPException(status_code=502, detail="Upstream request error") from exc
+
+
+__all__ = ["FmResilientClient"]

fastapi_memory/resilience.py

@@ -0,0 +1,116 @@
+"""
+Retry helpers built on top of tenacity.
+
+Re-exports the building blocks you already use directly (``retry``,
+``stop_after_retries``, ``exponential_backoff``, ``retry_on_error``) and
+adds two small helpers for retry policies on flaky upstream services:
+
+- :func:`is_retryable_httpx_error` - retry network errors and 5xx responses,
+  but never 4xx client errors.
+- :func:`default_retry` - a ready-made decorator factory for "retry up to 3
+  times with exponential backoff (2s..10s), reraising on final failure".
+
+These two together are exactly equivalent to::
+
+    def _should_retry(exc):
+        if isinstance(exc, httpx.RequestError):
+            return True
+        if isinstance(exc, httpx.HTTPStatusError):
+            return exc.response.status_code >= 500
+        return False
+
+    @retry(
+        stop=stop_after_retries(3),
+        wait=exponential_backoff(multiplier=1, min=2, max=10),
+        retry=retry_on_error(_should_retry),
+        reraise=True,
+    )
+    async def call_upstream(...):
+        ...
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Optional
+
+import httpx
+from tenacity import (
+    retry,
+    retry_if_exception,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+# Aliases under fastapi-memory namespace
+stop_after_retries = stop_after_attempt
+exponential_backoff = wait_exponential
+retry_on_error = retry_if_exception
+
+RetryPredicate = Callable[[BaseException], bool]
+
+
+def is_retryable_httpx_error(exc: BaseException) -> bool:
+    """
+    Default retry policy for httpx calls:
+
+    - ``httpx.RequestError`` (timeouts, connection errors, DNS failures, ...) -> retry
+    - ``httpx.HTTPStatusError`` with a 5xx response                           -> retry
+    - ``httpx.HTTPStatusError`` with a 4xx response                           -> do NOT retry
+    - anything else                                                            -> do NOT retry
+    """
+    if isinstance(exc, httpx.RequestError):
+        return True
+    if isinstance(exc, httpx.HTTPStatusError):
+        return exc.response.status_code >= 500
+    return False
+
+
+def default_retry(
+    attempts: int = 3,
+    *,
+    wait_min: float = 2,
+    wait_max: float = 10,
+    multiplier: float = 1,
+    retry_on: Optional[RetryPredicate] = None,
+    reraise: bool = True,
+):
+    """
+    A pre-configured :func:`tenacity.retry` decorator factory.
+
+    Calling ``default_retry()`` with no arguments is equivalent to::
+
+        @retry(
+            stop=stop_after_retries(3),
+            wait=exponential_backoff(multiplier=1, min=2, max=10),
+            retry=retry_on_error(is_retryable_httpx_error),
+            reraise=True,
+        )
+
+    Example
+    -------
+        @default_retry()
+        async def call_upstream():
+            resp = await client.get(url)
+            resp.raise_for_status()
+            return resp.json()
+
+    Override any piece as needed, e.g. ``default_retry(attempts=5)`` or
+    ``default_retry(retry_on=my_predicate)``.
+    """
+    condition = retry_on or is_retryable_httpx_error
+    return retry(
+        stop=stop_after_retries(attempts),
+        wait=exponential_backoff(multiplier=multiplier, min=wait_min, max=wait_max),
+        retry=retry_on_error(condition),
+        reraise=reraise,
+    )
+
+
+__all__ = [
+    "retry",
+    "stop_after_retries",
+    "exponential_backoff",
+    "retry_on_error",
+    "default_retry",
+    "is_retryable_httpx_error",
+]

fastapi_memory-0.1.0.dist-info/METADATA

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: fastapi-memory
+Version: 0.1.0
+Summary: Caching, retry and resilient-HTTP helpers for FastAPI services.
+Author-email: Alexander Stankovic <alexdarka@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/alexdarka/fastapi-memory
+Project-URL: Repository, https://github.com/alexdarka/fastapi-memory
+Keywords: fastapi,cache,caching,retry,tenacity,httpx,resilience,redis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Framework :: FastAPI
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: fastapi-cache2>=0.2.2
+Requires-Dist: tenacity>=8.3.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: jinja2>=3.1.0
+Provides-Extra: redis
+Requires-Dist: redis>=5.0.0; extra == "redis"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocstrings[python]; extra == "docs"
+Dynamic: license-file
+
+# fastapi-memory
+
+Caching, retry, and resilient-HTTP helpers for FastAPI services.
+
+A single package that provides response caching, retry policies, a resilient
+async HTTP client, and cached config singletons — tailored for FastAPI
+projects that talk to upstream APIs.
+
+```python
+from fastapi_memory import (
+    FmCacheManager, FmMemoryBackend, memorize,
+    retry, stop_after_retries, exponential_backoff, retry_on_error,
+    fm_lru,
+)
+```
+
+## Why
+
+Most FastAPI services that proxy slower or less-reliable upstream APIs end up
+re-writing the same patterns:
+
+1. A **cache** for endpoints or data that don't change often.
+2. A **retry policy** for upstream calls — retry network errors and 5xx, but not 4xx.
+3. A **cached singleton** config object (build once, reuse everywhere).
+4. A **resilient HTTP client** with connection pooling and retries baked in.
+
+`fastapi-memory` consolidates all of these into one import, with ready-made
+helpers so you don't have to re-derive common patterns every time.
+
+## Installation
+
+```bash
+# Editable install (local development)
+pip install -e /path/to/fastapi-memory
+
+# From PyPI (once published)
+pip install fastapi-memory
+
+# With optional Redis cache backend support
+pip install "fastapi-memory[redis]"
+```
+
+## What's inside
+
+| Module       | Provides                                                          | Adds                                                      |
+|--------------|-------------------------------------------------------------------|-----------------------------------------------------------|
+| `caching`    | `FmCacheManager`, `FmMemoryBackend`, `memorize`, `FmRedisBackend` | `init_cache()`, `clear_cache()`                           |
+| `resilience` | `retry`, `stop_after_retries`, `exponential_backoff`, `retry_on_error` | `default_retry()`, `is_retryable_httpx_error()`           |
+| `config`     | `fm_lru`                                                          | `cached_singleton`                                        |
+| `http`       | —                                                                 | `FmResilientClient`                                       |
+
+Everything above is re-exported from the top-level `fastapi_memory` package,
+so `from fastapi_memory import <anything in the table>` works.
+
+---
+
+## Quick start
+
+### Caching — response caching with a single call
+
+```python
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from fastapi_memory import init_cache, clear_cache, memorize
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    init_cache(prefix="app-cache")  # in-memory (default)
+    yield
+
+app = FastAPI(lifespan=lifespan)
+
+@app.get("/api/data")
+@memorize(expire=60)
+async def get_data():
+    return {"data": "computed result"}
+
+@app.post("/api/cache/invalidate")
+async def invalidate_cache():
+    await clear_cache()
+    return {"ok": True}
+```
+
+### Switching to Redis later
+
+```python
+init_cache(backend="redis", prefix="app-cache", redis_url="redis://localhost:6379")
+```
+
+### Retry — exponential backoff with sensible defaults
+
+```python
+from fastapi_memory import default_retry
+
+@default_retry()
+async def call_upstream():
+    resp = await client.get(url)
+    resp.raise_for_status()
+    return resp.json()
+```
+
+`default_retry()` retries up to 3 times with exponential backoff (2s–10s),
+skip 4xx, reraise on final failure. Override any piece:
+
+```python
+@default_retry(attempts=5, wait_max=30)
+async def flaky_call():
+    ...
+```
+
+### Config — cached singleton
+
+```python
+from fastapi_memory import cached_singleton
+
+class Settings:
+    BASE_URL: str = "http://api.example.com:8080"
+    CACHE_TTL: int = 300
+
+@cached_singleton
+def get_settings() -> Settings:
+    return Settings()
+
+config = get_settings()
+```
+
+### Resilient HTTP client
+
+```python
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from fastapi_memory import FmResilientClient, init_cache
+
+upstream = FmResilientClient(
+    base_url="http://api.example.com:8080",
+    timeout=30.0,
+)
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await upstream.start()
+    init_cache(prefix="app-cache")
+    yield
+    await upstream.aclose()
+
+app = FastAPI(lifespan=lifespan)
+
+@app.get("/api/data")
+async def get_data():
+    return await upstream.get_json("data")
+```
+
+`upstream.get_raw(path, params)` is also available if you want the raw
+exceptions instead of `HTTPException`.
+
+---
+
+## Project layout
+
+```
+fastapi-memory/
+├── pyproject.toml
+├── setup.py
+├── README.md
+├── LICENSE
+├── fastapi_memory/
+│   ├── __init__.py          # re-exports everything
+│   ├── caching.py            # FmCacheManager, FmMemoryBackend, memorize, init_cache, clear_cache
+│   ├── resilience.py         # retry + default_retry, is_retryable_httpx_error
+│   ├── config.py             # fm_lru + cached_singleton
+│   └── http.py               # FmResilientClient
+└── tests/
+    └── test_imports.py
+```
+
+## Updating `requirements.txt`
+
+Replace:
+
+```
+tenacity>=8.3.0
+fastapi-cache2>=0.2.2
+redis>=5.0.0
+```
+
+with:
+
+```
+fastapi-memory @ file:///path/to/fastapi-memory
+```
+
+(or once published: `fastapi-memory>=0.1.0`, optionally `fastapi-memory[redis]`.)

fastapi_memory-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+fastapi_memory/__init__.py,sha256=IfdgrQx-vtTVeaBe5cmfwdY0Sk-QdL4x3lNILwfznDU,2047
+fastapi_memory/caching.py,sha256=Jpk6edAsJmdlu-8d_x9wvw_1EfsuxDwYr5BJ2n2DUWw,3673
+fastapi_memory/config.py,sha256=GhAGG3aTw_-Av0py7x_1DZkmRP6FwiPTGCH1sgpcmkI,785
+fastapi_memory/http.py,sha256=05WQ2w2CV6YX7rf8mwc4OxxXf92cFfNOdPhFyCRPqtI,5846
+fastapi_memory/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_memory/resilience.py,sha256=pqG9TzCebTs90gAy-GBE1EDtA-4Ft56Qn5kqQ2wQ8PI,3393
+fastapi_memory-0.1.0.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
+fastapi_memory-0.1.0.dist-info/METADATA,sha256=M7jeNnKPKepT_BUgL3TtMlHDEbUEQk5_DfB509-zSEQ,7126
+fastapi_memory-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fastapi_memory-0.1.0.dist-info/top_level.txt,sha256=SlnFpu4h_DxWXWff3_wTcdv64tx5xEKSd_7j7wN2DgA,15
+fastapi_memory-0.1.0.dist-info/RECORD,,

fastapi_memory-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fastapi_memory-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastapi_memory-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fastapi_memory