Add in-memory support.

Author: long2ice

CHANGELOG.md

@@ -0,0 +1,11 @@
+# ChangeLog
+
+## 0.1
+
+### 0.1.1
+
+- Add in-memory support.
+
+### 0.1.0
+
+- First version release.

README.md

@@ -11,7 +11,7 @@
 
 ## Features
 
-- Support `redis` and `memcache` .
+- Support `redis` and `memcache` and `in-memory` backends.
 - Easily integration with `fastapi`.
 - Support http cache like `ETag` and `Cache-Control`.
 
@@ -23,6 +23,12 @@
 
 ## Install
 
+```shell
+> pip install fastapi-cache2
+```
+
+or
+
 ```shell
 > pip install fastapi-cache2[redis]
 ```
@@ -39,14 +45,13 @@ or
 
 ```python
 import aioredis
-import uvicorn
 from fastapi import FastAPI
 from starlette.requests import Request
 from starlette.responses import Response
 
 from fastapi_cache import FastAPICache
 from fastapi_cache.backends.redis import RedisBackend
-from fastapi_cache.decorator import cache_response, cache
+from fastapi_cache.decorator import cache
 
 app = FastAPI()
 
@@ -57,7 +62,7 @@ async def get_cache():
 
 
 @app.get("/")
-@cache_response(expire=60)
+@cache(expire=60)
 async def index(request: Request, response: Response):
     return dict(hello="world")
 
@@ -69,23 +74,21 @@ async def startup():
 
 ```
 
-### Use `cache_response`
+### Use `cache` decorator
 
-If you want cache `fastapi` response transparently, you can use `cache_response` as decorator between router decorator and view function and must pass `request` as param of view function.
+If you want cache `fastapi` response transparently, you can use `cache` as decorator between router decorator and view function and must pass `request` as param of view function.
 
 And if you want use `ETag` and `Cache-Control` features, you must pass `response` param also.
 
-### Use `cache`
-
-You can use `cache` as decorator like other cache tools to cache common function result.
+You can also use `cache` as decorator like other cache tools to cache common function result.
 
 ### Custom coder
 
 By default use `JsonCoder`, you can write custom coder to encode and decode cache result, just need inherit `fastapi_cache.coder.Coder`.
 
 ```python
 @app.get("/")
-@cache_response(expire=60,coder=JsonCoder)
+@cache(expire=60,coder=JsonCoder)
 async def index(request: Request, response: Response):
     return dict(hello="world")
 ```
