fix(backend): fix redis backend and add kwargs param to every backend…

… for more flexibility

mkdocs.yml

@@ -1,8 +1,6 @@
 site_name: Starlette Session
 site_description: Session middleware for starlette.
-
-site_name: Starlette Session
-site_description: Session middleware for starlette.
+
 site_url: "https://auredentan.github.io/starlette-session"
 repo_url: "https://github.com/auredentan/starlette-session"
 repo_name: "auredentan/starlette-session"
@@ -34,4 +32,4 @@ plugins:
             - import sys
             - sys.path.append("docs")
       watch:
-        - starlette_session
+        - starlette_session

starlette_session/backends.py

@@ -9,10 +9,12 @@
 except ImportError:
     Redis = None  # type: ignore
 
+AioRedis: Any = None
 try:
-    from aioredis import Redis as AioRedis
+    from aioredis import Redis as _AioRedis
+    AioRedis = _AioRedis
 except ImportError:
-    AioRedis = None  # pragma: no cover
+    pass
 
 try:
     from pymemcache.client.base import Client as Memcache
@@ -59,67 +61,67 @@ class RedisSessionBackend(ISessionBackend):
     def __init__(self, redis: Redis):
         self.redis = redis
 
-    async def get(self, key: str) -> Optional[dict]:
-        value = self.redis.get(key)
+    async def get(self, key: str, **kwargs: dict) -> Optional[dict]:
+        value = self.redis.get(key, **kwargs)
         return _loads(value) if value else None
 
     async def set(
-        self, key: str, value: dict, exp: Optional[int] = None
+        self, key: str, value: dict, exp: Optional[int] = None, **kwargs: dict
     ) -> Optional[str]:
-        self.redis.set(key, _dumps(value), exp)
+        self.redis.set(key, _dumps(value), exp, **kwargs)
         return None
 
-    async def delete(self, key: str) -> Any:
-        return self.redis.delete(key)
+    async def delete(self, key: str, **kwargs: dict) -> Any:
+        return self.redis.delete(key, **kwargs)
 
 
 class AioRedisSessionBackend(ISessionBackend):
     def __init__(self, redis: AioRedis):  # pragma: no cover
         self.redis = redis
 
-    async def get(self, key: str) -> Optional[dict]:  # pragma: no cover
-        value = await self.redis.get(key)
+    async def get(self, key: str, **kwargs: dict) -> Optional[dict]:  # pragma: no cover
+        value = await self.redis.get(key, **kwargs)
         return _loads(value) if value else None
 
     async def set(
-        self, key: str, value: dict, exp: Optional[int] = None
+        self, key: str, value: dict, exp: Optional[int] = None, **kwargs
     ) -> Optional[str]:  # pragma: no cover
-        return await self.redis.set(key, _dumps(value), expire=exp)
+        return await self.redis.set(key, _dumps(value), exp, **kwargs)
 
-    async def delete(self, key: str) -> Any:  # pragma: no cover
-        return await self.redis.delete(key)
+    async def delete(self, key: str, **kwargs: dict) -> Any:  # pragma: no cover
+        return await self.redis.delete(key, **kwargs)
 
 
 class MemcacheSessionBackend(ISessionBackend):
     def __init__(self, memcache: Memcache):
         self.memcache = memcache
         self.memcache.serde = MemcacheJSONSerde()
 
-    async def get(self, key: str) -> Optional[dict]:
-        value = self.memcache.get(key)
+    async def get(self, key: str, **kwargs: dict) -> Optional[dict]:
+        value = self.memcache.get(key, **kwargs)
         return value if value else None
 
     async def set(
-        self, key: str, value: dict, exp: Optional[int] = None
+        self, key: str, value: dict, exp: Optional[int] = None, **kwargs: dict
     ) -> Optional[str]:
-        return self.memcache.set(key, value, expire=exp)
+        return self.memcache.set(key, value, expire=exp, **kwargs)
 
-    async def delete(self, key: str) -> Any:
-        return self.memcache.delete(key)
+    async def delete(self, key: str, **kwargs: dict) -> Any:
+        return self.memcache.delete(key, **kwargs)
 
 
 class AioMemcacheSessionBackend(ISessionBackend):
     def __init__(self, memcache: AioMemcache):  # pragma: no cover
         self.memcache = memcache
 
-    async def get(self, key: str) -> Optional[dict]:  # pragma: no cover
-        value = await self.memcache.get(key.encode())
+    async def get(self, key: str, **kwargs: dict) -> Optional[dict]:  # pragma: no cover
+        value = await self.memcache.get(key.encode(), **kwargs)
         return _loads(value) if value else None
 
     async def set(
-        self, key: str, value: dict, exp: Optional[int] = None
+        self, key: str, value: dict, exp: Optional[int] = None, **kwargs: dict
     ) -> Optional[str]:  # pragma: no cover
-        return await self.memcache.set(key.encode(), _dumps(value), exptime=exp)
+        return await self.memcache.set(key.encode(), _dumps(value), exptime=exp, **kwargs)
 
-    async def delete(self, key: str) -> Any:  # pragma: no cover
-        return await self.memcache.delete(key.encode())
+    async def delete(self, key: str, **kwargs: dict) -> Any:  # pragma: no cover
+        return await self.memcache.delete(key.encode(), **kwargs)