lavkach3

1
from functools import wraps
2
from typing import Any
3

4
from .base import BaseBackend, BaseKeyMaker
5
from .cache_tag import CacheTag
6

7

8
class CacheManager:
9
    def __init__(self):
10
        self.backend = None
11
        self.key_maker = None
12

13
    def init(self, *, backend: BaseBackend, key_maker: BaseKeyMaker) -> None:
14
        self.backend = backend
15
        self.key_maker = key_maker
16

17
    def cached(
18
        self,
19
        *,
20
        prefix: str | None = None,
21
        tag: CacheTag | None = None,
22
        ttl: int = 60,
23
    ):
24
        def _cached(function):
25
            @wraps(function)
26
            async def __cached(*args, **kwargs):
27
                if not self.backend or not self.key_maker:
28
                    raise Exception("backend or key_maker is None")
29

30
                key = await self.key_maker.make(
31
                    function=function,
32
                    prefix=prefix if prefix else tag.value,
33
                )
34
                cached_response = await self.backend.get(key=key)
35
                if cached_response:
36
                    return cached_response
37

38
                response = await function(*args, **kwargs)
39
                await self.backend.set(response=response, key=key, ttl=ttl)
40
                return response
41

42
            return __cached
43

44
        return _cached
45

46
    async def set(self, *, tag: CacheTag, key: str, response=Any, ttl=None) -> None:
47
        key = f'{tag.value}:{key}'
48
        try:
49
            await self.backend.set(response=response, key=key, ttl=ttl)
50
        except:
51
            pass #TODO: Надо убрать потом
52
        return key
53

54
    async def set_model(self, module, model, key: str, data=Any, ttl=10000) -> None:
55
        key = f'{CacheTag.MODEL.value}:{module}:{model}:{key}'
56
        await self.backend.set(response=data, key=key, ttl=ttl)
57
        return key
58

59
    async def get_model(self, module, model, key: str) -> None:
60
        key = f'{CacheTag.MODEL.value}:{module}:{model}:{key}'
61
        return await self.backend.get(key=key)
62

63
    def clean_model_tag(self, data, module, model):
64
        pass
65
    async def get_by_model_all(self, module, model) -> dict:
66
        key = f'{CacheTag.MODEL.value}:{module}:{model}'
67
        data =  await self.backend.get_startswith(key=key)
68
        new_data = {}
69
        for key, value in data.items():
70
            new_data.update({
71
                key.split(':')[-1]: value
72
            })
73
        return new_data
74

75
    async def get_by_tag(self, tag) -> dict:
76
        data =  await self.backend.get_startswith(key=tag)
77
        new_data = {}
78
        for key, value in data.items():
79
            new_data.update({
80
                key.split(':')[-1]: value
81
            })
82
        return new_data
83

84
    async def get(self, tag: CacheTag, key):
85
        key = f'{tag.value}:{key}'
86
        return await self.backend.get(key=key)
87

88

89
    async def remove_by_tag(self, *, tag: CacheTag, key:str=None) -> None:
90
        key = f'{tag.value}:{key}'
91
        await self.backend.delete_startswith(key=key)
92

93
    async def remove_by_prefix(self, *, prefix: str) -> None:
94
        await self.backend.delete_startswith(value=prefix)
95

96

97

98

99
Cache = CacheManager()
100