feat(DEVC-1286): remove DeprecatedRedisAdapter class and all related stuff

Author: kossman

src/corva/cache_adapter.py

@@ -1,13 +1,9 @@
-from datetime import timedelta
 from typing import (
     Dict,
-    List,
     Optional,
     Protocol,
     Sequence,
     Tuple,
-    Union,
-    overload,
 )
 
 import redis
@@ -85,133 +81,3 @@ def delete_many(self, keys: Sequence[str]) -> None:
     def delete_all(self) -> None:
         self.client.delete(self.hash_name)
 
-
-class DeprecatedRedisAdapter:
-    """Expands basic redis functionality
-
-    Serves the purpose of adding custom logic on top of basic redis functions
-    (e.g. adding expiry to hset, which is not available out of the box).
-    """
-
-    DEFAULT_EXPIRY: timedelta = timedelta(days=60)
-    REDIS_STORED_VALUE_TYPE = Union[bytes, str, int, float]
-
-    def __init__(
-        self,
-        hash_name: str,
-        client: redis.Redis,
-    ):
-        self.default_name = hash_name
-        self.client = client
-
-        self.client.ping()
-
-    @overload
-    def hset(
-        self,
-        name: Optional[str] = ...,
-        key: str = ...,
-        value: REDIS_STORED_VALUE_TYPE = ...,
-        mapping: None = ...,
-        expiry: Union[int, timedelta, None] = ...,
-    ) -> int:
-        ...
-
-    @overload
-    def hset(
-        self,
-        name: Optional[str] = ...,
-        key: None = ...,
-        value: None = ...,
-        mapping: Dict[str, REDIS_STORED_VALUE_TYPE] = ...,
-        expiry: Union[int, timedelta, None] = ...,
-    ) -> int:
-        ...
-
-    def hset(
-        self,
-        name=None,
-        key=None,
-        value=None,
-        mapping=None,
-        expiry=DEFAULT_EXPIRY,
-    ) -> int:
-        """Stores the data in cache
-
-        params:
-         key: key, which will contain the data
-         value: data to be saved
-         mapping: dict of key:data pairs to be saved
-         expiry: time in seconds for when data will be deleted from cache
-            expiration is reset with every hset call
-            expiration can be disabled by setting expiry to None
-        returns: number of inserted elements
-        """
-
-        name = name or self.default_name
-
-        n_set = self.client.hset(name=name, key=key, value=value, mapping=mapping)
-
-        if expiry is None and self.pttl(name=name) > 0:
-            self.client.persist(name=name)
-
-        if expiry is not None:
-            self.client.expire(name=name, time=expiry)
-
-        return n_set
-
-    def hget(
-        self, key: str, name: Optional[str] = None
-    ) -> Union[REDIS_STORED_VALUE_TYPE, None]:
-        """Loads data from cache
-
-        params:
-         key: key to load data from
-        returns: stored data
-        """
-
-        name = name or self.default_name
-        return self.client.hget(name=name, key=key)
-
-    def hgetall(
-        self, name: Optional[str] = None
-    ) -> Dict[str, Union[REDIS_STORED_VALUE_TYPE]]:
-        """Loads all data from cache"""
-
-        name = name or self.default_name
-        return self.client.hgetall(name=name)
-
-    def hdel(self, keys: List[str], name: Optional[str] = None) -> int:
-        """Deletes some data from cache
-
-        params:
-         keys: list of keys to delete
-        returns: number of deleted elements
-        """
-
-        name = name or self.default_name
-        return self.client.hdel(name, *keys)
-
-    def delete(self, *names: List[str]) -> int:
-        """Deletes all data from cache"""
-
-        delete_names = names or [self.default_name]
-        return self.client.delete(*delete_names)
-
-    def ttl(self, name: Optional[str] = None) -> int:
-        """Returns the number of seconds until expiration"""
-
-        name = name or self.default_name
-        return self.client.ttl(name=name)
-
-    def pttl(self, name: Optional[str] = None) -> int:
-        """Returns the number of milliseconds until expiration"""
-
-        name = name or self.default_name
-        return self.client.pttl(name=name)
-
-    def exists(self, *names: List[str]) -> int:
-        """Returns whether there is data in cache"""
-
-        exists_names = names or [self.default_name]
-        return self.client.exists(*exists_names)

