lavkach3

1
import pickle
2
from typing import Any, Optional
3

4
import ujson
5

6
from core.helpers.cache.base import BaseBackend
7
from core.helpers.redis import redis as redis_client
8

9

10
class RedisBackend(BaseBackend):
11
    async def get(self, *, key: str) -> Any:
12
        result = await redis_client.get(key)
13
        if not result:
14
            return
15

16
        return ujson.loads(result)
17

18
    async def set(self, *, response: Any, key: str, ttl: int = 60) -> None:
19
        if isinstance(response, dict):
20
            response = ujson.dumps(response)
21
        else:
22
            response = pickle.dumps(response)
23

24
        await redis_client.set(name=key, value=response, ex=ttl)
25

26
    async def set_hash(
27
            self,
28
            name: str,
29
            key: Optional[str] = None,
30
            value: Optional[str] = None,
31
            mapping: Optional[dict] = None,
32
            items: Optional[list] = None,
33
    ) -> None:
34
        await redis_client.hset(name=name, key=key, value=value, mapping=mapping, items=items)
35

36
    async def delete_startswith(self, *, key: str) -> None:
37
        async for key in redis_client.scan_iter(f"{key}*"):
38
            await redis_client.delete(key)
39

40
    async def get_startswith(self, *, key: str) -> dict:
41
        keys = []
42
        data = {}
43
        async for value in redis_client.scan_iter(f"{key}*"):
44
            keys.append(value)
45
        for key in keys:
46
            data.update({
47
                key.decode('utf-8'): await self.get(key=key)
48
            })
49
        return data
50

51
    async def delete(self, *, key: str) -> None:
52
        await redis_client.delete(key)
53

54

55
redis_backend = RedisBackend()
56