tigrbl_engine_memlru 0.1.10.dev1__py3-none-any.whl

tigrbl_engine_memlru/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "0.1.0"

tigrbl_engine_memlru/lru.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from collections import OrderedDict
+from dataclasses import dataclass
+from threading import RLock
+from time import monotonic
+from typing import Any
+
+
+@dataclass
+class _Entry:
+    value: Any
+    cost: float
+    t: float
+
+
+class LRUCache:
+    """LRU cache with optional cost budget.
+
+    Eviction:
+      - Always enforces max_items.
+      - If max_cost set, evicts LRU until total_cost <= max_cost.
+    """
+
+    def __init__(
+        self,
+        *,
+        max_items: int = 100_000,
+        max_cost: float | None = None,
+        default_cost: float = 1.0,
+        namespace: str = "default",
+    ) -> None:
+        if max_items <= 0:
+            raise ValueError("max_items must be > 0")
+        if max_cost is not None and max_cost <= 0:
+            raise ValueError("max_cost must be > 0 if set")
+        if default_cost <= 0:
+            raise ValueError("default_cost must be > 0")
+        self.max_items = int(max_items)
+        self.max_cost = float(max_cost) if max_cost is not None else None
+        self.default_cost = float(default_cost)
+        self.namespace = namespace
+
+        self._lock = RLock()
+        self._od: OrderedDict[str, _Entry] = OrderedDict()
+        self._total_cost = 0.0
+
+    def get(self, key: str, default: Any = None) -> Any:
+        with self._lock:
+            e = self._od.get(key)
+            if e is None:
+                return default
+            self._od.move_to_end(key, last=True)
+            return e.value
+
+    def set(self, key: str, value: Any, *, cost: float | None = None) -> None:
+        if cost is None:
+            cost = self.default_cost
+        c = float(cost)
+        if c <= 0:
+            raise ValueError("cost must be > 0")
+        now = monotonic()
+        with self._lock:
+            old = self._od.pop(key, None)
+            if old is not None:
+                self._total_cost -= old.cost
+            self._od[key] = _Entry(value=value, cost=c, t=now)
+            self._od.move_to_end(key, last=True)
+            self._total_cost += c
+            self._evict()
+
+    def delete(self, key: str) -> bool:
+        with self._lock:
+            e = self._od.pop(key, None)
+            if e is None:
+                return False
+            self._total_cost -= e.cost
+            return True
+
+    def clear(self) -> None:
+        with self._lock:
+            self._od.clear()
+            self._total_cost = 0.0
+
+    def stats(self) -> dict[str, Any]:
+        with self._lock:
+            return {
+                "size": len(self._od),
+                "max_items": self.max_items,
+                "total_cost": self._total_cost,
+                "max_cost": self.max_cost,
+                "default_cost": self.default_cost,
+            }
+
+    def _evict(self) -> None:
+        while len(self._od) > self.max_items:
+            k, e = self._od.popitem(last=False)
+            self._total_cost -= e.cost
+        if self.max_cost is not None:
+            while self._total_cost > self.max_cost and self._od:
+                k, e = self._od.popitem(last=False)
+                self._total_cost -= e.cost

tigrbl_engine_memlru/plugin.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from tigrbl.engine.registry import register_engine
+
+from .lru import LRUCache
+from .session import LRUSession, AsyncLRUSession
+
+
+def register() -> None:
+    register_engine(kind="memlru", build=build_memlru, capabilities=capabilities)
+
+
+def capabilities() -> dict:
+    return {
+        "engine": "memlru",
+        "transactional": False,
+        "async_native": True,
+        "persistence": "process",
+        "features": {"lru", "cost_based_optional"},
+    }
+
+
+def build_memlru(*, mapping=None, spec=None, dsn=None, **_) -> tuple[object, object]:
+    mapping = dict(mapping or {})
+    async_ = bool(getattr(spec, "async_", False))
+
+    max_items = int(mapping.get("max_items", 100_000))
+    max_cost = float(mapping.get("max_cost", 0.0)) or None
+    default_cost = float(mapping.get("default_cost", 1.0))
+    namespace = str(mapping.get("namespace", "default"))
+
+    engine = LRUCache(max_items=max_items, max_cost=max_cost, default_cost=default_cost, namespace=namespace)
+
+    if async_:
+        def sessionmaker():
+            return AsyncLRUSession(engine)
+    else:
+        def sessionmaker():
+            return LRUSession(engine)
+
+    return engine, sessionmaker

tigrbl_engine_memlru/session.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .lru import LRUCache
+
+
+class LRUSession:
+    def __init__(self, engine: LRUCache) -> None:
+        self._engine = engine
+        self._closed = False
+
+    def close(self) -> None:
+        self._closed = True
+
+    def get(self, key: str, default: Any = None) -> Any:
+        self._require_open()
+        return self._engine.get(key, default)
+
+    def set(self, key: str, value: Any, *, cost: float | None = None) -> None:
+        self._require_open()
+        self._engine.set(key, value, cost=cost)
+
+    def delete(self, key: str) -> bool:
+        self._require_open()
+        return self._engine.delete(key)
+
+    def clear(self) -> None:
+        self._require_open()
+        self._engine.clear()
+
+    def stats(self) -> dict:
+        self._require_open()
+        return self._engine.stats()
+
+    def _require_open(self) -> None:
+        if self._closed:
+            raise RuntimeError("session is closed")
+
+
+class AsyncLRUSession(LRUSession):
+    async def close(self) -> None:  # type: ignore[override]
+        super().close()

tigrbl_engine_memlru-0.1.10.dev1.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: tigrbl_engine_memlru
+Version: 0.1.10.dev1
+Requires-Python: <3.14,>=3.10
+Requires-Dist: tigrbl

tigrbl_engine_memlru-0.1.10.dev1.dist-info/RECORD

@@ -0,0 +1,8 @@
+tigrbl_engine_memlru/__init__.py,sha256=tXbRXsO0NE_UV1kIHiZTTQQH0fj0U2KoxxNusu_gzrM,48
+tigrbl_engine_memlru/lru.py,sha256=CXVhMR9Aj2TrY3HIU2l0Y6mvIgSCSvycCM2oPBTmX2k,3097
+tigrbl_engine_memlru/plugin.py,sha256=Fj_iH3GPiqYKmrgKWsWNv7TZ9485_J3j7kWCLtVhrxM,1206
+tigrbl_engine_memlru/session.py,sha256=rOjMIiwcHsDx0Gpd3BoXIuPaSjL8jFEf0kGQWEFCVkk,1093
+tigrbl_engine_memlru-0.1.10.dev1.dist-info/METADATA,sha256=OsvJfWbX6IBbh-NjXdLNZhHGv7lZogs4MXPjC0tD2ts,122
+tigrbl_engine_memlru-0.1.10.dev1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+tigrbl_engine_memlru-0.1.10.dev1.dist-info/entry_points.txt,sha256=QhuLp8RxZvrSi9HoLKbMmy2mzwiQBpGyyArDf60LPsQ,62
+tigrbl_engine_memlru-0.1.10.dev1.dist-info/RECORD,,

tigrbl_engine_memlru-0.1.10.dev1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

tigrbl_engine_memlru-0.1.10.dev1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[tigrbl.engine]
+memlru = tigrbl_engine_memlru.plugin:register