fastapi-alcazaba 0.1.0__py3-none-any.whl

fastapi_alcazaba/__init__.py

@@ -0,0 +1,125 @@
+from importlib.metadata import PackageNotFoundError, version
+from typing import Any, ClassVar
+
+from fastapi_alcazaba.cache import (
+    DEFAULT_VARY_HEADERS,
+    Cache,
+    CacheOptions,
+    get_cache,
+    normalise_headers,
+    warn_unsigned,
+)
+from fastapi_alcazaba.coder import Coder, JsonCoder
+from fastapi_alcazaba.errors import (
+    BackendUnavailable,
+    UnsignedEntriesWarning,
+    UnstableCacheKeyWarning,
+)
+from fastapi_alcazaba.key_builder import default_key_builder
+from fastapi_alcazaba.metrics import Metrics
+from fastapi_alcazaba.resilience import BackendGuard
+from fastapi_alcazaba.types import Backend, KeyBuilder
+
+try:
+    __version__ = version("fastapi-alcazaba")
+except PackageNotFoundError:  # running from a source checkout that isn't installed
+    __version__ = "0.0.0"
+
+__all__ = [
+    "DEFAULT_VARY_HEADERS",
+    "Backend",
+    "BackendUnavailable",
+    "Cache",
+    "CacheOptions",
+    "Coder",
+    "FastAPICache",
+    "JsonCoder",
+    "KeyBuilder",
+    "UnsignedEntriesWarning",
+    "UnstableCacheKeyWarning",
+    "default_key_builder",
+    "get_cache",
+    "normalise_headers",
+    "warn_unsigned",
+]
+
+
+class FastAPICache:
+    """The global cache that `@cache` uses: a Cache configured once with `init()`. The API of
+    fastapi-cache2; for several caches, or one per app, create Cache instances instead."""
+
+    _instance: ClassVar[Cache | None] = None
+
+    @classmethod
+    def init(cls, backend: Backend, *args: Any, **kwargs: Any) -> None:
+        """Configure the global cache, with the arguments of `Cache`; later calls are ignored
+        until `reset()`."""
+        if cls._instance is None:
+            cls._instance = Cache(backend, *args, **kwargs)
+
+    @classmethod
+    def reset(cls) -> None:
+        cls._instance = None
+
+    @classmethod
+    def instance(cls) -> Cache:
+        if cls._instance is None:
+            raise RuntimeError(
+                "FastAPICache.init() hasn't been called (or decorate with a Cache's cached())"
+            )
+        return cls._instance
+
+    @classmethod
+    def get_backend(cls) -> Backend:
+        return cls.instance().backend
+
+    @classmethod
+    def get_prefix(cls) -> str:
+        return cls.instance().prefix
+
+    @classmethod
+    def get_expire(cls) -> int | None:
+        return cls._instance.expire if cls._instance is not None else None
+
+    @classmethod
+    def get_coder(cls) -> type[Coder]:
+        return cls.instance().coder
+
+    @classmethod
+    def get_key_builder(cls) -> KeyBuilder:
+        return cls.instance().key_builder
+
+    @classmethod
+    def get_cache_status_header(cls) -> str:
+        return cls.instance().cache_status_header
+
+    @classmethod
+    def get_enable(cls) -> bool:
+        return cls._instance.enable if cls._instance is not None else True
+
+    @classmethod
+    def get_options(cls) -> CacheOptions:
+        return cls._instance.options if cls._instance is not None else CacheOptions()
+
+    @classmethod
+    def get_guard(cls) -> BackendGuard:
+        return cls.instance().guard
+
+    @classmethod
+    def get_metrics(cls) -> Metrics:
+        return cls._instance.metrics if cls._instance is not None else Metrics(enabled=False)
+
+    @classmethod
+    def tag_key(cls, tag: str) -> str:
+        return cls.instance().tag_key(tag)
+
+    @classmethod
+    async def invalidate_tags(cls, *tags: str) -> int:
+        """Delete every entry stored with any of `tags` (see `@cache(tags=...)`)."""
+        return await cls.instance().invalidate_tags(*tags)
+
+    @classmethod
+    async def clear(cls, namespace: str | None = None, key: str | None = None) -> int:
+        """Delete the entry `key` (a full cache key), or every entry of `namespace`, or of the
+        whole prefix when neither is given."""
+        return await cls.instance().clear(namespace, key)

