update version and changelog

Add dynamodb backend support

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+custom: ["https://sponsor.long2ice.io"]
+

.github/workflows/ci.yml

@@ -1,5 +1,5 @@
 name: ci
-on: [push, pull_request]
+on: [ push, pull_request ]
 jobs:
   ci:
     runs-on: ubuntu-latest
@@ -8,6 +8,8 @@ jobs:
       - uses: actions/setup-python@v2
         with:
           python-version: "3.x"
-      - uses: dschep/install-poetry-action@v1.3
+      - uses: abatilo/actions-poetry@v2.1.3
+      - name: Config poetry
+        run: poetry config experimental.new-installer false
       - name: CI
         run: make ci

.github/workflows/pypi.yml

@@ -11,7 +11,9 @@ jobs:
       - uses: actions/setup-python@v1
         with:
           python-version: '3.x'
-      - uses: dschep/install-poetry-action@v1.3
+      - uses: abatilo/actions-poetry@v2.1.3
+      - name: Config poetry
+        run: poetry config experimental.new-installer false
       - name: Build dists
         run: make build
       - name: Pypi Publish

CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## 0.1
 
+### 0.1.8
+
+- Support `dynamodb` backend.
+
+### 0.1.7
+
+- Fix default json coder for datetime.
+- Add `enable` param to `init`.
+
+### 0.1.6
+
+- Fix redis cache.
+- Encode key builder.
+
+### 0.1.5
+
+- Fix setting expire for redis (#24)
+- Update expire key
+
+### 0.1.4
+
+- Fix default expire for memcached. (#13)
+- Update default key builder. (#12)
+
+### 0.1.3
+
+- Fix cache key builder.
+
+### 0.1.2
+
+- Add default config when init.
+- Update JsonEncoder.
+
 ### 0.1.1
 
 - Add in-memory support.

Makefile

@@ -1,19 +1,6 @@
 checkfiles = fastapi_cache/ examples/ tests/
-black_opts = -l 100 -t py38
 py_warn = PYTHONDEVMODE=1
 
-help:
-	@echo "FastAPI-Cache development makefile"
-	@echo
-	@echo  "usage: make <target>"
-	@echo  "Targets:"
-	@echo  "    up			Ensure dev/test dependencies are updated"
-	@echo  "    deps		Ensure dev/test dependencies are installed"
-	@echo  "    check		Checks that build is sane"
-	@echo  "    test		Runs all tests"
-	@echo  "    style		Auto-formats the code"
-	@echo  "    build		Build package"
-
 up:
 	@poetry update
 
@@ -21,18 +8,21 @@ deps:
 	@poetry install --no-root -E all
 
 style: deps
-	@isort -src $(checkfiles)
-	@black $(black_opts) $(checkfiles)
+	@poetry run isort -src $(checkfiles)
+	@poetry run black $(checkfiles)
 
 check: deps
-	@black --check $(black_opts) $(checkfiles) || (echo "Please run 'make style' to auto-fix style issues" && false)
-	@flake8 $(checkfiles)
-	@bandit -r $(checkfiles)
+	@poetry run black $(checkfiles) || (echo "Please run 'make style' to auto-fix style issues" && false)
+	@poetry run flake8 $(checkfiles)
+	@poetry run bandit -r $(checkfiles)
 
 test: deps
-	$(py_warn) pytest
+	$(py_warn) poetry run pytest
 
-build: deps
+build: clean deps
 	@poetry build
 
+clean:
+	@rm -rf ./dist
+
 ci: check test

README.md

@@ -7,11 +7,11 @@
 
 ## Introduction
 
-`fastapi-cache` is a tool to cache fastapi response and function result, with backends support `redis` and `memcache`.
+`fastapi-cache` is a tool to cache fastapi response and function result, with backends support `redis`, `memcache`, and `dynamodb`.
 
 ## Features
 
-- Support `redis` and `memcache` and `in-memory` backends.
+- Support `redis`, `memcache`, `dynamodb`, and `in-memory` backends.
 - Easily integration with `fastapi`.
 - Support http cache like `ETag` and `Cache-Control`.
 
@@ -20,6 +20,7 @@
 - `asyncio` environment.
 - `redis` if use `RedisBackend`.
 - `memcache` if use `MemcacheBackend`.
+- `aiobotocore` if use `DynamoBackend`.
 
 ## Install
 
@@ -30,13 +31,19 @@
 or
 
 ```shell
-> pip install fastapi-cache2[redis]
+> pip install "fastapi-cache2[redis]"
 ```
 
 or
 
 ```shell
-> pip install fastapi-cache2[memcache]
+> pip install "fastapi-cache2[memcache]"
+```
+
+or
+
+```shell
+> pip install "fastapi-cache2[dynamodb]"
 ```
 
 ## Usage
@@ -69,15 +76,27 @@ async def index(request: Request, response: Response):
 
 @app.on_event("startup")
 async def startup():
-    redis = await aioredis.create_redis_pool("redis://localhost", encoding="utf8")
+    redis =  aioredis.from_url("redis://localhost", encoding="utf8", decode_responses=True)
     FastAPICache.init(RedisBackend(redis), prefix="fastapi-cache")
 
 ```
 
+### Initialization
+
+Firstly you must call `FastAPICache.init` on startup event of `fastapi`, there are some global config you can pass in.
+
 ### Use `cache` decorator
 
 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.
 
+Parameter | type, description
+------------ | -------------
+expire | int, states a caching time in seconds
+namespace | str, namespace to use to store certain cache items
+coder | which coder to use, e.g. JsonCoder
+key_builder | which key builder to use, default to builtin
+
+
 And if you want use `ETag` and `Cache-Control` features, you must pass `response` param also.
 
 You can also use `cache` as decorator like other cache tools to cache common function result.
@@ -95,6 +114,8 @@ async def index(request: Request, response: Response):
 
 ### Custom key builder
 
+By default use builtin key builder, if you need, you can override this and pass in `cache` or `FastAPICache.init` to take effect globally.
+
 ```python
 def my_key_builder(
     func,
@@ -116,7 +137,7 @@ async def index(request: Request, response: Response):
 
 ### InMemoryBackend
 
-`InMemoryBackend` only support in single node instead of distributed environment.
+`InMemoryBackend` store cache data in memory and use lazy delete, which mean if you don't access it after cached, it will not delete automatically.
 
 ## License
 

examples/main.py

@@ -1,10 +1,13 @@
+from datetime import date, datetime
+
+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.inmemory import InMemoryBackend
+from fastapi_cache.backends.redis import RedisBackend
 from fastapi_cache.decorator import cache
 
 app = FastAPI()
@@ -12,7 +15,7 @@ app = FastAPI()
 ret = 0
 
 
-@cache(expire=1)
+@cache(namespace="test", expire=1)
 async def get_ret():
     global ret
     ret = ret + 1
@@ -20,14 +23,32 @@ async def get_ret():
 
 
 @app.get("/")
-@cache(expire=2)
+@cache(namespace="test", expire=20)
 async def index(request: Request, response: Response):
     return dict(ret=await get_ret())
 
 
+@app.get("/clear")
+async def clear():
+    return await FastAPICache.clear(namespace="test")
+
+
+@app.get("/date")
+@cache(namespace="test", expire=20)
+async def get_data(request: Request, response: Response):
+    return date.today()
+
+
+@app.get("/datetime")
+@cache(namespace="test", expire=20)
+async def get_datetime(request: Request, response: Response):
+    return datetime.now()
+
+
 @app.on_event("startup")
 async def startup():
-    FastAPICache.init(InMemoryBackend(), prefix="fastapi-cache")
+    redis = aioredis.from_url(url="redis://localhost")
+    FastAPICache.init(RedisBackend(redis), prefix="fastapi-cache")
 
 
 if __name__ == "__main__":

fastapi_cache/__init__.py

@@ -1,17 +1,37 @@
+from typing import Callable
+
+from fastapi_cache.coder import Coder, JsonCoder
+from fastapi_cache.key_builder import default_key_builder
+
+
 class FastAPICache:
     _backend = None
     _prefix = None
     _expire = None
     _init = False
+    _coder = None
+    _key_builder = None
+    _enable = True
 
     @classmethod
-    def init(cls, backend, prefix: str = "", expire: int = None):
+    def init(
+        cls,
+        backend,
+        prefix: str = "",
+        expire: int = None,
+        coder: Coder = JsonCoder,
+        key_builder: Callable = default_key_builder,
+        enable: bool = True,
+    ):
         if cls._init:
             return
         cls._init = True
         cls._backend = backend
         cls._prefix = prefix
         cls._expire = expire
+        cls._coder = coder
+        cls._key_builder = key_builder
+        cls._enable = enable
 
     @classmethod
     def get_backend(cls):
@@ -25,3 +45,20 @@ class FastAPICache:
     @classmethod
     def get_expire(cls):
         return cls._expire
+
+    @classmethod
+    def get_coder(cls):
+        return cls._coder
+
+    @classmethod
+    def get_key_builder(cls):
+        return cls._key_builder
+
+    @classmethod
+    def get_enable(cls):
+        return cls._enable
+
+    @classmethod
+    async def clear(cls, namespace: str = None, key: str = None):
+        namespace = cls._prefix + ":" + namespace if namespace else None
+        return await cls._backend.clear(namespace, key)

fastapi_cache/backends/__init__.py

@@ -14,3 +14,7 @@ class Backend:
     @abc.abstractmethod
     async def set(self, key: str, value: str, expire: int = None):
         raise NotImplementedError
+
+    @abc.abstractmethod
+    async def clear(self, namespace: str = None, key: str = None) -> int:
+        raise NotImplementedError

fastapi_cache/backends/dynamodb.py

@@ -0,0 +1,92 @@
+import datetime
+from typing import Tuple
+
+from aiobotocore.session import get_session
+
+from fastapi_cache.backends import Backend
+
+
+class DynamoBackend(Backend):
+    """
+    Amazon DynamoDB backend provider
+
+    This backend requires an existing table within your AWS environment to be passed during
+    backend init. If ttl is going to be used, this needs to be manually enabled on the table
+    using the `ttl` key. Dynamo will take care of deleting outdated objects, but this is not
+    instant so don't be alarmed when they linger around for a bit.
+
+    As with all AWS clients, credentials will be taken from the environment. Check the AWS SDK
+    for more information.
+
+    Usage:
+        >> dynamodb = DynamoBackend(table_name="your-cache", region="eu-west-1")
+        >> await dynamodb.init()
+        >> FastAPICache.init(dynamodb)
+    """
+
+    def __init__(self, table_name, region=None):
+        self.session = get_session()
+        self.client = None  # Needs async init
+        self.table_name = table_name
+        self.region = region
+
+    async def init(self):
+        self.client = await self.session.create_client(
+            "dynamodb", region_name=self.region
+        ).__aenter__()
+
+    async def close(self):
+        self.client = await self.client.__aexit__(None, None, None)
+
+    async def get_with_ttl(self, key: str) -> Tuple[int, str]:
+        response = await self.client.get_item(TableName=self.table_name, Key={"key": {"S": key}})
+
+        if "Item" in response:
+            value = response["Item"].get("value", {}).get("S")
+            ttl = response["Item"].get("ttl", {}).get("N")
+
+            if not ttl:
+                return -1, value
+
+            # It's only eventually consistent so we need to check ourselves
+            expire = int(ttl) - int(datetime.datetime.now().timestamp())
+            if expire > 0:
+                return expire, value
+
+        return 0, None
+
+    async def get(self, key) -> str:
+        response = await self.client.get_item(TableName=self.table_name, Key={"key": {"S": key}})
+        if "Item" in response:
+            return response["Item"].get("value", {}).get("S")
+
+    async def set(self, key: str, value: str, expire: int = None):
+        ttl = (
+            {
+                "ttl": {
+                    "N": str(
+                        int(
+                            (
+                                datetime.datetime.now() + datetime.timedelta(seconds=expire)
+                            ).timestamp()
+                        )
+                    )
+                }
+            }
+            if expire
+            else {}
+        )
+
+        await self.client.put_item(
+            TableName=self.table_name,
+            Item={
+                **{
+                    "key": {"S": key},
+                    "value": {"S": value},
+                },
+                **ttl,
+            },
+        )
+
+    async def clear(self, namespace: str = None, key: str = None) -> int:
+        raise NotImplementedError

fastapi_cache/backends/inmemory.py

@@ -1,6 +1,6 @@
 import time
+from asyncio import Lock
 from dataclasses import dataclass
-from threading import Lock
 from typing import Dict, Optional, Tuple
 
 from fastapi_cache.backends import Backend
@@ -29,18 +29,31 @@ class InMemoryBackend(Backend):
                 return v
 
     async def get_with_ttl(self, key: str) -> Tuple[int, Optional[str]]:
-        with self._lock:
+        async 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:
+        async 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)
+        async with self._lock:
+            self._store[key] = Value(value, self._now + expire or 0)
+
+    async def clear(self, namespace: str = None, key: str = None) -> int:
+        count = 0
+        if namespace:
+            keys = list(self._store.keys())
+            for key in keys:
+                if key.startswith(namespace):
+                    del self._store[key]
+                    count += 1
+        elif key:
+            del self._store[key]
+            count += 1
+        return count

fastapi_cache/backends/memcached.py

@@ -5,15 +5,18 @@ from aiomcache import Client
 from fastapi_cache.backends import Backend
 
 
-class MemcacheBackend(Backend):
+class MemcachedBackend(Backend):
     def __init__(self, mcache: Client):
         self.mcache = mcache
 
     async def get_with_ttl(self, key: str) -> Tuple[int, str]:
-        return 0, await self.mcache.get(key.encode())
+        return 3600, await self.mcache.get(key.encode())
 
     async def get(self, key: str):
         return await self.mcache.get(key, key.encode())
 
     async def set(self, key: str, value: str, expire: int = None):
-        return await self.mcache.set(key.encode(), value.encode(), exptime=expire)
+        return await self.mcache.set(key.encode(), value.encode(), exptime=expire or 0)
+
+    async def clear(self, namespace: str = None, key: str = None):
+        raise NotImplementedError

fastapi_cache/backends/redis.py

@@ -10,13 +10,18 @@ class RedisBackend(Backend):
         self.redis = redis
 
     async def get_with_ttl(self, key: str) -> Tuple[int, str]:
-        p = self.redis.pipeline()
-        p.ttl(key)
-        p.get(key)
-        return await p.execute()
+        async with self.redis.pipeline(transaction=True) as pipe:
+            return await (pipe.ttl(key).get(key).execute())
 
     async def get(self, key) -> str:
         return await self.redis.get(key)
 
     async def set(self, key: str, value: str, expire: int = None):
-        return await self.redis.set(key, value, expire=expire)
+        return await self.redis.set(key, value, ex=expire)
+
+    async def clear(self, namespace: str = None, key: str = None) -> int:
+        if namespace:
+            lua = f"for i, name in ipairs(redis.call('KEYS', '{namespace}:*')) do redis.call('DEL', name); end"
+            return await self.redis.eval(lua, numkeys=0)
+        elif key:
+            return await self.redis.delete(key)

fastapi_cache/coder.py

@@ -1,7 +1,41 @@
+import datetime
 import json
 import pickle  # nosec:B403
+from decimal import Decimal
 from typing import Any
 
+import pendulum
+from fastapi.encoders import jsonable_encoder
+
+CONVERTERS = {
+    "date": lambda x: pendulum.parse(x, exact=True),
+    "datetime": lambda x: pendulum.parse(x, exact=True),
+    "decimal": Decimal,
+}
+
+
+class JsonEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, datetime.datetime):
+            return {"val": str(obj), "_spec_type": "datetime"}
+        elif isinstance(obj, datetime.date):
+            return {"val": str(obj), "_spec_type": "date"}
+        elif isinstance(obj, Decimal):
+            return {"val": str(obj), "_spec_type": "decimal"}
+        else:
+            return jsonable_encoder(obj)
+
+
+def object_hook(obj):
+    _spec_type = obj.get("_spec_type")
+    if not _spec_type:
+        return obj
+
+    if _spec_type in CONVERTERS:
+        return CONVERTERS[_spec_type](obj["val"])
+    else:
+        raise TypeError("Unknown {}".format(_spec_type))
+
 
 class Coder:
     @classmethod
@@ -16,11 +50,11 @@ class Coder:
 class JsonCoder(Coder):
     @classmethod
     def encode(cls, value: Any):
-        return json.dumps(value)
+        return json.dumps(value, cls=JsonEncoder)
 
     @classmethod
     def decode(cls, value: Any):
-        return json.loads(value)
+        return json.loads(value, object_hook=object_hook)
 
 
 class PickleCoder(Coder):

fastapi_cache/decorator.py

@@ -1,30 +1,14 @@
 from functools import wraps
 from typing import Callable, Optional, Type
 
-from starlette.requests import Request
-from starlette.responses import Response
-
 from fastapi_cache import FastAPICache
-from fastapi_cache.coder import Coder, JsonCoder
-
-
-def default_key_builder(
-    func,
-    namespace: Optional[str] = "",
-    request: Request = None,
-    response: Response = None,
-    *args,
-    **kwargs,
-):
-    prefix = FastAPICache.get_prefix()
-    cache_key = f"{prefix}:{namespace}:{func.__module__}:{func.__name__}:{args}:{kwargs}"
-    return cache_key
+from fastapi_cache.coder import Coder
 
 
 def cache(
     expire: int = None,
-    coder: Type[Coder] = JsonCoder,
-    key_builder: Callable = default_key_builder,
+    coder: Type[Coder] = None,
+    key_builder: Callable = None,
     namespace: Optional[str] = "",
 ):
     """
@@ -39,9 +23,25 @@ def cache(
     def wrapper(func):
         @wraps(func)
         async def inner(*args, **kwargs):
-            request = kwargs.get("request")
+            nonlocal coder
+            nonlocal expire
+            nonlocal key_builder
+            copy_kwargs = kwargs.copy()
+            request = copy_kwargs.pop("request", None)
+            response = copy_kwargs.pop("response", None)
+            if (
+                request and request.headers.get("Cache-Control") == "no-store"
+            ) or not FastAPICache.get_enable():
+                return await func(*args, **kwargs)
+
+            coder = coder or FastAPICache.get_coder()
+            expire = expire or FastAPICache.get_expire()
+            key_builder = key_builder or FastAPICache.get_key_builder()
             backend = FastAPICache.get_backend()
-            cache_key = key_builder(func, namespace, *args, **kwargs)
+
+            cache_key = key_builder(
+                func, namespace, request=request, response=response, args=args, kwargs=copy_kwargs
+            )
             ttl, ret = await backend.get_with_ttl(cache_key)
             if not request:
                 if ret is not None:
@@ -54,7 +54,6 @@ def cache(
                 return await func(request, *args, **kwargs)
             if_none_match = request.headers.get("if-none-match")
             if ret is not None:
-                response = kwargs.get("response")
                 if response:
                     response.headers["Cache-Control"] = f"max-age={ttl}"
                     etag = f"W/{hash(ret)}"

fastapi_cache/key_builder.py

@@ -0,0 +1,25 @@
+import hashlib
+from typing import Optional
+
+from starlette.requests import Request
+from starlette.responses import Response
+
+
+def default_key_builder(
+    func,
+    namespace: Optional[str] = "",
+    request: Optional[Request] = None,
+    response: Optional[Response] = None,
+    args: Optional[tuple] = None,
+    kwargs: Optional[dict] = None,
+):
+    from fastapi_cache import FastAPICache
+
+    prefix = f"{FastAPICache.get_prefix()}:{namespace}:"
+    cache_key = (
+        prefix
+        + hashlib.md5(  # nosec:B303
+            f"{func.__module__}:{func.__name__}:{args}:{kwargs}".encode()
+        ).hexdigest()
+    )
+    return cache_key

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fastapi-cache2"
-version = "0.1.1"
+version = "0.1.8"
 description = "Cache for FastAPI"
 authors = ["long2ice <long2ice@gmail.com>"]
 license = "Apache-2.0"
@@ -18,13 +18,15 @@ include = ["LICENSE", "README.md"]
 python = "^3.7"
 fastapi = "*"
 uvicorn = "*"
-aioredis = {version = "*", optional = true}
+aioredis = {version = "^2.0", optional = true}
 aiomcache = {version = "*", optional = true}
+pendulum = "*"
+aiobotocore = {version = "^1.4.1", optional = true}
 
 [tool.poetry.dev-dependencies]
 flake8 = "*"
 isort = "*"
-black = "^19.10b0"
+black = "*"
 pytest = "*"
 bandit = "*"
 
@@ -35,4 +37,9 @@ build-backend = "poetry.masonry.api"
 [tool.poetry.extras]
 redis = ["aioredis"]
 memcache = ["aiomcache"]
+dynamodb = ["aiobotocore"]
 all = ["aioredis","aiomcache"]
+
+[tool.black]
+line-length = 100
+target-version = ['py36', 'py37', 'py38', 'py39']