tigrbl_engine_memdedupe 0.1.10.dev1__py3-none-any.whl

tigrbl_engine_memdedupe/__init__.py

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

tigrbl_engine_memdedupe/dedupe.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import heapq
+from dataclasses import dataclass
+from threading import RLock
+from time import monotonic
+from typing import Any
+
+
+@dataclass(order=True)
+class _Exp:
+    expires_at: float
+    key: str
+
+
+class DedupeSet:
+    """Exact TTL membership set with bounded size.
+
+    Stores: key -> expires_at (monotonic seconds)
+    Cleanup: min-heap of expirations for amortized O(log n) eviction.
+    """
+
+    def __init__(self, *, default_ttl_s: float = 60.0, max_items: int = 1_000_000, namespace: str = "default") -> None:
+        if default_ttl_s <= 0:
+            raise ValueError("default_ttl_s must be > 0")
+        if max_items <= 0:
+            raise ValueError("max_items must be > 0")
+        self.default_ttl_s = float(default_ttl_s)
+        self.max_items = int(max_items)
+        self.namespace = namespace
+
+        self._lock = RLock()
+        self._m: dict[str, float] = {}
+        self._h: list[_Exp] = []
+
+    def _gc(self, now: float) -> None:
+        # Pop until heap head is not expired or stale.
+        while self._h:
+            exp = self._h[0]
+            if exp.expires_at > now:
+                return
+            heapq.heappop(self._h)
+            cur = self._m.get(exp.key)
+            if cur is None:
+                continue
+            if cur <= now:
+                self._m.pop(exp.key, None)
+
+    def seen(self, key: str) -> bool:
+        now = monotonic()
+        with self._lock:
+            self._gc(now)
+            exp = self._m.get(key)
+            return exp is not None and exp > now
+
+    def mark(self, key: str, *, ttl_s: float | None = None) -> None:
+        now = monotonic()
+        ttl = self.default_ttl_s if ttl_s is None else float(ttl_s)
+        if ttl <= 0:
+            raise ValueError("ttl_s must be > 0")
+        exp_at = now + ttl
+        with self._lock:
+            self._gc(now)
+            self._m[key] = exp_at
+            heapq.heappush(self._h, _Exp(exp_at, key))
+            self._enforce_max(now)
+
+    def mark_if_absent(self, key: str, *, ttl_s: float | None = None) -> bool:
+        now = monotonic()
+        ttl = self.default_ttl_s if ttl_s is None else float(ttl_s)
+        if ttl <= 0:
+            raise ValueError("ttl_s must be > 0")
+        exp_at = now + ttl
+        with self._lock:
+            self._gc(now)
+            cur = self._m.get(key)
+            if cur is not None and cur > now:
+                return False
+            self._m[key] = exp_at
+            heapq.heappush(self._h, _Exp(exp_at, key))
+            self._enforce_max(now)
+            return True
+
+    def delete(self, key: str) -> bool:
+        now = monotonic()
+        with self._lock:
+            self._gc(now)
+            return self._m.pop(key, None) is not None
+
+    def size(self) -> int:
+        now = monotonic()
+        with self._lock:
+            self._gc(now)
+            return len(self._m)
+
+    def reset(self) -> None:
+        with self._lock:
+            self._m.clear()
+            self._h.clear()
+
+    def stats(self) -> dict[str, Any]:
+        now = monotonic()
+        with self._lock:
+            self._gc(now)
+            return {"size": len(self._m), "max_items": self.max_items, "default_ttl_s": self.default_ttl_s}
+
+    def _enforce_max(self, now: float) -> None:
+        # If above max, evict oldest-expiring keys (heap order)
+        while len(self._m) > self.max_items and self._h:
+            exp = heapq.heappop(self._h)
+            cur = self._m.get(exp.key)
+            if cur is None:
+                continue
+            # evict regardless of expiration order; this is a hard cap
+            self._m.pop(exp.key, None)