fastapi_alcazaba/backends/__init__.py

@@ -0,0 +1,42 @@
+from fastapi_alcazaba.backends import inmemory, tiered
+from fastapi_alcazaba.types import Backend
+
+__all__ = ["Backend", "inmemory", "tiered"]
+
+# import each backend in turn and add to __all__. This syntax
+# is explicitly supported by type checkers, while more dynamic
+# syntax would not be recognised.
+try:
+    from fastapi_alcazaba.backends import dynamodb
+except ImportError:
+    pass
+else:
+    __all__ += ["dynamodb"]
+
+try:
+    from fastapi_alcazaba.backends import memcached
+except ImportError:
+    pass
+else:
+    __all__ += ["memcached"]
+
+try:
+    from fastapi_alcazaba.backends import redis
+except ImportError:
+    pass
+else:
+    __all__ += ["redis"]
+
+try:
+    from fastapi_alcazaba.backends import valkey
+except ImportError:
+    pass
+else:
+    __all__ += ["valkey"]
+
+try:
+    from fastapi_alcazaba.backends import glide
+except ImportError:
+    pass
+else:
+    __all__ += ["glide"]

fastapi_alcazaba/backends/_redis_common.py

@@ -0,0 +1,138 @@
+"""Shared implementation of the Redis and Valkey backends: their clients have the same API."""
+
+import re
+import secrets
+from collections.abc import Sequence
+from typing import Any
+
+from fastapi_alcazaba.types import Backend
+
+_GLOB_SPECIAL = re.compile(r"([\\*?\[\]])")
+
+# Keys and values always travel as KEYS/ARGV, never inside the script source.
+RELEASE_LOCK_SCRIPT = """
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+    return redis.call('DEL', KEYS[1])
+end
+return 0
+"""
+
+# KEYS[1]: tag set; ARGV[1]: entry key; ARGV[2]: its expiry in seconds, 0 for none. The set lives as
+# long as its longest-lived entry: it stays persistent once an entry without expiry joins.
+ADD_TAG_SCRIPT = """
+local existed = redis.call('EXISTS', KEYS[1]) == 1
+redis.call('SADD', KEYS[1], ARGV[1])
+local expire = tonumber(ARGV[2])
+if expire == 0 then
+    redis.call('PERSIST', KEYS[1])
+elseif not existed then
+    redis.call('EXPIRE', KEYS[1], expire)
+else
+    local current = redis.call('TTL', KEYS[1])
+    if current ~= -1 and current < expire then
+        redis.call('EXPIRE', KEYS[1], expire)
+    end
+end
+return 1
+"""
+
+
+def escape_glob(text: str) -> str:
+    """Escape the metacharacters of a SCAN MATCH pattern, so that a namespace like "a*" or "a[b]"
+    only matches itself."""
+    return _GLOB_SPECIAL.sub(r"\\\1", text)
+
+
+def pending_tag_key(tag: str) -> str:
+    """Where a tag set is moved while it's invalidated. Same hash slot as the tag in a cluster:
+    the tag keys carry a {hash tag}."""
+    return f"{tag}:invalidating:{secrets.token_hex(8)}"
+
+
+def is_missing_key_error(exc: Exception) -> bool:
+    return "no such key" in str(exc).lower()
+
+
+class RedisLikeBackend(Backend):
+    """Backend for redis-py style clients (standalone or cluster).
+
+    `clear(namespace=...)` walks the namespace with SCAN and deletes in batches with UNLINK.
+    fastapi-cache2 ran a Lua script with KEYS, which blocks the server while it walks every key,
+    and interpolated the namespace into the script source: a namespace coming from user input
+    could run arbitrary commands (e.g. "x') redis.call('FLUSHALL') --").
+    """
+
+    supports_locks = True
+    supports_tags = True
+
+    def __init__(self, client: Any, *, is_cluster: bool, scan_count: int = 500) -> None:
+        if scan_count < 1:
+            raise ValueError("scan_count must be at least 1")
+        self._client = client
+        self.is_cluster = is_cluster
+        self.scan_count = scan_count
+
+    async def get_with_ttl(self, key: str) -> tuple[int, bytes | None]:
+        async with self._client.pipeline(transaction=not self.is_cluster) as pipe:
+            ttl, value = await pipe.ttl(key).get(key).execute()
+        if value is None:
+            return 0, None
+        return int(ttl), value
+
+    async def get(self, key: str) -> bytes | None:
+        value: bytes | None = await self._client.get(key)
+        return value
+
+    async def set(self, key: str, value: bytes, expire: int | None = None) -> None:
+        await self._client.set(key, value, ex=expire or None)
+
+    async def clear(self, namespace: str | None = None, key: str | None = None) -> int:
+        if namespace:
+            return await self._delete_matching(f"{escape_glob(namespace)}:*")
+        if key:
+            return int(await self._client.delete(key))
+        return 0
+
+    async def acquire_lock(self, key: str, token: str, ttl: float) -> bool:
+        return bool(await self._client.set(key, token, nx=True, px=max(1, int(ttl * 1000))))
+
+    async def release_lock(self, key: str, token: str) -> None:
+        await self._client.eval(RELEASE_LOCK_SCRIPT, 1, key, token)
+
+    async def add_tags(self, key: str, tags: Sequence[str], expire: int | None) -> None:
+        for tag in tags:
+            await self._client.eval(ADD_TAG_SCRIPT, 1, tag, key, str(expire or 0))
+
+    async def invalidate_tags(self, tags: Sequence[str]) -> int:
+        deleted = 0
+        for tag in tags:
+            # Moving the set first means that entries tagged while this runs land in a new set and
+            # aren't lost; they belong to the next invalidation.
+            pending = pending_tag_key(tag)
+            try:
+                await self._client.rename(tag, pending)
+            except Exception as exc:
+                if not is_missing_key_error(exc):
+                    raise
+                continue
+            members = list(await self._client.smembers(pending))
+            if members:
+                deleted += await self._unlink(members)
+            await self._client.unlink(pending)
+        return deleted
+
+    async def _delete_matching(self, pattern: str) -> int:
+        deleted = 0
+        batch: list[bytes] = []
+        async for found in self._client.scan_iter(match=pattern, count=self.scan_count):
+            batch.append(found)
+            if len(batch) >= self.scan_count:
+                deleted += await self._unlink(batch)
+                batch = []
+        if batch:
+            deleted += await self._unlink(batch)
+        return deleted
+
+    async def _unlink(self, keys: list[bytes]) -> int:
+        # The cluster clients of redis-py and valkey-py split a multi-key UNLINK by hash slot.
+        return int(await self._client.unlink(*keys))

