omnilimit 0.1.0__py3-none-any.whl

omnilimit/__init__.py

@@ -0,0 +1,46 @@
+"""Rate limiting that behaves the same across stacks, and proves it. See spec/SPEC.md."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from omnilimit._generated import SPEC_VERSION
+from omnilimit._headers import build_headers
+from omnilimit._limiter import AsyncLimiter, Limiter
+from omnilimit._types import (
+    AsyncStore,
+    Decision,
+    HeaderInput,
+    HeaderProfile,
+    HitParams,
+    LimiterEvent,
+    OnStoreError,
+    RawHit,
+    Reason,
+    Store,
+    Tier,
+)
+from omnilimit.stores.memory import MemoryStore
+
+try:
+    __version__ = version("omnilimit")
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "0.1.0"
+
+__all__ = [
+    "SPEC_VERSION",
+    "AsyncLimiter",
+    "AsyncStore",
+    "Decision",
+    "HeaderInput",
+    "HeaderProfile",
+    "HitParams",
+    "Limiter",
+    "LimiterEvent",
+    "MemoryStore",
+    "OnStoreError",
+    "RawHit",
+    "Reason",
+    "Store",
+    "Tier",
+    "__version__",
+    "build_headers",
+]

omnilimit/_gcra.py

@@ -0,0 +1,96 @@
+"""The algorithm, on integers only. Every division in this port lives in this file."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from omnilimit._types import HitParams, RawHit
+
+MIN_WINDOW_MS = 1000
+MAX_SAFE_INTEGER = 2**53 - 1
+_SCOPE = re.compile(r"[A-Za-z0-9._-]{1,64}")
+
+
+def ceil_div(a: int, b: int) -> int:
+    """`ceil(a / b)` for non-negative integers."""
+    return (a + b - 1) // b
+
+
+def _is_positive_int(value: object) -> bool:
+    # bool is an int in Python, but `limit=True` is a bug rather than a limit of one.
+    return isinstance(value, int) and not isinstance(value, bool) and 1 <= value <= MAX_SAFE_INTEGER
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedPolicy(HitParams):
+    burst: int
+
+
+def resolve_policy(limit: int, window_ms: int, burst: int | None = None) -> ResolvedPolicy:
+    """Validate a policy and compute the integers shared with every store."""
+    resolved_burst = limit if burst is None else burst
+    if not _is_positive_int(limit):
+        raise ValueError("omnilimit: limit must be a positive integer")
+    if not _is_positive_int(resolved_burst):
+        raise ValueError("omnilimit: burst must be a positive integer")
+    if not _is_positive_int(window_ms) or window_ms < MIN_WINDOW_MS:
+        raise ValueError(f"omnilimit: window_ms must be an integer of at least {MIN_WINDOW_MS}")
+    # Python would not overflow, but the same policy must be valid in every language.
+    if 2 * resolved_burst * window_ms + limit > MAX_SAFE_INTEGER:
+        raise ValueError(
+            "omnilimit: policy too large for exact integer arithmetic (2*burst*window_ms + limit)"
+        )
+    capacity = resolved_burst * window_ms
+    return ResolvedPolicy(
+        limit=limit,
+        window_ms=window_ms,
+        capacity=capacity,
+        drain_ms=ceil_div(capacity, limit),
+        burst=resolved_burst,
+    )
+
+
+def assert_scope(scope: str) -> None:
+    if not isinstance(scope, str) or _SCOPE.fullmatch(scope) is None:
+        raise ValueError("omnilimit: scope must match ^[A-Za-z0-9._-]{1,64}$")
+
+
+@dataclass(frozen=True, slots=True)
+class MeterState:
+    level: int
+    ts: int
+
+
+def apply_hit(
+    state: MeterState | None, params: HitParams, now_ms: int
+) -> tuple[RawHit, MeterState | None]:
+    """Return the hit and the state to persist, which is `None` on denial: denials never write."""
+    ts = state.ts if state is not None else now_ms
+    level = state.level if state is not None else 0
+    t = max(now_ms, ts)
+    elapsed = min(t - ts, params.drain_ms)
+    drained = max(0, level - elapsed * params.limit)
+
+    if drained + params.window_ms > params.capacity:
+        return RawHit(allowed=False, level=drained, ts=ts), None
+    new_level = drained + params.window_ms
+    return RawHit(allowed=True, level=new_level, ts=t), MeterState(level=new_level, ts=t)
+
+
+@dataclass(frozen=True, slots=True)
+class MeterView:
+    remaining: int
+    reset_ms: int
+    retry_after_ms: int | None
+    effective_ms: int
+
+
+def view_of(allowed: bool, level: int, params: HitParams) -> MeterView:
+    """Derive the public numbers from a level."""
+    remaining = (params.capacity - level) // params.window_ms
+    reset_ms = ceil_div(level, params.limit)
+    next_unit_ms = ceil_div(max(0, level + params.window_ms - params.capacity), params.limit)
+    if not allowed:
+        return MeterView(remaining, reset_ms, next_unit_ms, next_unit_ms)
+    return MeterView(remaining, reset_ms, None, next_unit_ms if remaining == 0 else reset_ms)

omnilimit/_generated.py