@@ -106,11 +109,15 @@ def my_key_builder(
     return cache_key
 
 @app.get("/")
-@cache_response(expire=60,coder=JsonCoder,key_builder=my_key_builder)
+@cache(expire=60,coder=JsonCoder,key_builder=my_key_builder)
 async def index(request: Request, response: Response):
     return dict(hello="world")
 ```
 
+### InMemoryBackend
+
+`InMemoryBackend` only support in single node instead of distributed environment.
+
 ## License
 
 This project is licensed under the [Apache-2.0](https://github.com/long2ice/fastapi-cache/blob/master/LICENSE) License.

examples/main.py

@@ -1,31 +1,33 @@
-import aioredis
 import uvicorn
 from fastapi import FastAPI
 from starlette.requests import Request
 from starlette.responses import Response
 
 from fastapi_cache import FastAPICache
-from fastapi_cache.backends.redis import RedisBackend
-from fastapi_cache.decorator import cache, cache_response
+from fastapi_cache.backends.inmemory import InMemoryBackend
+from fastapi_cache.decorator import cache
 
 app = FastAPI()
 
+ret = 0
 
-@cache()
-async def get_cache():
-    return 1
+
+@cache(expire=1)
+async def get_ret():
+    global ret
+    ret = ret + 1
+    return ret
 
 
 @app.get("/")
-@cache_response(expire=60)
+@cache(expire=2)
 async def index(request: Request, response: Response):
-    return dict(hello="world")
+    return dict(ret=await get_ret())
 
 
 @app.on_event("startup")
 async def startup():
-    redis = await aioredis.create_redis_pool("redis://localhost", encoding="utf8")
-    FastAPICache.init(RedisBackend(redis), prefix="fastapi-cache")
+    FastAPICache.init(InMemoryBackend(), prefix="fastapi-cache")
 
 
 if __name__ == "__main__":

fastapi_cache/__init__.py

@@ -1,11 +1,17 @@
 class FastAPICache:
     _backend = None
     _prefix = None
+    _expire = None
+    _init = False
 
     @classmethod
-    def init(cls, backend, prefix: str = ""):
+    def init(cls, backend, prefix: str = "", expire: int = None):
+        if cls._init:
+            return
+        cls._init = True
         cls._backend = backend
         cls._prefix = prefix
+        cls._expire = expire
 
     @classmethod
     def get_backend(cls):
@@ -14,5 +20,8 @@ def get_backend(cls):
 
     @classmethod
     def get_prefix(cls):
-        assert cls._prefix, "You must call init first!"  # nosec: B101
         return cls._prefix
+
+    @classmethod
+    def get_expire(cls):
+        return cls._expire

fastapi_cache/backends/inmemory.py

@@ -0,0 +1,46 @@
+import time
+from dataclasses import dataclass
+from threading import Lock
+from typing import Dict, Optional, Tuple
+
+from fastapi_cache.backends import Backend
+
+
+@dataclass
+class Value:
+    data: str
+    ttl_ts: int
+
+
+class InMemoryBackend(Backend):
+    _store: Dict[str, Value] = {}
+    _lock = Lock()
+
+    @property
+    def _now(self) -> int:
+        return int(time.time())
+
+    def _get(self, key: str):
+        v = self._store.get(key)
+        if v:
+            if v.ttl_ts < self._now:
+                del self._store[key]
+            else:
+                return v
+
+    async def get_with_ttl(self, key: str) -> Tuple[int, Optional[str]]:
+        with self._lock:
+            v = self._get(key)
+            if v:
+                return v.ttl_ts - self._now, v.data
+            return 0, None
+
+    async def get(self, key: str) -> str:
+        with self._lock:
+            v = self._get(key)
+            if v:
+                return v.data
+
+    async def set(self, key: str, value: str, expire: int = None):
+        with self._lock:
+            self._store[key] = Value(value, self._now + expire)

fastapi_cache/decorator.py

@@ -39,45 +39,19 @@ def cache(
     def wrapper(func):
         @wraps(func)
         async def inner(*args, **kwargs):
+            request = kwargs.get("request")
             backend = FastAPICache.get_backend()
             cache_key = key_builder(func, namespace, *args, **kwargs)
-            ret = await backend.get(cache_key)
-            if ret is not None:
-                return coder.decode(ret)
-
-            ret = await func(*args, **kwargs)
-            await backend.set(cache_key, coder.encode(ret), expire)
-            return ret
-
-        return inner
-
-    return wrapper
-
-
-def cache_response(
-    expire: int = None,
-    coder: Type[Coder] = JsonCoder,
-    key_builder: Callable = default_key_builder,
-    namespace: Optional[str] = "",
-):
-    """
-    cache fastapi response
-    :param namespace:
-    :param expire:
-    :param coder:
-    :param key_builder:
-    :return:
-    """
+            ttl, ret = await backend.get_with_ttl(cache_key)
+            if not request:
+                if ret is not None:
+                    return coder.decode(ret)
+                ret = await func(*args, **kwargs)
+                await backend.set(cache_key, coder.encode(ret), expire or FastAPICache.get_expire())
+                return ret
 
-    def wrapper(func):
-        @wraps(func)
-        async def inner(request: Request, *args, **kwargs):
             if request.method != "GET":
                 return await func(request, *args, **kwargs)
-
-            backend = FastAPICache.get_backend()
-            cache_key = key_builder(func, namespace, request, *args, **kwargs)
-            ttl, ret = await backend.get_with_ttl(cache_key)
             if_none_match = request.headers.get("if-none-match")
             if ret is not None:
                 response = kwargs.get("response")
@@ -90,8 +64,8 @@ async def inner(request: Request, *args, **kwargs):
                     response.headers["ETag"] = etag
                 return coder.decode(ret)
 
-            ret = await func(request, *args, **kwargs)
-            await backend.set(cache_key, coder.encode(ret), expire)
+            ret = await func(*args, **kwargs)
+            await backend.set(cache_key, coder.encode(ret), expire or FastAPICache.get_expire())
             return ret
 
         return inner