Merge remote-tracking branch 'origin/master'

Add support for normal def functions

.github/FUNDING.yml

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

.github/workflows/ci.yml

@@ -8,9 +8,8 @@ jobs:
       - uses: actions/setup-python@v2
         with:
           python-version: "3.x"
-      - name: Install and configure Poetry
+      - uses: abatilo/actions-poetry@v2.1.3
-        uses: snok/install-poetry@v1.1.1
+      - name: Config poetry
-        with:
+        run: poetry config experimental.new-installer false
-          virtualenvs-create: false
       - name: CI
         run: make ci

.github/workflows/pypi.yml

@@ -11,11 +11,13 @@ 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
         uses: pypa/gh-action-pypi-publish@master
         with:
           user: __token__
-          password: ${{ secrets.pypi_password }}
+          password: ${{ secrets.pypi_password }}

CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## 0.1
 
+### 0.1.9
+
+- Replace `aioredis` with `redis-py`.
+
+### 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.

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,20 @@ deps:
 	@poetry install --no-root -E all
 
 style: deps
-	@isort -src $(checkfiles)
+	@poetry run isort -src $(checkfiles)
-	@black $(black_opts) $(checkfiles)
+	@poetry run black $(checkfiles)
 
 check: deps
-	@black --check $(black_opts) $(checkfiles) || (echo "Please run 'make style' to auto-fix style issues" && false)
+	@poetry run black $(checkfiles) || (echo "Please run 'make style' to auto-fix style issues" && false)
-	@flake8 $(checkfiles)
+	@poetry run flake8 $(checkfiles)
-	@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,7 +76,7 @@ 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")
 
 ```
@@ -82,6 +89,14 @@ Firstly you must call `FastAPICache.init` on startup event of `fastapi`, there a
 
 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.

examples/main.py

@@ -1,10 +1,15 @@
+from datetime import date, datetime
+import time
+
+import redis.asyncio as redis
 import uvicorn
 from fastapi import FastAPI
+from redis.asyncio.connection import ConnectionPool
 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()
@@ -20,7 +25,7 @@ async def get_ret():
 
 
 @app.get("/")
-@cache(namespace="test", expire=2)
+@cache(namespace="test", expire=20)
 async def index(request: Request, response: Response):
     return dict(ret=await get_ret())
 
@@ -30,9 +35,30 @@ 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("/blocking")
+@cache(namespace="test", expire=20)
+def blocking(request: Request, response: Response):
+    time.sleep(5)
+    return dict(ret=get_ret())
+
+
+@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")
+    pool = ConnectionPool.from_url(url="redis://localhost")
+    r = redis.Redis(connection_pool=pool)
+    FastAPICache.init(RedisBackend(r), prefix="fastapi-cache")
 
 
 if __name__ == "__main__":

fastapi_cache/__init__.py

@@ -11,6 +11,7 @@ class FastAPICache:
     _init = False
     _coder = None
     _key_builder = None
+    _enable = True
 
     @classmethod
     def init(
@@ -20,6 +21,7 @@ class FastAPICache:
         expire: int = None,
         coder: Coder = JsonCoder,
         key_builder: Callable = default_key_builder,
+        enable: bool = True,
     ):
         if cls._init:
             return
@@ -29,6 +31,7 @@ class FastAPICache:
         cls._expire = expire
         cls._coder = coder
         cls._key_builder = key_builder
+        cls._enable = enable
 
     @classmethod
     def get_backend(cls):
@@ -51,6 +54,10 @@ class FastAPICache:
     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

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

@@ -43,7 +43,7 @@ class InMemoryBackend(Backend):
 
     async def set(self, key: str, value: str, expire: int = None):
         async with self._lock:
-            self._store[key] = Value(value, self._now + expire)
+            self._store[key] = Value(value, self._now + (expire or 0))
 
     async def clear(self, namespace: str = None, key: str = None) -> int:
         count = 0

fastapi_cache/backends/memcached.py

@@ -16,7 +16,7 @@ class MemcachedBackend(Backend):
         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

@@ -1,6 +1,6 @@
 from typing import Tuple
 
-from aioredis import Redis
+from redis.asyncio.client import Redis
 
 from fastapi_cache.backends import Backend
 
@@ -10,20 +10,18 @@ class RedisBackend(Backend):
         self.redis = redis
 
     async def get_with_ttl(self, key: str) -> Tuple[int, str]:
-        p = self.redis.pipeline()
+        async with self.redis.pipeline(transaction=True) as pipe:
-        p.ttl(key)
+            return await (pipe.ttl(key).get(key).execute())
-        p.get(key)
-        return await p.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)
+            return await self.redis.eval(lua, numkeys=0)
         elif key:
             return await self.redis.delete(key)

fastapi_cache/coder.py

@@ -4,11 +4,12 @@ import pickle  # nosec:B403
 from decimal import Decimal
 from typing import Any
 
-import dateutil.parser
+import pendulum
+from fastapi.encoders import jsonable_encoder
 
 CONVERTERS = {
-    "date": dateutil.parser.parse,
+    "date": lambda x: pendulum.parse(x, exact=True),
-    "datetime": dateutil.parser.parse,
+    "datetime": lambda x: pendulum.parse(x, exact=True),
     "decimal": Decimal,
 }
 
@@ -16,13 +17,13 @@ CONVERTERS = {
 class JsonEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, datetime.datetime):
-            return {"val": obj.strftime("%Y-%m-%d %H:%M:%S"), "_spec_type": "datetime"}
+            return {"val": str(obj), "_spec_type": "datetime"}
         elif isinstance(obj, datetime.date):
-            return {"val": obj.strftime("%Y-%m-%d"), "_spec_type": "date"}
+            return {"val": str(obj), "_spec_type": "date"}
         elif isinstance(obj, Decimal):
             return {"val": str(obj), "_spec_type": "decimal"}
         else:
-            return super().default(obj)
+            return jsonable_encoder(obj)
 
 
 def object_hook(obj):
@@ -63,4 +64,4 @@ class PickleCoder(Coder):
 
     @classmethod
     def decode(cls, value: Any):
-        return pickle.loads(value)  # nosec:B403
+        return pickle.loads(value)  # nosec:B403,B301

fastapi_cache/decorator.py

@@ -1,15 +1,21 @@
-from functools import wraps
+import asyncio
-from typing import Callable, Optional, Type
+from functools import wraps, partial
+import inspect
+from typing import TYPE_CHECKING, Callable, Optional, Type
 
 from fastapi_cache import FastAPICache
 from fastapi_cache.coder import Coder
 
+if TYPE_CHECKING:
+    import concurrent.futures
+
 
 def cache(
     expire: int = None,
     coder: Type[Coder] = None,
     key_builder: Callable = None,
     namespace: Optional[str] = "",
+    executor: Optional["concurrent.futures.Executor"] = None,
 ):
     """
     cache all function
@@ -17,6 +23,8 @@ def cache(
     :param expire:
     :param coder:
     :param key_builder:
+    :param executor:
+
     :return:
     """
 
@@ -26,17 +34,22 @@ def cache(
             nonlocal coder
             nonlocal expire
             nonlocal key_builder
-            request = kwargs.get("request")
+            copy_kwargs = kwargs.copy()
-            if request.headers.get("Cache-Control") == "no-store":
+            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()
-            request = kwargs.pop("request", None)
-            response = kwargs.pop("response", None)
             backend = FastAPICache.get_backend()
-            cache_key = key_builder(func, namespace, args=args, kwargs=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:
@@ -49,7 +62,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)}"
@@ -59,7 +71,12 @@ def cache(
                     response.headers["ETag"] = etag
                 return coder.decode(ret)
 
-            ret = await func(*args, **kwargs)
+            if inspect.iscoroutinefunction(func):
+                ret = await func(*args, **kwargs)
+            else:
+                loop = asyncio.get_event_loop()
+                ret = await loop.run_in_executor(executor, partial(func, *args, **kwargs))
+
             await backend.set(cache_key, coder.encode(ret), expire or FastAPICache.get_expire())
             return ret
 

fastapi_cache/key_builder.py

@@ -1,3 +1,4 @@
+import hashlib
 from typing import Optional
 
 from starlette.requests import Request
@@ -14,6 +15,11 @@ def default_key_builder(
 ):
     from fastapi_cache import FastAPICache
 
-    prefix = FastAPICache.get_prefix()
+    prefix = f"{FastAPICache.get_prefix()}:{namespace}:"
-    cache_key = f"{prefix}:{namespace}:{func.__module__}:{func.__name__}:{args}:{kwargs}"
+    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.3"
+version = "0.1.9"
 description = "Cache for FastAPI"
 authors = ["long2ice <long2ice@gmail.com>"]
 license = "Apache-2.0"
@@ -18,22 +18,27 @@ include = ["LICENSE", "README.md"]
 python = "^3.7"
 fastapi = "*"
 uvicorn = "*"
-aioredis = {version = "*", optional = true}
+redis = { version = "^4.2.0rc1", optional = true }
-aiomcache = {version = "*", optional = true}
+aiomcache = { version = "*", optional = true }
-python-dateutil = "*"
+pendulum = "*"
+aiobotocore = { version = "^1.4.1", optional = true }
 
 [tool.poetry.dev-dependencies]
 flake8 = "*"
 isort = "*"
-black = "^19.10b0"
+black = "*"
 pytest = "*"
-bandit = "*"
 
 [build-system]
 requires = ["poetry>=0.12"]
 build-backend = "poetry.masonry.api"
 
 [tool.poetry.extras]
-redis = ["aioredis"]
+redis = ["redis"]
 memcache = ["aiomcache"]
-all = ["aioredis","aiomcache"]
+dynamodb = ["aiobotocore"]
+all = ["redis", "aiomcache", "aiobotocore"]
+
+[tool.black]
+line-length = 100
+target-version = ['py36', 'py37', 'py38', 'py39']