fastapi_alcazaba/backends/dynamodb.py

@@ -0,0 +1,92 @@
+import time
+from typing import TYPE_CHECKING
+
+from aiobotocore.client import AioBaseClient
+from aiobotocore.session import AioSession, get_session
+
+from fastapi_alcazaba.types import Backend
+
+if TYPE_CHECKING:
+    from types_aiobotocore_dynamodb import DynamoDBClient
+else:
+    DynamoDBClient = AioBaseClient
+
+
+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: str, region: str | None = None, *, endpoint_url: str | None = None
+    ) -> None:
+        """`endpoint_url` points to DynamoDB Local, LocalStack or a VPC endpoint."""
+        self.session: AioSession = get_session()
+        self.table_name = table_name
+        self.region = region
+        self.endpoint_url = endpoint_url
+        self.client: DynamoDBClient | None = None
+
+    async def init(self) -> None:
+        self.client = await self.session.create_client(
+            "dynamodb", region_name=self.region, endpoint_url=self.endpoint_url
+        ).__aenter__()
+
+    async def close(self) -> None:
+        if self.client is not None:
+            await self.client.__aexit__(None, None, None)
+            self.client = None
+
+    def _get_client(self) -> DynamoDBClient:
+        if self.client is None:
+            raise RuntimeError("DynamoBackend.init() must be awaited first")
+        return self.client
+
+    async def get_with_ttl(self, key: str) -> tuple[int, bytes | None]:
+        response = await self._get_client().get_item(
+            TableName=self.table_name, Key={"key": {"S": key}}
+        )
+        item = response.get("Item")
+        if item is None:
+            return 0, None
+        value = item.get("value", {}).get("B")
+        ttl = item.get("ttl", {}).get("N")
+        if value is None:
+            return 0, None
+        if not ttl:
+            return -1, value
+        # DynamoDB deletes expired items eventually, not right away: check it ourselves.
+        remaining = int(ttl) - int(time.time())
+        return (remaining, value) if remaining > 0 else (0, None)
+
+    async def get(self, key: str) -> bytes | None:
+        return (await self.get_with_ttl(key))[1]
+
+    async def set(self, key: str, value: bytes, expire: int | None = None) -> None:
+        item: dict[str, dict[str, str | bytes]] = {"key": {"S": key}, "value": {"B": value}}
+        if expire:
+            item["ttl"] = {"N": str(int(time.time()) + expire)}
+        await self._get_client().put_item(TableName=self.table_name, Item=item)
+
+    async def clear(self, namespace: str | None = None, key: str | None = None) -> int:
+        if namespace:
+            raise NotImplementedError("DynamoDB can't delete a namespace without a table scan")
+        if key:
+            response = await self._get_client().delete_item(
+                TableName=self.table_name, Key={"key": {"S": key}}, ReturnValues="ALL_OLD"
+            )
+            return 1 if response.get("Attributes") else 0
+        return 0