@@ -0,0 +1,5 @@
+# GENERATED by tools/sync_assets.py from spec/scripts. Do not edit.
+SPEC_VERSION = "1"
+REDIS_HIT_SHA1 = "f525d75f3e6a26f742e789522c9055c49bad3cce"
+REDIS_HIT_LUA = "-- omnilimit state format 1. KEYS[1] = bucket key.\n-- ARGV: limit, window_ms, capacity, drain_ms, now_ms ('' = use the server clock).\n-- The script has no division on policy values: every port computes capacity and\n-- drain_ms once, so it behaves identically regardless of the calling language.\nlocal limit = tonumber(ARGV[1])\nlocal window_ms = tonumber(ARGV[2])\nlocal capacity = tonumber(ARGV[3])\nlocal drain_ms = tonumber(ARGV[4])\n\nlocal now\nlocal injected = ARGV[5] ~= nil and ARGV[5] ~= ''\nif injected then\n  now = tonumber(ARGV[5])\nelse\n  local clock = redis.call('TIME')\n  now = tonumber(clock[1]) * 1000 + math.floor(tonumber(clock[2]) / 1000)\nend\n\nlocal stored = redis.call('HMGET', KEYS[1], 'l', 't')\nlocal level = tonumber(stored[1]) or 0\nlocal ts = tonumber(stored[2]) or now\n\nlocal t = math.max(now, ts)\nlocal elapsed = math.min(t - ts, drain_ms)\nlocal drained = math.max(0, level - elapsed * limit)\n\nif drained + window_ms > capacity then\n  -- Denied requests never write, so a retry storm cannot extend the wait.\n  return {0, string.format('%.0f', drained), string.format('%.0f', ts)}\nend\n\nlocal new_level = drained + window_ms\n-- tostring() would render large doubles in scientific notation and lose digits.\nredis.call('HSET', KEYS[1], 'l', string.format('%.0f', new_level), 't', string.format('%.0f', t))\n-- A TTL runs on real time, so it cannot be mixed with an injected clock (conformance vectors only).\nif not injected then\n  redis.call('PEXPIRE', KEYS[1], drain_ms)\nend\nreturn {1, string.format('%.0f', new_level), string.format('%.0f', t)}\n"
+POSTGRES_MIGRATION_SQL = "-- omnilimit state format 1. Apply once with your migration tool; omnilimit never runs it for you.\nCREATE TABLE IF NOT EXISTS omnilimit_state (\n  key           text PRIMARY KEY,\n  level         bigint NOT NULL,\n  ts_ms         bigint NOT NULL,\n  expires_at_ms bigint NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS omnilimit_state_expires_idx ON omnilimit_state (expires_at_ms);\n\nCREATE OR REPLACE FUNCTION omnilimit_hit_v1(\n  p_key text,\n  p_limit bigint,\n  p_window_ms bigint,\n  p_capacity bigint,\n  p_drain_ms bigint,\n  p_now_ms bigint DEFAULT NULL\n) RETURNS TABLE (allowed boolean, new_level bigint, new_ts bigint)\nLANGUAGE plpgsql\nAS $$\nDECLARE\n  v_level bigint;\n  v_ts bigint;\n  v_now bigint;\n  v_t bigint;\n  v_drained bigint;\nBEGIN\n  -- The placeholder (level 0, ts 0) behaves exactly like a missing row.\n  INSERT INTO omnilimit_state AS s (key, level, ts_ms, expires_at_ms)\n  VALUES (p_key, 0, 0, 0)\n  ON CONFLICT (key) DO NOTHING;\n\n  SELECT s.level, s.ts_ms INTO v_level, v_ts\n  FROM omnilimit_state AS s\n  WHERE s.key = p_key\n  FOR UPDATE;\n\n  -- Read the clock after taking the lock: waiters must not act on a stale time.\n  v_now := COALESCE(p_now_ms, floor(extract(epoch FROM clock_timestamp()) * 1000)::bigint);\n  v_t := GREATEST(v_now, v_ts);\n  v_drained := GREATEST(0, v_level - LEAST(v_t - v_ts, p_drain_ms) * p_limit);\n\n  IF v_drained + p_window_ms > p_capacity THEN\n    RETURN QUERY SELECT false, v_drained, v_ts;\n    RETURN;\n  END IF;\n\n  UPDATE omnilimit_state AS s\n  SET level = v_drained + p_window_ms,\n      ts_ms = v_t,\n      expires_at_ms = v_t + p_drain_ms\n  WHERE s.key = p_key;\n\n  RETURN QUERY SELECT true, v_drained + p_window_ms, v_t;\nEND;\n$$;\n\nCREATE OR REPLACE FUNCTION omnilimit_cleanup_v1(p_batch integer DEFAULT 1000, p_now_ms bigint DEFAULT NULL)\nRETURNS integer\nLANGUAGE plpgsql\nAS $$\nDECLARE\n  v_deleted integer;\n  v_now bigint := COALESCE(p_now_ms, floor(extract(epoch FROM clock_timestamp()) * 1000)::bigint);\nBEGIN\n  DELETE FROM omnilimit_state\n  WHERE key IN (\n    SELECT s.key FROM omnilimit_state AS s\n    WHERE s.expires_at_ms < v_now\n    ORDER BY s.expires_at_ms\n    LIMIT p_batch\n    FOR UPDATE SKIP LOCKED\n  );\n  GET DIAGNOSTICS v_deleted = ROW_COUNT;\n  RETURN v_deleted;\nEND;\n$$;\n"

omnilimit/_headers.py

@@ -0,0 +1,27 @@
+"""Response headers. `draft-11` is pinned: a newer draft becomes a new profile."""
+
+from __future__ import annotations
+
+from omnilimit._gcra import ceil_div
+from omnilimit._types import HeaderInput, HeaderProfile
+
+
+def _seconds(ms: int) -> int:
+    return ceil_div(ms, 1000)
+
+
+def build_headers(profile: HeaderProfile, data: HeaderInput) -> dict[str, str]:
+    decision = data.decision
+    out: dict[str, str] = {}
+    if decision.remaining is not None:
+        t = _seconds(data.effective_ms)
+        if profile == "draft-11":
+            out["ratelimit-policy"] = f'"{data.scope}";q={data.limit};w={_seconds(data.window_ms)}'
+            out["ratelimit"] = f'"{data.scope}";r={decision.remaining};t={t}'
+        elif profile == "legacy":
+            out["x-ratelimit-limit"] = str(data.limit)
+            out["x-ratelimit-remaining"] = str(decision.remaining)
+            out["x-ratelimit-reset"] = str(t)
+    if not decision.allowed and decision.retry_after_ms is not None:
+        out["retry-after"] = str(_seconds(decision.retry_after_ms))
+    return out

omnilimit/_key.py

@@ -0,0 +1,26 @@
+"""Bucket keys. The id is hashed: keys stay short and stores never hold raw IPs."""
+
+from __future__ import annotations
+
+import hashlib
+
+from omnilimit._gcra import ResolvedPolicy
+
+_HASH_HEX_LENGTH = 32
+_STATE_FORMAT = 1
+
+
+def _utf8(text: str) -> bytes:
+    """Encode like JavaScript's TextEncoder, where a lone surrogate becomes U+FFFD."""
+    try:
+        return text.encode("utf-8")
+    except UnicodeEncodeError:
+        repaired = text.encode("utf-16", "surrogatepass").decode("utf-16", "replace")
+        return repaired.encode("utf-8")
+
+
+def derive_key(scope: str, policy: ResolvedPolicy, salt: str, id_value: str) -> str:
+    """Build the bucket key. The policy is part of it, since levels are measured in windows."""
+    digest = hashlib.sha256(_utf8(salt) + b"\x00" + _utf8(id_value)).hexdigest()
+    shape = f"{policy.limit}-{policy.window_ms}-{policy.burst}"
+    return f"ol:{_STATE_FORMAT}:{scope}:{shape}:{digest[:_HASH_HEX_LENGTH]}"