src/corva/service/cache_sdk.py

@@ -1,15 +1,12 @@
 import datetime
-import warnings
 from typing import (
     Dict,
-    List,
     Optional,
     Protocol,
     Sequence,
     Tuple,
     Union,
     cast,
-    overload,
 )
 
 import fakeredis
@@ -76,9 +73,6 @@ def __init__(
             hash_name=hash_name,
             client=cast(redis.Redis, redis_client),
         )
-        self.old_cache_repo = cache_adapter.DeprecatedRedisAdapter(
-            hash_name=hash_name, client=cast(redis.Redis, redis_client)
-        )
 
     def set(self, key: str, value: str, ttl: int = SIXTY_DAYS) -> None:
         self.cache_repo.set(key=key, value=value, ttl=ttl)
@@ -103,103 +97,17 @@ def get_many(self, keys: Sequence[str]) -> Dict[str, Optional[str]]:
     def get_all(self) -> Dict[str, str]:
         return self.cache_repo.get_all()
 
-    @overload
     def delete(self, *, key: str) -> None:
-        ...
-
-    @overload
-    def delete(self, keys: List[str], name: Optional[str] = ...) -> int:
-        ...
-
-    def delete(
-        self,
-        keys=None,
-        name=None,
-        *,
-        key=None,
-    ):
-        if keys is not None:
-            warnings.warn(
-                "The `keys` and `name` kwargs of `delete` cache method are deprecated "
-                "and will be removed from corva in the next major version. "
-                "Use `key` kwarg instead.",
-                FutureWarning,
-            )
-            return self.old_cache_repo.hdel(keys=keys, name=name)
-
-        if key is not None:
-            self.cache_repo.delete(key=key)
-            return None
-
-        raise TypeError("Bad arguments")
+        self.cache_repo.delete(key=key)
 
     def delete_many(self, keys: Sequence[str]) -> None:
         self.cache_repo.delete_many(keys=keys)
 
-    @overload
     def delete_all(self) -> None:
-        ...
-
-    @overload
-    def delete_all(self, *names: str):
-        ...
+        self.cache_repo.delete_all()
 
-    def delete_all(self, *names):
-        if names:
-            warnings.warn(
-                "`delete_all` with `*names` parameter cache method is deprecated and"
-                " will be removed from corva in the next major version. Use "
-                "`delete_many` cache method instead.",
-                FutureWarning,
-            )
-            return self.old_cache_repo.delete(*names)
-        else:
-            self.cache_repo.delete_all()
-
-    def store(self, **kwargs):
-        warnings.warn(
-            "`store` cache method is deprecated and will be removed from corva in the"
-            " next major version. Use `set` or `set_many` cache methods instead.",
-            FutureWarning,
-        )
-        return self.old_cache_repo.hset(**kwargs)
 
-    def load(self, **kwargs):
-        warnings.warn(
-            "`load` cache method is deprecated and will be removed from corva in the"
-            " next major version. Use `get` or `get_many` cache methods instead.",
-            FutureWarning,
-        )
-        return self.old_cache_repo.hget(**kwargs)
 
-    def load_all(self, **kwargs):
-        warnings.warn(
-            "`load_all` cache method is deprecated and will be removed from corva in "
-            "the next major version. Use `get_all` cache method instead.",
-            FutureWarning,
-        )
-        return self.old_cache_repo.hgetall(**kwargs)
 
-    def ttl(self, **kwargs):
-        warnings.warn(
-            "`ttl` cache method is deprecated and will be removed from corva in the"
-            " next major version.",
-            FutureWarning,
-        )
-        return self.old_cache_repo.ttl(**kwargs)
 
-    def pttl(self, **kwargs):
-        warnings.warn(
-            "`pttl` cache method is deprecated and will be removed from corva in the"
-            " next major version.",
-            FutureWarning,
-        )
-        return self.old_cache_repo.pttl(**kwargs)
 
-    def exists(self, *names):
-        warnings.warn(
-            "`exists` cache method is deprecated and will be removed from corva in the"
-            " next major version.",
-            FutureWarning,
-        )
-        return self.old_cache_repo.exists(*names)