fastapi_alcazaba/backends/glide.py

@@ -0,0 +1,117 @@
+from collections.abc import Sequence
+
+from glide import (
+    Batch,
+    ClusterBatch,
+    ClusterScanCursor,
+    ConditionalChange,
+    ExpirySet,
+    ExpiryType,
+    GlideClient,
+    GlideClusterClient,
+    Script,
+)
+
+from fastapi_alcazaba.backends._redis_common import (
+    ADD_TAG_SCRIPT,
+    RELEASE_LOCK_SCRIPT,
+    escape_glob,
+    is_missing_key_error,
+    pending_tag_key,
+)
+from fastapi_alcazaba.types import Backend
+
+_RELEASE_LOCK = Script(RELEASE_LOCK_SCRIPT)  # type: ignore[no-untyped-call]
+_ADD_TAG = Script(ADD_TAG_SCRIPT)  # type: ignore[no-untyped-call]
+
+
+class GlideBackend(Backend):
+    """Valkey (or Redis) through Valkey GLIDE, the official client with a Rust core:
+    `GlideClient` or `GlideClusterClient`, created with `await GlideClient.create(config)`.
+
+    Same behaviour as RedisBackend: SCAN + UNLINK to clear a namespace, distributed locks and tags.
+    """
+
+    supports_locks = True
+    supports_tags = True
+
+    def __init__(self, client: GlideClient | GlideClusterClient, *, scan_count: int = 500) -> None:
+        if scan_count < 1:
+            raise ValueError("scan_count must be at least 1")
+        self.client = client
+        self.scan_count = scan_count
+        self._is_cluster = isinstance(client, GlideClusterClient)
+
+    async def get_with_ttl(self, key: str) -> tuple[int, bytes | None]:
+        # TTL and GET in one round trip (a non-atomic batch, i.e. a pipeline).
+        batch = ClusterBatch(is_atomic=False) if self._is_cluster else Batch(is_atomic=False)
+        batch.ttl(key)
+        batch.get(key)
+        replies = await self.client.exec(batch, raise_on_error=True)
+        ttl, value = replies if replies is not None else (0, None)
+        if value is None:
+            return 0, None
+        return int(ttl), value
+
+    async def get(self, key: str) -> bytes | None:
+        return await self.client.get(key)
+
+    async def set(self, key: str, value: bytes, expire: int | None = None) -> None:
+        expiry = ExpirySet(ExpiryType.SEC, expire) if expire else None
+        await self.client.set(key, value, expiry=expiry)
+
+    async def clear(self, namespace: str | None = None, key: str | None = None) -> int:
+        if namespace:
+            return await self._delete_matching(f"{escape_glob(namespace)}:*")
+        if key:
+            return await self.client.delete([key])
+        return 0
+
+    async def acquire_lock(self, key: str, token: str, ttl: float) -> bool:
+        result = await self.client.set(
+            key,
+            token,
+            conditional_set=ConditionalChange.ONLY_IF_DOES_NOT_EXIST,
+            expiry=ExpirySet(ExpiryType.MILLSEC, max(1, int(ttl * 1000))),
+        )
+        return result is not None
+
+    async def release_lock(self, key: str, token: str) -> None:
+        await self.client.invoke_script(_RELEASE_LOCK, keys=[key], args=[token])
+
+    async def add_tags(self, key: str, tags: Sequence[str], expire: int | None) -> None:
+        for tag in tags:
+            await self.client.invoke_script(_ADD_TAG, keys=[tag], args=[key, str(expire or 0)])
+
+    async def invalidate_tags(self, tags: Sequence[str]) -> int:
+        deleted = 0
+        for tag in tags:
+            pending = pending_tag_key(tag)
+            try:
+                await self.client.rename(tag, pending)
+            except Exception as exc:
+                if not is_missing_key_error(exc):
+                    raise
+                continue
+            members = list(await self.client.smembers(pending))
+            if members:
+                deleted += await self.client.unlink(list(members))
+            await self.client.unlink([pending])
+        return deleted
+
+    async def _delete_matching(self, pattern: str) -> int:
+        deleted = 0
+        if isinstance(self.client, GlideClusterClient):
+            cursor = ClusterScanCursor()  # type: ignore[no-untyped-call]
+            while not cursor.is_finished():
+                cursor, keys = await self.client.scan(cursor, match=pattern, count=self.scan_count)  # type: ignore[assignment]
+                if keys:
+                    deleted += await self.client.unlink(keys)
+            return deleted
+        position: bytes = b"0"
+        while True:
+            position, keys = await self.client.scan(position, match=pattern, count=self.scan_count)  # type: ignore[assignment]
+            if keys:
+                deleted += await self.client.unlink(keys)
+            if position == b"0":
+                return deleted