omnilimit/_limiter.py

@@ -0,0 +1,291 @@
+"""`Limiter` and `AsyncLimiter`. The decision logic is shared; only store calls differ."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import inspect
+import threading
+import time
+from collections.abc import Callable
+from dataclasses import replace
+from typing import Any
+
+from omnilimit._gcra import assert_scope, resolve_policy, view_of
+from omnilimit._headers import build_headers
+from omnilimit._key import derive_key
+from omnilimit._types import (
+    AsyncStore,
+    Decision,
+    EventHook,
+    HeaderInput,
+    HeaderOption,
+    LimiterEvent,
+    OnStoreError,
+    RawHit,
+    Store,
+    Tier,
+)
+
+_DEFAULT_STORE_TIMEOUT_MS = 1000
+_DEFAULT_MAX_STORE_THREADS = 32
+_STORE_ERROR_RETRY_MS = 1000
+
+
+class _Core:
+    """Everything that does no I/O: validation, keys and turning hits into decisions."""
+
+    def __init__(
+        self,
+        *,
+        tier: Tier,
+        scope: str,
+        limit: int,
+        window_ms: int,
+        burst: int | None,
+        on_store_error: OnStoreError,
+        store_timeout_ms: int,
+        headers: HeaderOption,
+        salt: str,
+        on_event: EventHook | None,
+    ) -> None:
+        self.policy = resolve_policy(limit, window_ms, burst)
+        assert_scope(scope)
+        if on_store_error not in ("open", "closed"):
+            raise ValueError("omnilimit: on_store_error is required: 'open' or 'closed'")
+        if store_timeout_ms <= 0:
+            raise ValueError("omnilimit: store_timeout_ms must be positive")
+        self.tier: Tier = tier
+        self.scope = scope
+        self.on_store_error: OnStoreError = on_store_error
+        self.timeout_s = store_timeout_ms / 1000
+        self.headers = headers
+        self.salt = salt
+        self.on_event = on_event
+
+    def key(self, id_value: str) -> str:
+        return derive_key(self.scope, self.policy, self.salt, id_value)
+
+    def _emit(self, event: LimiterEvent) -> None:
+        if self.on_event is None:
+            return
+        # An observability hook must never change a rate limit decision.
+        with contextlib.suppress(Exception):
+            self.on_event(event)
+
+    def _finish(self, decision: Decision, effective_ms: int) -> Decision:
+        data = HeaderInput(
+            scope=self.scope,
+            limit=self.policy.limit,
+            window_ms=self.policy.window_ms,
+            decision=decision,
+            effective_ms=effective_ms,
+        )
+        built = self.headers(data) if callable(self.headers) else build_headers(self.headers, data)
+        return replace(decision, headers=built)
+
+    def from_hit(self, hit: RawHit) -> Decision:
+        self._emit(LimiterEvent("allowed" if hit.allowed else "limited", self.scope, self.tier))
+        base = Decision(
+            allowed=hit.allowed,
+            reason="ok" if hit.allowed else "limited",
+            status=None if hit.allowed else 429,
+            remaining=None,
+            reset_ms=None,
+            retry_after_ms=None,
+            tier=self.tier,
+        )
+        if hit.level is None:
+            retry_after_ms = None
+            if not hit.allowed:
+                retry_after_ms = (
+                    hit.retry_after_ms if hit.retry_after_ms is not None else self.policy.window_ms
+                )
+            return self._finish(replace(base, retry_after_ms=retry_after_ms), retry_after_ms or 0)
+        view = view_of(hit.allowed, hit.level, self.policy)
+        decision = replace(
+            base,
+            remaining=view.remaining,
+            reset_ms=view.reset_ms,
+            retry_after_ms=view.retry_after_ms,
+        )
+        return self._finish(decision, view.effective_ms)
+
+    def from_failure(self, error: Exception) -> Decision:
+        self._emit(LimiterEvent("store_error", self.scope, self.tier, error))
+        # Reports nothing about quota: the store could not say anything about it.
+        allowed = self.on_store_error == "open"
+        decision = Decision(
+            allowed=allowed,
+            reason="store_error",
+            status=None if allowed else 503,
+            remaining=None,
+            reset_ms=None,
+            retry_after_ms=None if allowed else _STORE_ERROR_RETRY_MS,
+            tier=self.tier,
+        )
+        return self._finish(decision, 0)
+
+
+def _run_with_timeout(
+    call: Callable[[], RawHit], timeout_s: float, slots: threading.BoundedSemaphore
+) -> RawHit:
+    """Run a blocking call, giving up after `timeout_s`.
+
+    Python cannot abandon a blocking call, so it runs in its own daemon thread: if it hangs,
+    the request moves on and interpreter exit is not held up. `slots` caps those threads,
+    so a store that hangs turns into timeouts instead of an unbounded pile of threads.
+    """
+    deadline = time.monotonic() + timeout_s
+    if not slots.acquire(timeout=timeout_s):
+        raise TimeoutError("omnilimit: too many store calls in flight")
+
+    outcome: list[RawHit | Exception] = []
+    finished = threading.Event()
+
+    def work() -> None:
+        try:
+            outcome.append(call())
+        except Exception as error:
+            outcome.append(error)
+        finally:
+            slots.release()
+            finished.set()
+
+    try:
+        threading.Thread(target=work, name="omnilimit-store", daemon=True).start()
+    except RuntimeError:
+        slots.release()
+        raise
+    if not finished.wait(max(0.0, deadline - time.monotonic())):
+        raise TimeoutError(f"omnilimit: store timed out after {timeout_s}s")
+    result = outcome[0]
+    if isinstance(result, Exception):
+        raise result
+    return result
+
+
+class Limiter:
+    """A limiter for blocking code: Flask, Django, `def` dependencies in FastAPI.
+
+    `on_store_error` is required on purpose: a login route usually wants `closed`, a public
+    read route usually wants `open`. Configure socket timeouts on your store's client too.
+    """
+
+    def __init__(
+        self,
+        *,
+        store: Store,
+        scope: str,
+        limit: int,
+        window_ms: int,
+        on_store_error: OnStoreError,
+        burst: int | None = None,
+        store_timeout_ms: int = _DEFAULT_STORE_TIMEOUT_MS,
+        max_store_threads: int = _DEFAULT_MAX_STORE_THREADS,
+        headers: HeaderOption = "draft-11",
+        salt: str = "",
+        on_event: EventHook | None = None,
+    ) -> None:
+        if inspect.iscoroutinefunction(store.hit):
+            raise TypeError("omnilimit: this store is async: use AsyncLimiter")
+        if max_store_threads < 1:
+            raise ValueError("omnilimit: max_store_threads must be positive")
+        self._store = store
+        self._core = _Core(
+            tier=store.tier,
+            scope=scope,
+            limit=limit,
+            window_ms=window_ms,
+            burst=burst,
+            on_store_error=on_store_error,
+            store_timeout_ms=store_timeout_ms,
+            headers=headers,
+            salt=salt,
+            on_event=on_event,
+        )
+        self._slots = threading.BoundedSemaphore(max_store_threads)
+
+    @property
+    def scope(self) -> str:
+        return self._core.scope
+
+    @property
+    def tier(self) -> Tier:
+        return self._core.tier
+
+    def check(self, id_value: str, *, now_ms: int | None = None) -> Decision:
+        """Count one request for `id_value`. `now_ms` exists for conformance vectors only."""
+        core = self._core
+        key = core.key(id_value)
+
+        def call() -> RawHit:
+            return self._store.hit(key, core.policy, now_ms)
+
+        try:
+            # A local store has no I/O, so it cannot hang and does not need a thread.
+            hit = (
+                call()
+                if core.tier == "local"
+                else _run_with_timeout(call, core.timeout_s, self._slots)
+            )
+        except Exception as error:
+            return core.from_failure(error)
+        return core.from_hit(hit)
+
+
+class AsyncLimiter:
+    """A limiter for event loops. Accepts async stores and `MemoryStore`, which never blocks."""
+
+    def __init__(
+        self,
+        *,
+        store: AsyncStore | Store,
+        scope: str,
+        limit: int,
+        window_ms: int,
+        on_store_error: OnStoreError,
+        burst: int | None = None,
+        store_timeout_ms: int = _DEFAULT_STORE_TIMEOUT_MS,
+        headers: HeaderOption = "draft-11",
+        salt: str = "",
+        on_event: EventHook | None = None,
+    ) -> None:
+        if not inspect.iscoroutinefunction(store.hit) and store.tier != "local":
+            raise TypeError("omnilimit: this store would block the event loop: use its async form")
+        self._store: Any = store
+        self._core = _Core(
+            tier=store.tier,
+            scope=scope,
+            limit=limit,
+            window_ms=window_ms,
+            burst=burst,
+            on_store_error=on_store_error,
+            store_timeout_ms=store_timeout_ms,
+            headers=headers,
+            salt=salt,
+            on_event=on_event,
+        )
+
+    @property
+    def scope(self) -> str:
+        return self._core.scope
+
+    @property
+    def tier(self) -> Tier:
+        return self._core.tier
+
+    async def check(self, id_value: str, *, now_ms: int | None = None) -> Decision:
+        """Count one request for `id_value`. `now_ms` exists for conformance vectors only."""
+        core = self._core
+        key = core.key(id_value)
+        try:
+            result = self._store.hit(key, core.policy, now_ms)
+            hit: RawHit = (
+                await asyncio.wait_for(result, core.timeout_s)
+                if inspect.isawaitable(result)
+                else result
+            )
+        except Exception as error:
+            return core.from_failure(error)
+        return core.from_hit(hit)

omnilimit/_types.py

@@ -0,0 +1,89 @@
+"""Public data types. See spec/SPEC.md."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Literal, Protocol, runtime_checkable
+
+Tier = Literal["exact", "local", "approximate"]
+Reason = Literal["ok", "limited", "store_error"]
+OnStoreError = Literal["open", "closed"]
+HeaderProfile = Literal["draft-11", "legacy", "none"]
+
+
+@dataclass(frozen=True, slots=True)
+class HitParams:
+    """Integers computed once by the core, so stores never divide."""
+
+    limit: int
+    window_ms: int
+    capacity: int
+    drain_ms: int
+
+
+@dataclass(frozen=True, slots=True)
+class RawHit:
+    """What a store answers. Approximate stores leave `level` and `ts` as `None`."""
+
+    allowed: bool
+    level: int | None
+    ts: int | None
+    retry_after_ms: int | None = None
+
+
+@runtime_checkable
+class Store(Protocol):
+    """A blocking store. It must apply the hit atomically and use its own clock."""
+
+    tier: Tier
+
+    def hit(self, key: str, params: HitParams, now_ms: int | None = None) -> RawHit: ...
+
+
+@runtime_checkable
+class AsyncStore(Protocol):
+    """Same contract as `Store`, for event loops."""
+
+    tier: Tier
+
+    async def hit(self, key: str, params: HitParams, now_ms: int | None = None) -> RawHit: ...
+
+
+@dataclass(frozen=True, slots=True)
+class Decision:
+    """The outcome of one check. `status` is what to answer with when denied."""
+
+    allowed: bool
+    reason: Reason
+    status: Literal[429, 503] | None
+    remaining: int | None
+    reset_ms: int | None
+    retry_after_ms: int | None
+    tier: Tier
+    headers: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class HeaderInput:
+    """What a custom header function receives. `decision.headers` is still empty."""
+
+    scope: str
+    limit: int
+    window_ms: int
+    decision: Decision
+    effective_ms: int
+
+
+@dataclass(frozen=True, slots=True)
+class LimiterEvent:
+    """Observability event. `error` is only set for `store_error`."""
+
+    type: Literal["allowed", "limited", "store_error"]
+    scope: str
+    tier: Tier
+    error: Exception | None = None
+
+
+HeaderOption = HeaderProfile | Callable[[HeaderInput], dict[str, str]]
+EventHook = Callable[[LimiterEvent], None]

