WIP

Author: mosquito

aiomisc/cache/__init__.py

@@ -0,0 +1 @@
+

aiomisc/cache/base.py

@@ -0,0 +1,73 @@
+import asyncio
+import threading
+from abc import ABC, abstractmethod
+from typing import Any, Union, Hashable, Dict, Optional
+
+from llist import dllist, dllistnode
+
+
+class CacheBase(ABC):
+    def __init__(self, max_size: int = 0):
+        self._max_size: int = max_size
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self.usages: dllist = dllist()
+        self.cache: Dict[Hashable, Any] = dict()
+        self.lock = threading.RLock()
+
+    @property
+    def is_overflow(self) -> bool:
+        if self._max_size == 0:
+            return False
+
+        if self._max_size < len(self.usages):
+            return True
+
+        return False
+
+    @property
+    def loop(self) -> asyncio.AbstractEventLoop:
+        if self._loop is None:
+            self._loop = asyncio.get_event_loop()
+        return self._loop
+
+    @abstractmethod
+    def _on_set(self, node: dllistnode) -> None:
+        pass
+
+    def _on_expires(self, node: dllistnode) -> None:
+        pass
+
+    @abstractmethod
+    def _on_get(self, node: dllistnode) -> Any:
+        pass
+
+    def __contains__(self, item: Hashable) -> bool:
+        return item in self.cache
+
+    def get(self, item: Hashable) -> Any:
+        with self.lock:
+            node: dllistnode = self.cache[item]
+        self.loop.call_soon(self._on_get, node)
+        return node.value[1]
+
+    def expire(self, node: dllistnode):
+        with self.lock:
+            item, value = node.value
+            node: Optional[dllistnode] = self.cache.pop(item, None)
+
+        if node is None:
+            return
+
+        self.loop.call_soon(self._on_expires, node)
+        self.usages.remove(node)
+
+    def set(self, item: Hashable, value: Any,
+            expiration: Union[int, float] = None) -> None:
+        with self.lock:
+            node: dllistnode = self.usages.append((item, value))
+            self.cache[item] = node
+
+        self.loop.call_soon(self._on_set, node)
+
+        if expiration is not None:
+            self.loop.call_later(expiration, self.expire, node)

aiomisc/cache/lfu.py

@@ -0,0 +1,79 @@
+from dataclasses import dataclass
+from threading import RLock
+from typing import Any, Hashable, Optional
+
+from llist import dllistnode, dllist
+
+
+@dataclass(frozen=True)
+class FrequencyItem:
+    node: dllistnode
+    key: Hashable
+    value: Any
+
+
+class LFUCache:
+    """
+    LFU cache implementation
+
+    >>> lfu = LFUCache(3)
+    >>> lfu.set("foo", "bar")
+    >>> assert "foo" in lfu
+    >>> lfu.get('foo')
+    'bar'
+    >>> lfu.set("bar", "foo")
+    >>> lfu.set("spam", "egg")
+
+    """
+
+    def __init__(self, max_size: int = 0):
+        self.cache = dict()
+        self.usages = dllist()
+        self.lock = RLock()
+        self.size = 0
+        self.max_size = max_size
+
+    def _create_node(self) -> dllistnode:
+        return self.usages.append(set([]))
+
+    def _update_usage(self, item: FrequencyItem):
+        with self.lock:
+            old_node = item.node
+            new_node = item.node.next
+
+            if new_node is None:
+                new_node = self._create_node()
+
+            old_node.value.remove(item)
+            item = FrequencyItem(
+                node=new_node,
+                key=item.key,
+                value=item.value,
+            )
+            new_node.value.add(item)
+            self.cache[item.key] = item
+
+            if not old_node.value:
+                self.usages.remove(old_node)
+
+    def get(self, key: Hashable):
+        item: FrequencyItem = self.cache[key]
+        self._update_usage(item)
+        return item.value
+
+    def set(self, key: Hashable, value: Any):
+        with self.lock:
+            node: Optional[dllistnode] = self.usages.first
+
+            if node is None:
+                node = self._create_node()
+
+            item = FrequencyItem(node=node, key=key, value=value)
+            node.value.add(item)
+            self.cache[key] = item
+
+    def __contains__(self, key) -> Any:
+        if key in self.cache:
+            self._update_usage(self.cache[key])
+            return True
+        return False

aiomisc/cache/lru.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from llist import dllistnode
+
+from .base import CacheBase
+
+
+class LRUCache(CacheBase):
+    def _on_set(self, node: dllistnode) -> None:
+        if not self.is_overflow:
+            return
+        self._on_overflow()
+
+    def _on_get(self, node: dllistnode) -> Any:
+        with self.lock:
+            self.usages.remove(node)
+            self.usages.appendright(node)
+
+    def _on_overflow(self):
+        with self.lock:
+            while self.is_overflow:
+                node: dllistnode = self.usages.popleft()
+                item, value = node.value
+                self.cache.pop(item)

requirements.dev.txt

@@ -1,19 +1,20 @@
-aiohttp<4
 aiohttp-asgi
+aiohttp<4
 async-generator
 async-timeout
 coverage==4.5.1
 coveralls
 croniter~=0.3.34
 fastapi
 freezegun<1.1
+llist==0.6
 mypy~=0.782
 pylava
 pytest
 pytest-cov~=2.5.1
 pytest-freezegun~=0.4.2
-sphinx>=3.5.1
 sphinx-autobuild
 sphinx-intl
+sphinx>=3.5.1
 timeout-decorator
 tox>=2.4

setup.py

@@ -65,6 +65,7 @@ def load_requirements(fname):
         'raven': ['raven-aiohttp'],
         'uvloop': ['uvloop>=0.14,<1'],
         'cron': ['croniter~=0.3.34'],
+        'lfu': ['llist==0.6'],
         ':python_version < "3.7"': 'async-generator',
     },
     entry_points={