fastapi_alcazaba/backends/inmemory.py

@@ -0,0 +1,95 @@
+import math
+import time
+from collections import OrderedDict
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from fastapi_alcazaba.types import Backend
+
+
+@dataclass(slots=True)
+class Value:
+    data: bytes
+    expires_at: float | None  # time.monotonic(); None: no expiry
+
+
+class InMemoryBackend(Backend):
+    """Cache in the memory of the process: for development, tests and single-process apps.
+
+    Each instance has its own store, bounded to `max_size` entries (the least recently used are
+    evicted). fastapi-cache2 shared one dict between all instances and never evicted, so varying
+    a query string grew it until the process ran out of memory.
+    """
+
+    supports_tags = True
+
+    def __init__(self, max_size: int | None = 10_000) -> None:
+        if max_size is not None and max_size < 1:
+            raise ValueError("max_size must be at least 1 (or None for no limit)")
+        self.max_size = max_size
+        self._store: OrderedDict[str, Value] = OrderedDict()
+        self._tags: dict[str, set[str]] = {}
+        self._tags_of: dict[str, set[str]] = {}  # entry key -> its tags
+
+    def _delete(self, key: str) -> bool:
+        if self._store.pop(key, None) is None:
+            return False
+        for tag in self._tags_of.pop(key, ()):
+            members = self._tags.get(tag)
+            if members is not None:
+                members.discard(key)
+                if not members:
+                    del self._tags[tag]
+        return True
+
+    def _get(self, key: str) -> Value | None:
+        value = self._store.get(key)
+        if value is None:
+            return None
+        if value.expires_at is not None and value.expires_at <= time.monotonic():
+            self._delete(key)
+            return None
+        self._store.move_to_end(key)
+        return value
+
+    async def get_with_ttl(self, key: str) -> tuple[int, bytes | None]:
+        value = self._get(key)
+        if value is None:
+            return 0, None
+        if value.expires_at is None:
+            return -1, value.data
+        return max(1, math.ceil(value.expires_at - time.monotonic())), value.data
+
+    async def get(self, key: str) -> bytes | None:
+        value = self._get(key)
+        return None if value is None else value.data
+
+    async def set(self, key: str, value: bytes, expire: int | None = None) -> None:
+        expires_at = time.monotonic() + expire if expire else None
+        self._store[key] = Value(value, expires_at)
+        self._store.move_to_end(key)
+        if self.max_size is not None:
+            while len(self._store) > self.max_size:
+                self._delete(next(iter(self._store)))
+
+    async def clear(self, namespace: str | None = None, key: str | None = None) -> int:
+        if namespace:
+            prefix = f"{namespace}:"
+            matching = [k for k in self._store if k.startswith(prefix)]
+            for k in matching:
+                self._delete(k)
+            return len(matching)
+        if key:
+            return int(self._delete(key))
+        return 0
+
+    async def add_tags(self, key: str, tags: Sequence[str], expire: int | None) -> None:
+        if key not in self._store:
+            return
+        for tag in tags:
+            self._tags.setdefault(tag, set()).add(key)
+        self._tags_of.setdefault(key, set()).update(tags)
+
+    async def invalidate_tags(self, tags: Sequence[str]) -> int:
+        keys = set().union(*(self._tags.get(tag, set()) for tag in tags))
+        return sum(self._delete(key) for key in keys)