omnilimit/fastapi.py

@@ -0,0 +1,118 @@
+"""FastAPI dependency.
+
+`rate_limit` raises `HTTPException` on denial, so your own error handlers format the response.
+When the request passes, headers go on the injected `Response`: FastAPI does not copy them if
+the route returns a `Response` object of its own, as a file download usually does.
+"""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Any, Literal
+
+from fastapi import HTTPException, Request, Response
+
+from omnilimit._limiter import AsyncLimiter, Limiter
+from omnilimit._types import Decision
+from omnilimit.ip import IpPreset, mask_ip, resolve_client_ip
+
+MissingKeyPolicy = Literal["shared", "skip", "reject"]
+"""`shared`: everyone without a key shares a bucket. `skip`: no limit. `reject`: answer 400."""
+
+_SHARED_ID = "__omnilimit_shared__"
+
+
+@dataclass(frozen=True, slots=True)
+class KeyContext:
+    request: Request
+    headers: Any
+    peer: str | None
+
+
+KeyFn = Callable[[KeyContext], "Awaitable[str | None] | str | None"]
+"""Returns the bucket id, or `None` if it cannot be determined."""
+
+
+def ip_key(
+    *,
+    preset: IpPreset | None = None,
+    xff_hops: int | None = None,
+    header: str | None = None,
+    use_peer: bool = False,
+    ipv6_prefix: int = 64,
+) -> Callable[[KeyContext], str | None]:
+    """Key requests by trusted client IP. See `omnilimit.ip.resolve_client_ip`."""
+
+    def key(context: KeyContext) -> str | None:
+        ip = resolve_client_ip(
+            context.headers,
+            context.peer,
+            preset=preset,
+            xff_hops=xff_hops,
+            header=header,
+            use_peer=use_peer,
+        )
+        return None if ip is None else mask_ip(ip, ipv6_prefix)
+
+    return key
+
+
+def _context(request: Request) -> KeyContext:
+    peer = request.client.host if request.client is not None else None
+    return KeyContext(request=request, headers=request.headers, peer=peer)
+
+
+def _missing(on_missing_key: MissingKeyPolicy) -> str | None:
+    """The id to count a keyless request under, or `None` to skip the limit."""
+    if on_missing_key == "skip":
+        return None
+    if on_missing_key == "reject":
+        raise HTTPException(status_code=400, detail="client_not_identified")
+    return _SHARED_ID
+
+
+def _apply(decision: Decision, response: Response) -> None:
+    if not decision.allowed:
+        detail = "rate_limiter_unavailable" if decision.reason == "store_error" else "rate_limited"
+        raise HTTPException(
+            status_code=decision.status or 429, detail=detail, headers=decision.headers
+        )
+    for name, value in decision.headers.items():
+        response.headers[name] = value
+
+
+def rate_limit(
+    limiter: Limiter | AsyncLimiter, *, key: KeyFn, on_missing_key: MissingKeyPolicy
+) -> Callable[..., Any]:
+    """Build a dependency: `Depends(rate_limit(limiter, key=..., on_missing_key=...))`.
+
+    `on_missing_key` is required so a misconfigured proxy cannot pass unnoticed.
+    """
+    if on_missing_key not in ("shared", "skip", "reject"):
+        raise ValueError("omnilimit: on_missing_key must be 'shared', 'skip' or 'reject'")
+
+    if isinstance(limiter, AsyncLimiter):
+
+        async def async_dependency(request: Request, response: Response) -> None:
+            result = key(_context(request))
+            id_value = await result if inspect.isawaitable(result) else result
+            if id_value is None:
+                id_value = _missing(on_missing_key)
+            if id_value is not None:
+                _apply(await limiter.check(id_value), response)
+
+        return async_dependency
+
+    # A plain `def`: FastAPI runs it in its thread pool, so a blocking store is fine.
+    def dependency(request: Request, response: Response) -> None:
+        result: Any = key(_context(request))
+        if inspect.iscoroutine(result):
+            result.close()
+            raise TypeError("omnilimit: an async key function needs an AsyncLimiter")
+        id_value = _missing(on_missing_key) if result is None else result
+        if id_value is not None:
+            _apply(limiter.check(id_value), response)
+
+    return dependency

