poc for a new caching system

cache.py

from collections import defaultdict
from functools import lru_cache


CACHE = Cache()


class Cache:
    _free = defaultdict(lambda: defaultdict(list))
    _active = defaultdict(lambda: defaultdict(list))

    @lru_cache(20)
    def _make_key(self, key=None, **kwargs):
        obj_key = ""
        if not isinstance(key, list):
            key = [key]
        for k in key:
            obj_key = f"{obj_key}{kwargs.get(k, '')}"
        return obj_key

    def add(self, obj, key=None, **kwargs):
        cls_name = getattr(obj, __name__, obj.__class__.__name__)
        inst_key = self._make_key(key, **kwargs)
        if obj not in self._free[cls_name][inst_key]:
            self._free[cls_name][inst_key].append(obj)

    def get(self, obj_cls, key=None, _free_cache=True, **kwargs):
        cls_name = getattr(obj_cls, __name__, obj_cls.__class__.__name__)
        inst_key = self._make_key(key, **kwargs)
        if _free_cache:
            if self._free[cls_name][inst_key]:
                obj = self._free[cls_name][inst_key].pop()
                self._active[cls_name][inst_key].append(obj)
                return obj
        else:
            if self._active[cls_name].get(inst_key):
                obj = self._active[cls_name][inst_key].pop()
                return True


def cached(limit=5, key=None):
    def cls_wrap(Cls):
        __old_init__ = Cls.__init__

        def __init__(self, *args, **kwargs):
            cached = CACHE.get(Cls, key, **kwargs)
            if cached:
                self = cached
            else:
                Cls.__cache_kwargs = kwargs
                __old_init__(self, *args, **kwargs)

        def __del__(self):
            CACHE.add(self, key, getattr(self, __cache_kwargs))

        def __exit__(self):
            CACHE.add(self, key, getattr(self, __cache_kwargs))

        Cls.__init__ = __init__
        Cls.__del__ = __del__
        Cls.__exit__ = __exit__
        return Cls
    return cls_wrap