fastapi_alcazaba/backends/memcached.py

@@ -0,0 +1,49 @@
+import hashlib
+import time
+
+from aiomcache import Client
+
+from fastapi_alcazaba.types import Backend
+
+# Beyond 30 days memcached reads exptime as a Unix timestamp, not as seconds from now.
+_MAX_RELATIVE_EXPTIME = 30 * 24 * 3600
+_MAX_KEY_LENGTH = 250
+
+
+def memcached_key(key: str) -> bytes:
+    """memcached keys are at most 250 bytes of printable ASCII without spaces: anything else is
+    replaced by its SHA-256 (the keys Alcazaba builds always fit)."""
+    raw = key.encode()
+    if len(raw) <= _MAX_KEY_LENGTH and all(33 <= byte <= 126 for byte in raw):
+        return raw
+    return b"fastapi_alcazaba:sha256:" + hashlib.sha256(raw).hexdigest().encode()
+
+
+class MemcachedBackend(Backend):
+    def __init__(self, mcache: Client) -> None:
+        self.mcache = mcache
+
+    async def get_with_ttl(self, key: str) -> tuple[int, bytes | None]:
+        value = await self.get(key)
+        # memcached can't tell the remaining time to live (fastapi-cache2 always said 3600).
+        return (0, None) if value is None else (-1, value)
+
+    async def get(self, key: str) -> bytes | None:
+        value: bytes | None = await self.mcache.get(memcached_key(key))
+        return value
+
+    async def set(self, key: str, value: bytes, expire: int | None = None) -> None:
+        exptime = expire or 0
+        if exptime > _MAX_RELATIVE_EXPTIME:
+            exptime += int(time.time())
+        await self.mcache.set(memcached_key(key), value, exptime=exptime)
+
+    async def clear(self, namespace: str | None = None, key: str | None = None) -> int:
+        if namespace:
+            # flush_all (upstream PR #477) would also wipe every other application's data.
+            raise NotImplementedError(
+                "memcached can't list the keys of a namespace; delete them one by one with `key`"
+            )
+        if key:
+            return int(await self.mcache.delete(memcached_key(key)))
+        return 0

fastapi_alcazaba/backends/redis.py

@@ -0,0 +1,15 @@
+from redis.asyncio.client import Redis
+from redis.asyncio.cluster import RedisCluster
+
+from fastapi_alcazaba.backends._redis_common import RedisLikeBackend
+
+
+class RedisBackend(RedisLikeBackend):
+    """Redis, or any server speaking its protocol (Valkey, KeyDB, Dragonfly...), through redis-py.
+
+    Create the client without `decode_responses=True`: cached values are bytes.
+    """
+
+    def __init__(self, redis: Redis | RedisCluster, *, scan_count: int = 500) -> None:
+        super().__init__(redis, is_cluster=isinstance(redis, RedisCluster), scan_count=scan_count)
+        self.redis = redis