omnilimit/ip.py

@@ -0,0 +1,131 @@
+"""Trusted client IPs, using only the standard library.
+
+This module depends on nothing else in omnilimit, so it also works next to `slowapi` or anything
+else needing a client IP. It returns `None` rather than guessing when the configured source is
+missing or malformed, and it never falls back to the first value of `X-Forwarded-For`.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import re
+from typing import Any, Literal
+
+IpPreset = Literal["cloudflare", "cloud-run", "cloud-run-lb", "vercel", "direct"]
+
+_IPV4_OCTET = re.compile(r"0|[1-9][0-9]{0,2}")
+
+# preset: (header to read, X-Forwarded-For hops); neither means the TCP peer
+_PRESETS: dict[str, tuple[str | None, int | None]] = {
+    "cloudflare": ("cf-connecting-ip", None),
+    "cloud-run": (None, 0),
+    "cloud-run-lb": (None, 1),
+    "vercel": ("x-vercel-forwarded-for", None),
+    "direct": (None, None),
+}
+
+
+def _read_header(headers: Any, name: str) -> str | None:
+    # A header can arrive on several lines, and `.get` on Starlette or Werkzeug headers only
+    # returns the first one: a client-supplied line could then pass for the trusted value.
+    getlist = getattr(headers, "getlist", None)
+    value = getlist(name) if callable(getlist) else headers.get(name)
+    if value is None:
+        return None
+    if isinstance(value, list | tuple):
+        return ",".join(value) if value else None
+    return str(value)
+
+
+def _canonical_ipv4(raw: str) -> str | None:
+    parts = raw.split(".")
+    if len(parts) != 4:
+        return None
+    for part in parts:
+        if _IPV4_OCTET.fullmatch(part) is None or int(part) > 255:
+            return None
+    return raw
+
+
+def _parse_ipv6(raw: str) -> ipaddress.IPv6Address | None:
+    # `ipaddress` accepts zone identifiers, which would give one host many buckets.
+    if "%" in raw:
+        return None
+    try:
+        return ipaddress.IPv6Address(raw)
+    except ValueError:
+        return None
+
+
+def canonical_ip(raw: str | None) -> str | None:
+    """Validate and normalise an address (RFC 5952; IPv4-mapped becomes IPv4), or `None`."""
+    if not raw:
+        return None
+    if ":" not in raw:
+        return _canonical_ipv4(raw)
+    address = _parse_ipv6(raw)
+    if address is None:
+        return None
+    if address.ipv4_mapped is not None:
+        return str(address.ipv4_mapped)
+    return address.compressed
+
+
+def mask_ip(ip: str, prefix: int) -> str | None:
+    """Keep an IPv6 network prefix, since one customer commonly controls a whole /64.
+
+    IPv4 addresses are returned unchanged.
+    """
+    canonical = canonical_ip(ip)
+    if canonical is None:
+        return None
+    if ":" not in canonical:
+        return canonical
+    if not isinstance(prefix, int) or isinstance(prefix, bool) or not 0 <= prefix <= 128:
+        raise ValueError("omnilimit: IPv6 prefix must be an integer from 0 to 128")
+    network = ipaddress.IPv6Network((canonical, prefix), strict=False)
+    return network.network_address.compressed
+
+
+def _from_xff(value: str | None, hops: int) -> str | None:
+    if value is None:
+        return None
+    entries = [entry.strip() for entry in value.split(",")]
+    # The client controls everything to the left of what your proxies appended, so a chain
+    # that is too short must never fall back to its first value.
+    if len(entries) <= hops:
+        return None
+    return canonical_ip(entries[len(entries) - 1 - hops])
+
+
+def resolve_client_ip(
+    headers: Any,
+    peer: str | None = None,
+    *,
+    preset: IpPreset | None = None,
+    xff_hops: int | None = None,
+    header: str | None = None,
+    use_peer: bool = False,
+) -> str | None:
+    """Resolve the client IP from the one source you name.
+
+    Choose exactly one: `preset`, `xff_hops` (read `X-Forwarded-For` from the right, skipping
+    entries added by your own proxies), `header` (a single-IP header your edge overwrites) or
+    `use_peer` (the TCP peer). `headers` is any mapping with lowercase names, or the headers
+    object of your framework.
+    """
+    chosen = sum((preset is not None, xff_hops is not None, header is not None, use_peer))
+    if chosen != 1:
+        raise ValueError("omnilimit: choose exactly one of preset, xff_hops, header or use_peer")
+    if preset is not None:
+        if preset not in _PRESETS:
+            raise ValueError("omnilimit: unknown IP preset")
+        header, xff_hops = _PRESETS[preset]
+    if xff_hops is not None:
+        if not isinstance(xff_hops, int) or isinstance(xff_hops, bool) or xff_hops < 0:
+            raise ValueError("omnilimit: hops must be a non-negative integer")
+        return _from_xff(_read_header(headers, "x-forwarded-for"), xff_hops)
+    if header is not None:
+        value = _read_header(headers, header.lower())
+        return canonical_ip(value.strip() if value is not None else None)
+    return canonical_ip(peer)

omnilimit/stores/__init__.py

@@ -0,0 +1 @@
+"""Stores. Each module imports its client lazily or not at all, so extras stay optional."""

omnilimit/stores/memory.py

@@ -0,0 +1,49 @@
+"""In-process store."""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections import OrderedDict
+from typing import Literal
+
+from omnilimit._gcra import MeterState, apply_hit
+from omnilimit._types import HitParams, RawHit
+
+
+class MemoryStore:
+    """Exact within one process and independent per instance: N instances allow about N times
+    the limit. It is thread-safe, and `max_keys` stops rotating ids from exhausting memory.
+    """
+
+    tier: Literal["local"] = "local"
+
+    def __init__(self, max_keys: int = 100_000) -> None:
+        if not isinstance(max_keys, int) or isinstance(max_keys, bool) or max_keys < 1:
+            raise ValueError("omnilimit: max_keys must be a positive integer")
+        self._max_keys = max_keys
+        self._lock = threading.Lock()
+        # key -> (state, expires_at); insertion order tracks recency
+        self._entries: OrderedDict[str, tuple[MeterState, int]] = OrderedDict()
+
+    def hit(self, key: str, params: HitParams, now_ms: int | None = None) -> RawHit:
+        now = now_ms if now_ms is not None else time.time_ns() // 1_000_000
+        with self._lock:
+            entry = self._entries.get(key)
+            hit, write = apply_hit(entry[0] if entry else None, params, now)
+            if write is not None:
+                self._entries[key] = (write, write.ts + params.drain_ms)
+                self._entries.move_to_end(key)
+                self._evict(now)
+            return hit
+
+    def _evict(self, now: int) -> None:
+        if len(self._entries) <= self._max_keys:
+            return
+        for key, (_, expires_at) in list(self._entries.items()):
+            if expires_at <= now:
+                del self._entries[key]
+            if len(self._entries) <= self._max_keys:
+                return
+        while len(self._entries) > self._max_keys:
+            self._entries.popitem(last=False)

omnilimit/stores/postgres.py

@@ -0,0 +1,91 @@
+"""Postgres stores: atomic and shared, using a row lock per bucket and the database clock.
+
+They are good when Postgres is already there. Each hit is a write, so they are not meant for
+high traffic. They take a psycopg 3 pool, or a connection with `autocommit=True`: anything else
+would hold the bucket's row lock until the surrounding transaction ends.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from omnilimit._generated import POSTGRES_MIGRATION_SQL
+from omnilimit._types import HitParams, RawHit
+
+MIGRATION_SQL = POSTGRES_MIGRATION_SQL
+"""Creates the table and functions. Apply it with your migration tool; it never runs on its own."""
+
+_HIT_SQL = (
+    "SELECT allowed, new_level, new_ts FROM omnilimit_hit_v1("
+    "%s::text, %s::bigint, %s::bigint, %s::bigint, %s::bigint, %s::bigint)"
+)
+_CLEANUP_SQL = "SELECT omnilimit_cleanup_v1(%s::integer)"
+
+
+def _is_pool(db: Any) -> bool:
+    # A connection also has a `.connection` attribute, so that cannot tell them apart.
+    return not hasattr(db, "execute")
+
+
+def _check_db(db: Any) -> None:
+    if not _is_pool(db) and getattr(db, "autocommit", False) is not True:
+        raise ValueError("omnilimit: pass a psycopg pool, or a connection with autocommit=True")
+
+
+def _hit_params(key: str, params: HitParams, now_ms: int | None) -> tuple[Any, ...]:
+    return (key, params.limit, params.window_ms, params.capacity, params.drain_ms, now_ms)
+
+
+def _parse(row: Any) -> RawHit:
+    if row is None:
+        raise ValueError("omnilimit: omnilimit_hit_v1 returned no rows")
+    return RawHit(allowed=row[0] is True, level=int(row[1]), ts=int(row[2]))
+
+
+class PostgresStore:
+    """For blocking connections and pools. Use it with `Limiter`."""
+
+    tier: Literal["exact"] = "exact"
+
+    def __init__(self, db: Any) -> None:
+        _check_db(db)
+        self._db = db
+
+    def _fetch(self, sql: str, params: tuple[Any, ...]) -> Any:
+        if _is_pool(self._db):
+            with self._db.connection() as connection:
+                return connection.execute(sql, params).fetchone()
+        return self._db.execute(sql, params).fetchone()
+
+    def hit(self, key: str, params: HitParams, now_ms: int | None = None) -> RawHit:
+        return _parse(self._fetch(_HIT_SQL, _hit_params(key, params, now_ms)))
+
+    def cleanup(self, batch: int = 1000) -> int:
+        """Delete up to `batch` expired buckets and return how many. Schedule it yourself."""
+        return int(self._fetch(_CLEANUP_SQL, (batch,))[0])
+
+
+class AsyncPostgresStore:
+    """For async connections and pools. Use it with `AsyncLimiter`."""
+
+    tier: Literal["exact"] = "exact"
+
+    def __init__(self, db: Any) -> None:
+        _check_db(db)
+        self._db = db
+
+    async def _fetch(self, sql: str, params: tuple[Any, ...]) -> Any:
+        if _is_pool(self._db):
+            async with self._db.connection() as connection:
+                cursor = await connection.execute(sql, params)
+                return await cursor.fetchone()
+        cursor = await self._db.execute(sql, params)
+        return await cursor.fetchone()
+
+    async def hit(self, key: str, params: HitParams, now_ms: int | None = None) -> RawHit:
+        return _parse(await self._fetch(_HIT_SQL, _hit_params(key, params, now_ms)))
+
+    async def cleanup(self, batch: int = 1000) -> int:
+        """Delete up to `batch` expired buckets and return how many. Schedule it yourself."""
+        row = await self._fetch(_CLEANUP_SQL, (batch,))
+        return int(row[0])