tigrbl_engine_memdedupe/plugin.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from tigrbl.engine.registry import register_engine
+
+from .dedupe import DedupeSet
+from .session import DedupeSession, AsyncDedupeSession
+
+
+def register() -> None:
+    register_engine(kind="memdedupe", build=build_memdedupe, capabilities=capabilities)
+
+
+def capabilities() -> dict:
+    return {
+        "engine": "memdedupe",
+        "transactional": False,
+        "async_native": True,
+        "persistence": "process",
+        "features": {"ttl_set", "exact_membership"},
+    }
+
+
+def build_memdedupe(*, mapping=None, spec=None, dsn=None, **_) -> tuple[object, object]:
+    mapping = dict(mapping or {})
+    async_ = bool(getattr(spec, "async_", False))
+
+    default_ttl_s = float(mapping.get("default_ttl_s", 60.0))
+    max_items = int(mapping.get("max_items", 1_000_000))
+    namespace = str(mapping.get("namespace", "default"))
+
+    engine = DedupeSet(default_ttl_s=default_ttl_s, max_items=max_items, namespace=namespace)
+
+    if async_:
+        def sessionmaker():
+            return AsyncDedupeSession(engine)
+    else:
+        def sessionmaker():
+            return DedupeSession(engine)
+
+    return engine, sessionmaker

tigrbl_engine_memdedupe/session.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from .dedupe import DedupeSet
+
+
+class DedupeSession:
+    def __init__(self, engine: DedupeSet) -> None:
+        self._engine = engine
+        self._closed = False
+
+    def close(self) -> None:
+        self._closed = True
+
+    def seen(self, key: str) -> bool:
+        self._require_open()
+        return self._engine.seen(key)
+
+    def mark(self, key: str, *, ttl_s: float | None = None) -> None:
+        self._require_open()
+        self._engine.mark(key, ttl_s=ttl_s)
+
+    def mark_if_absent(self, key: str, *, ttl_s: float | None = None) -> bool:
+        self._require_open()
+        return self._engine.mark_if_absent(key, ttl_s=ttl_s)
+
+    def delete(self, key: str) -> bool:
+        self._require_open()
+        return self._engine.delete(key)
+
+    def size(self) -> int:
+        self._require_open()
+        return self._engine.size()
+
+    def reset(self) -> None:
+        self._require_open()
+        self._engine.reset()
+
+    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 AsyncDedupeSession(DedupeSession):
+    async def close(self) -> None:  # type: ignore[override]
+        super().close()

tigrbl_engine_memdedupe-0.1.10.dev1.dist-info/METADATA

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

tigrbl_engine_memdedupe-0.1.10.dev1.dist-info/RECORD

@@ -0,0 +1,8 @@
+tigrbl_engine_memdedupe/__init__.py,sha256=tXbRXsO0NE_UV1kIHiZTTQQH0fj0U2KoxxNusu_gzrM,48
+tigrbl_engine_memdedupe/dedupe.py,sha256=b4gIY1U1096Qi914YP9m-cxVq6u87ED3BlDcyQkE-gY,3630
+tigrbl_engine_memdedupe/plugin.py,sha256=uYw35FQ1SnBNwk4QbgH_cJIeyRbacadX6oT4vr8yCgo,1165
+tigrbl_engine_memdedupe/session.py,sha256=WdjjL-7UmnCMKUhNmySjqQ8wwwjujgc4i_0tNtan_G4,1304
+tigrbl_engine_memdedupe-0.1.10.dev1.dist-info/METADATA,sha256=JrW4fxxxp6ZeE7cFotFdYFAZ8kRAbCTaBYEfLexYzMc,125
+tigrbl_engine_memdedupe-0.1.10.dev1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+tigrbl_engine_memdedupe-0.1.10.dev1.dist-info/entry_points.txt,sha256=4UegOfnPR5IkocZv1ocrurBXgkUYRPEnZi9WlUO5kAo,68
+tigrbl_engine_memdedupe-0.1.10.dev1.dist-info/RECORD,,

tigrbl_engine_memdedupe-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_memdedupe-0.1.10.dev1.dist-info/entry_points.txt

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