Data Management and API Design Questions

import threading
import time
from typing import Any, Optional

class IdempotencyStore:
    def __init__(self, janitor_interval: Optional[float] = 60.0):
        self._store = {}  # key -> (response, expires_at)
        self._lock = threading.Lock()
        self._stop = threading.Event()
        self._janitor_interval = janitor_interval
        if janitor_interval:
            self._janitor = threading.Thread(target=self._run_janitor, daemon=True)
            self._janitor.start()

    def _now(self) -> float:
        return time.time()

    def _is_expired(self, expires_at: float) -> bool:
        return expires_at is not None and expires_at <= self._now()

    def put(self, key: str, response: Any, ttl_seconds: Optional[float] = None) -> Optional[Any]:
        """
        Store response for key with TTL. If key already present and not expired,
        return previous response and do NOT overwrite. If expired or absent, store and return None.
        """
        expires_at = None if ttl_seconds is None else self._now() + ttl_seconds
        with self._lock:
            item = self._store.get(key)
            if item:
                prev_resp, prev_exp = item
                if not self._is_expired(prev_exp):
                    return prev_resp  # idempotent: return previous response
                # expired: fall through to overwrite
            # store new entry
            self._store[key] = (response, expires_at)
            return None

    def get(self, key: str) -> Optional[Any]:
        """Return stored response or None if absent/expired."""
        with self._lock:
            item = self._store.get(key)
            if not item:
                return None
            resp, expires_at = item
            if self._is_expired(expires_at):
                # lazy eviction
                del self._store[key]
                return None
            return resp

    def _run_janitor(self):
        while not self._stop.wait(self._janitor_interval):
            now = self._now()
            with self._lock:
                keys_to_del = [k for k, (_, ex) in self._store.items() if ex is not None and ex <= now]
                for k in keys_to_del:
                    del self._store[k]

    def close(self):
        self._stop.set()
        if hasattr(self, "_janitor"):
            self._janitor.join(timeout=1)