omnilimit/stores/redis.py

@@ -0,0 +1,77 @@
+"""Redis and Valkey stores: atomic, shared across instances and languages, on the server clock.
+
+They take a client from `redis` or `valkey`, or anything with the same `evalsha` and `eval`.
+Set `socket_timeout` and `socket_connect_timeout` on it.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any, Literal
+
+from omnilimit._generated import REDIS_HIT_LUA, REDIS_HIT_SHA1
+from omnilimit._types import HitParams, RawHit
+
+
+def _is_no_script(error: Exception) -> bool:
+    # redis-py strips the NOSCRIPT prefix from the message and raises NoScriptError.
+    return (
+        type(error).__name__ == "NoScriptError"
+        or "NOSCRIPT" in str(error)
+        or "No matching script" in str(error)
+    )
+
+
+def _args(params: HitParams, now_ms: int | None) -> list[str]:
+    return [
+        str(params.limit),
+        str(params.window_ms),
+        str(params.capacity),
+        str(params.drain_ms),
+        "" if now_ms is None else str(now_ms),
+    ]
+
+
+def _parse(reply: Any) -> RawHit:
+    if not isinstance(reply, Sequence) or isinstance(reply, str | bytes) or len(reply) != 3:
+        raise ValueError("omnilimit: unexpected reply from the Redis script")
+    # Values arrive as bytes or str, depending on the client's decode_responses.
+    return RawHit(allowed=int(reply[0]) == 1, level=int(reply[1]), ts=int(reply[2]))
+
+
+class RedisStore:
+    """For blocking clients. Use it with `Limiter`."""
+
+    tier: Literal["exact"] = "exact"
+
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def hit(self, key: str, params: HitParams, now_ms: int | None = None) -> RawHit:
+        args = _args(params, now_ms)
+        try:
+            reply = self._client.evalsha(REDIS_HIT_SHA1, 1, key, *args)
+        except Exception as error:
+            if not _is_no_script(error):
+                raise
+            reply = self._client.eval(REDIS_HIT_LUA, 1, key, *args)
+        return _parse(reply)
+
+
+class AsyncRedisStore:
+    """For `redis.asyncio` and `valkey.asyncio` clients. Use it with `AsyncLimiter`."""
+
+    tier: Literal["exact"] = "exact"
+
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    async def hit(self, key: str, params: HitParams, now_ms: int | None = None) -> RawHit:
+        args = _args(params, now_ms)
+        try:
+            reply = await self._client.evalsha(REDIS_HIT_SHA1, 1, key, *args)
+        except Exception as error:
+            if not _is_no_script(error):
+                raise
+            reply = await self._client.eval(REDIS_HIT_LUA, 1, key, *args)
+        return _parse(reply)

omnilimit-0.1.0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.5
+Name: omnilimit
+Version: 0.1.0
+Summary: Rate limiting that behaves the same across stacks, with trusted client IPs and an explicit failure mode.
+Project-URL: Homepage, https://github.com/PabloAlaniz/omnilimit
+Project-URL: Repository, https://github.com/PabloAlaniz/omnilimit
+Project-URL: Specification, https://github.com/PabloAlaniz/omnilimit/blob/main/spec/SPEC.md
+Author: Pablo Alaniz
+License-Expression: MIT
+License-File: LICENSE
+Keywords: fastapi,gcra,postgres,rate-limit,rate-limiting,redis,x-forwarded-for
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.109; extra == 'fastapi'
+Provides-Extra: postgres
+Requires-Dist: psycopg>=3.1; extra == 'postgres'
+Provides-Extra: redis
+Requires-Dist: redis>=5.0; extra == 'redis'
+Description-Content-Type: text/markdown
+
+# omnilimit for Python
+
+Rate limiting that behaves the same across stacks, and proves it. This port follows the same [spec](https://github.com/PabloAlaniz/omnilimit/blob/main/spec/SPEC.md) and passes the same conformance vectors as the TypeScript one, and both can share a counter in Redis or Postgres.
+
+- **Trusted client IPs.** It reads `X-Forwarded-For` from the right. Rotating the header does not evade the limit.
+- **An explicit failure mode.** You must decide, per limiter, what happens when the store is down.
+- **No dependencies.** Extras only install a client: `omnilimit[redis]`, `omnilimit[postgres]`, `omnilimit[fastapi]`.
+
+```bash
+pip install omnilimit
+```
+
+## Usage
+
+```python
+from redis import Redis
+
+from omnilimit import Limiter
+from omnilimit.stores.redis import RedisStore
+
+client = Redis.from_url(url, socket_timeout=0.25, socket_connect_timeout=0.25)
+limiter = Limiter(
+    store=RedisStore(client),
+    scope="login",
+    limit=5,
+    window_ms=60_000,
+    burst=2,
+    on_store_error="closed",  # required: "open" lets requests through, "closed" answers 503
+)
+
+decision = limiter.check(user_id)
+if not decision.allowed:
+    ...  # answer decision.status with decision.headers, which include Retry-After
+```
+
+`5` per minute with burst 5 can admit 9 requests in one minute: this is a rate, not a counter that resets. Lower `burst` if you need fewer.
+
+## Sync or async
+
+| Code | Limiter | Stores |
+|---|---|---|
+| Flask, Django, `def` dependencies | `Limiter` | `MemoryStore`, `RedisStore`, `PostgresStore` |
+| `async def` | `AsyncLimiter` | `MemoryStore`, `AsyncRedisStore`, `AsyncPostgresStore` |
+
+`Limiter` runs each store call in its own daemon thread, because Python cannot abandon a blocking call. `store_timeout_ms` bounds the request, and `max_store_threads` bounds the calls in flight. Set socket timeouts on your client as well, so a hung call ends.
+
+redis-py caps its pool and raises past that cap, which `omnilimit` reports as a store failure. If you expect bursts of concurrent checks, use `BlockingConnectionPool`.
+
+## FastAPI
+
+```python
+from fastapi import Depends, FastAPI
+
+from omnilimit import MemoryStore, Limiter
+from omnilimit.fastapi import ip_key, rate_limit
+
+limiter = Limiter(
+    store=MemoryStore(), scope="api", limit=100, window_ms=60_000, on_store_error="open"
+)
+app = FastAPI(dependencies=[
+    Depends(rate_limit(limiter, key=ip_key(preset="cloud-run"), on_missing_key="shared")),
+])
+```
+
+Denials raise `HTTPException`, so your own handlers format them. Headers on allowed requests are not added when a route returns its own `Response` object, as a file download usually does.
+
+## Client IP only
+
+`omnilimit.ip` uses only the standard library and also works next to `slowapi`:
+
+```python
+from omnilimit.ip import resolve_client_ip
+
+ip = resolve_client_ip(request.headers, request.client.host, preset="cloud-run-lb")
+```
+
+It returns `None` rather than guessing. Check that the preset matches your deployment: see [client IP](https://github.com/PabloAlaniz/omnilimit/blob/main/docs/client-ip.md).
+
+## Postgres
+
+`omnilimit.stores.postgres.MIGRATION_SQL` creates the table and functions: apply it with your migration tool. Stores take a psycopg 3 pool or a connection with `autocommit=True`. Each hit is a write, so it is not meant for high traffic, and `cleanup()` is yours to schedule.

omnilimit-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+omnilimit/__init__.py,sha256=N2saauxmlT7Uz2_fdyCqtPsGl72q3on1KCWHUcpnyyQ,973
+omnilimit/_gcra.py,sha256=aaTckuox3Mp_SZNjr6uex8zF4Ig9XdPqUY0ljSBQJgI,3502
+omnilimit/_generated.py,sha256=fPemu-Ld9EDjEo9t8LqLbTXduh94ZL-2aRFqOyuThSc,4090
+omnilimit/_headers.py,sha256=SBGIL7BRPI7FrmKpwPC8l0OrossqhysJD-ZXaVGt4OI,1060
+omnilimit/_key.py,sha256=zA_1bXP8i9bvbV0wfyFQD_wbNBiw8TIcxJn5_W-liF4,948
+omnilimit/_limiter.py,sha256=pJznnD2n_i0MHoziPHTy7od9OX8SgzEi7-57QDiSyZo,9680
+omnilimit/_types.py,sha256=Oo8URs2fZ5jxB-Y2ItcJp_to2CJY9MTK5Qatgmue8ug,2253
+omnilimit/fastapi.py,sha256=3RoErR9tx5XiLzde3qe9abYhOZl1amy1lvjiyXe4-w4,4148
+omnilimit/ip.py,sha256=cOb5Ns1nD6zgw78vg6OP87FjoVRXYqgDJp9uwomAufw,4823
+omnilimit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omnilimit/stores/__init__.py,sha256=CRj-mzVzNgedxEGaSaK5pcagYYAgJOEW2FqY5HfqKyU,92
+omnilimit/stores/memory.py,sha256=bY6DrRIgH_FXhZYO3HkH7Yk_a3N9x8xOhl0PpRbiK4E,1887
+omnilimit/stores/postgres.py,sha256=lwHvxauF7-UIx9ZteqBTydi9ligjdFK2cRtVwyOd9FU,3482
+omnilimit/stores/redis.py,sha256=DCNdshsxBeu8YcuNv2c5yFaYNYTjfV9FlZC-JZYz3ps,2611
+omnilimit-0.1.0.dist-info/METADATA,sha256=VcO_MDWvJ0iipBKGNAtlUVJS4vzkLF2ZghaRZ2_vR0M,4545
+omnilimit-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+omnilimit-0.1.0.dist-info/licenses/LICENSE,sha256=25xFe8kmZ3TZzs93SbzlDP_OHHkT5lsANRqQ_Ao2A0M,1069
+omnilimit-0.1.0.dist-info/RECORD,,

omnilimit-0.1.0.dist-info/WHEEL

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

omnilimit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pablo Alaniz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.