superlocalmemory 4.1.13 → 4.1.15

package/src/superlocalmemory/core/recall_worker.py

@@ -1,414 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Subprocess recall worker — runs the full recall pipeline in isolation.
-
-The dashboard/MCP main process NEVER imports torch, numpy, or the engine.
-All heavy work (engine init, embedding, retrieval, reranking) happens here.
-
-Protocol (JSON over stdin/stdout):
-  Request:  {"cmd": "recall", "query": "...", "limit": 10}
-  Response: {"ok": true, "results": [...], "query_type": "...", ...}
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import signal
-import sys
-
-# Force CPU BEFORE any torch import
-os.environ["CUDA_VISIBLE_DEVICES"] = ""
-os.environ["PYTORCH_MPS_HIGH_WATERMARK_RATIO"] = "0.0"
-os.environ["PYTORCH_MPS_MEM_LIMIT"] = "0"
-os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
-os.environ["TORCH_DEVICE"] = "cpu"
-# V3.4.37: Disable CoreML EP — uses 3-5GB on ARM64 Mac.
-os.environ["ORT_DISABLE_COREML"] = "1"
-
-# SIGTERM bridge: Docker/systemd send SIGTERM to stop processes.
-# Without this, the worker ignores SIGTERM and becomes a zombie.
-if sys.platform != "win32":
-    signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
-
-
-def _start_parent_watchdog() -> None:
-    """Monitor parent process — self-terminate if parent dies.
-
-    V3.4.24: Delegates to platform_utils.start_parent_watchdog().
-    """
-    from superlocalmemory.core.platform_utils import start_parent_watchdog
-    start_parent_watchdog()
-
-_engine = None
-
-
-def _get_engine():
-    global _engine
-    if _engine is None:
-        from superlocalmemory.core.config import SLMConfig
-        from superlocalmemory.core.engine import MemoryEngine
-        config = SLMConfig.load()
-        _engine = MemoryEngine(config)
-        _engine.initialize()
-    return _engine
-
-
-def _handle_recall(
-    query: str, limit: int, session_id: str = "", fast: bool = False,
-    include_global: bool | None = None, include_shared: bool | None = None,
-    window: str | None = None,
-    as_of: str | None = None,
-    known_as_of: str | None = None,
-    valid_at: str | None = None,
-    include_unknown: bool = False,
-) -> dict:
-    engine = _get_engine()
-    # v3.6.15 multi-scope: None flags let engine.recall resolve the configured
-    # default (shared-off). The subprocess loads its own SLMConfig, so the
-    # resolution is identical to the in-process / daemon paths.
-    response = engine.recall(
-        query, limit=limit, session_id=session_id or None, fast=bool(fast),
-        include_global=include_global, include_shared=include_shared,
-        window=window or None,
-        as_of=as_of or None,
-        known_as_of=known_as_of or None,
-        valid_at=valid_at or None,
-        include_unknown=include_unknown,
-    )
-
-    # Batch-fetch original memory text for all results. Retrieval already
-    # enforced scope, so resolve content for everything it returned (own +
-    # global + shared-with-me); another tenant's PRIVATE content still can't
-    # resolve. Using the raw (possibly-None) recall flags here would drop
-    # content for legitimately-recalled global/shared memories.
-    memory_ids = list({r.fact.memory_id for r in response.results[:limit] if r.fact.memory_id})
-    memory_map = engine._db.get_memory_content_batch(
-        memory_ids, engine.profile_id,
-        include_global=True, include_shared=True,
-    ) if memory_ids else {}
-
-    # v3.6.6: same shared chokepoint as the daemon HTTP route + CLI fallback,
-    # so the MCP WorkerPool subprocess path returns identical budgeted output.
-    from superlocalmemory.server.recall_serializer import (
-        recall_response_metadata,
-        serialize_recall_response,
-    )
-    _rc = getattr(engine._config, "retrieval", None)
-    results, no_confident_match = serialize_recall_response(
-        response,
-        limit=limit,
-        memory_map=memory_map,
-        per_fact_max=getattr(_rc, "recall_per_fact_max_chars", 2400),
-        total_max=getattr(_rc, "recall_total_max_chars", 12000),
-        # Markers only on session-bearing recalls: a marker exists to let a
-        # downstream reference be traced back to the recall that produced it,
-        # and only a session-bearing recall has something to trace back to.
-        # (An earlier comment here justified the condition by a
-        # ``pending_outcomes`` row that no code path writes; settlement reads
-        # the evidence recorded with the play instead.)
-        include_marker=bool(session_id),
-    )
-    return {
-        "ok": True,
-        "query": query,
-        "query_type": response.query_type,
-        "result_count": len(results),
-        "retrieval_time_ms": round(response.retrieval_time_ms, 1),
-        "channel_weights": {
-            k: round(v, 3) for k, v in (response.channel_weights or {}).items()
-        },
-        "total_candidates": getattr(response, "total_candidates", 0),
-        "results": results,
-        "no_confident_match": no_confident_match,
-        **recall_response_metadata(response),
-    }
-
-
-def _handle_store(content: str, metadata: dict) -> dict:
-    engine = _get_engine()
-    values = dict(metadata or {})
-    session_id = str(values.pop("session_id", "") or "")
-    scope = str(values.pop("scope", "personal") or "personal")
-    shared_with = list(values.pop("shared_with", []) or [])
-    idempotency_key = str(values.pop("idempotency_key", "") or "")
-    from superlocalmemory.core.engine_ingestion import (
-        canonical_store,
-        local_trusted_actor_id,
-    )
-    operation = canonical_store(
-        engine,
-        content,
-        source_type="mcp-offline-worker",
-        trusted_actor_id=local_trusted_actor_id("recall-worker"),
-        metadata=values,
-        scope=scope,
-        shared_with=shared_with,
-        session_id=session_id,
-        idempotency_key=idempotency_key,
-        return_receipt=True,
-    )
-    if hasattr(operation, "fact_ids"):
-        fact_ids = list(operation.fact_ids)
-        operation_id = getattr(operation, "operation_id", None)
-        materialization_state = getattr(
-            getattr(operation, "state", None), "value", "complete"
-        )
-    else:
-        fact_ids = list(operation)
-        operation_id = None
-        materialization_state = "complete"
-
-    # Generate and persist summary immediately after store (Mode A heuristic, B/C LLM)
-    if fact_ids:
-        try:
-            from superlocalmemory.core.summarizer import Summarizer
-            summarizer = Summarizer(engine._config)
-            summary = summarizer.summarize_cluster([{"content": content}])
-            if summary:
-                # Get the memory_id from the first stored fact
-                rows = engine._db.execute(
-                    "SELECT memory_id FROM atomic_facts WHERE fact_id = ? LIMIT 1",
-                    (fact_ids[0],),
-                )
-                if rows:
-                    memory_id = dict(rows[0])["memory_id"]
-                    engine._db.update_memory_summary(memory_id, summary)
-        except Exception:
-            pass  # Summary is non-critical
-
-    pending = materialization_state != "complete"
-    return {
-        "ok": True,
-        "fact_ids": fact_ids,
-        "count": len(fact_ids),
-        "operation_id": operation_id,
-        "pending_id": operation_id if pending else None,
-        "materialization_state": materialization_state,
-    }
-
-
-def _handle_get_memory_facts(memory_id: str) -> dict:
-    engine = _get_engine()
-    pid = engine.profile_id
-    # Get original memory content (C4: tenant-scoped; global/shared resolvable)
-    mem_map = engine._db.get_memory_content_batch(
-        [memory_id], pid, include_global=True, include_shared=True,
-    )
-    original = mem_map.get(memory_id, "")
-    # Get child facts — same scope as the content fetch so a shared/global
-    # memory's facts are not silently empty.
-    facts = engine._db.get_facts_by_memory_id(
-        memory_id, pid, include_global=True, include_shared=True)
-    fact_list = []
-    for f in facts:
-        fact_list.append({
-            "fact_id": f.fact_id,
-            "content": f.content,
-            "fact_type": f.fact_type.value if hasattr(f.fact_type, 'value') else str(f.fact_type),
-            "confidence": round(f.confidence, 3),
-            "created_at": f.created_at,
-        })
-    return {
-        "ok": True,
-        "memory_id": memory_id,
-        "original_content": original,
-        "facts": fact_list,
-        "fact_count": len(fact_list),
-    }
-
-
-def _handle_delete_memory(
-    fact_id: str,
-    source_agent_id: str = "system",
-) -> dict:
-    """Delete a fact after capability-derived authorization."""
-    engine = _get_engine()
-    from superlocalmemory.core.engine_ingestion import local_trusted_actor_id
-    from superlocalmemory.core.mutations import delete_fact_authorized
-
-    return delete_fact_authorized(
-        engine,
-        fact_id,
-        trusted_actor_id=local_trusted_actor_id("recall-worker"),
-        source_agent_id=source_agent_id,
-    )
-
-
-def _handle_update_memory(
-    fact_id: str,
-    content: str,
-    source_agent_id: str = "system",
-) -> dict:
-    """Update a fact after capability-derived authorization.
-
-    CORRECTIONS CANNOT BE PERFORMED FROM THIS WORKER, AND THAT IS BY DESIGN.
-
-    Since corrections became a review-gated lifecycle (M042) rather than an
-    in-place edit, update_fact_authorized() requires a canonical correction
-    writer. That writer is the daemon's single-writer mutation boundary
-    (CanonicalRememberRuntime, owned by unified_daemon and handed to the HTTP
-    route). A worker subprocess cannot own it: CanonicalRememberRuntime.ready
-    requires a live worker of its own, so constructing one here would nest
-    worker processes and hand a second writer the ownership context that is
-    supposed to be exclusive.
-
-    Previously this called through anyway, and mutations.py answered
-    "canonical correction writer is temporarily unavailable" with
-    retryable=True. Nothing about it was temporary — with the daemon down that
-    path can NEVER succeed, so a caller could retry forever. This is the
-    honest, non-retryable answer with the actual remedy: the daemon-backed
-    route (used automatically whenever the daemon is running) does support
-    corrections.
-    """
-    return {
-        "ok": False,
-        "retryable": False,
-        "error": (
-            "Corrections are review-gated and require the SuperLocalMemory "
-            "daemon, which owns the single correction writer. Start it with "
-            "`slm serve start` and retry — updates route through the daemon "
-            "automatically when it is running."
-        ),
-        "remedy": "slm serve start",
-        "fact_id": fact_id,
-    }
-
-
-def _handle_summarize(texts: list[str], mode: str) -> dict:
-    """Generate summary using heuristic (A) or LLM (B/C)."""
-    from superlocalmemory.core.summarizer import Summarizer
-    engine = _get_engine()
-    summarizer = Summarizer(engine._config)
-    summary = summarizer.summarize_cluster(
-        [{"content": t} for t in texts],
-    )
-    return {"ok": True, "summary": summary}
-
-
-def _handle_synthesize(query: str, facts: list[dict]) -> dict:
-    """Generate synthesized answer from query + facts."""
-    from superlocalmemory.core.summarizer import Summarizer
-    engine = _get_engine()
-    summarizer = Summarizer(engine._config)
-    synthesis = summarizer.synthesize_answer(query, facts)
-    return {"ok": True, "synthesis": synthesis}
-
-
-def _handle_status() -> dict:
-    engine = _get_engine()
-    pid = engine.profile_id
-    fact_count = engine._db.get_fact_count(pid)
-    return {
-        "ok": True,
-        "mode": engine._config.mode.value,
-        "profile": pid,
-        "fact_count": fact_count,
-    }
-
-
-def _worker_main() -> None:
-    """Main loop: read JSON requests from stdin, write responses to stdout."""
-    _start_parent_watchdog()
-    from superlocalmemory.core.platform_utils import get_rss_mb
-
-    for line in sys.stdin:
-        line = line.strip()
-        if not line:
-            continue
-        try:
-            req = json.loads(line)
-        except json.JSONDecodeError:
-            _respond({"ok": False, "error": "Invalid JSON"})
-            continue
-
-        cmd = req.get("cmd", "")
-
-        if cmd == "quit":
-            break
-
-        if cmd == "ping":
-            _respond({"ok": True})
-            continue
-
-        if cmd == "warmup":
-            # Pre-load engine + database + embeddings only.
-            # V3.3.2: Do NOT run a dummy recall — it triggers the ONNX
-            # cross-encoder export (~30s) which combined with engine init
-            # exceeds the worker timeout. The cross-encoder loads lazily
-            # in a background thread on the first real recall instead.
-            try:
-                engine = _get_engine()
-                fact_count = engine._db.get_fact_count(engine._profile_id) if engine._db else 0
-                _respond({"ok": True, "message": "Engine warm", "facts": fact_count})
-            except Exception as exc:
-                _respond({"ok": False, "error": f"Warmup failed: {exc}"})
-            continue
-
-        try:
-            if cmd == "recall":
-                result = _handle_recall(
-                    req.get("query", ""), req.get("limit", 10),
-                    req.get("session_id", ""), bool(req.get("fast", False)),
-                    include_global=req.get("include_global"),
-                    include_shared=req.get("include_shared"),
-                    window=req.get("window"),
-                    as_of=req.get("as_of"),
-                    known_as_of=req.get("known_as_of"),
-                    valid_at=req.get("valid_at"),
-                    include_unknown=bool(req.get("include_unknown", False)),
-                )
-                _respond(result)
-            elif cmd == "store":
-                result = _handle_store(req.get("content", ""), req.get("metadata", {}))
-                _respond(result)
-            elif cmd == "delete_memory":
-                result = _handle_delete_memory(
-                    req.get("fact_id", ""),
-                    req.get("source_agent_id", req.get("agent_id", "system")),
-                )
-                _respond(result)
-            elif cmd == "update_memory":
-                result = _handle_update_memory(
-                    req.get("fact_id", ""),
-                    req.get("content", ""),
-                    req.get("source_agent_id", req.get("agent_id", "system")),
-                )
-                _respond(result)
-            elif cmd == "get_memory_facts":
-                result = _handle_get_memory_facts(req.get("memory_id", ""))
-                _respond(result)
-            elif cmd == "summarize":
-                result = _handle_summarize(req.get("texts", []), req.get("mode", "a"))
-                _respond(result)
-            elif cmd == "synthesize":
-                result = _handle_synthesize(req.get("query", ""), req.get("facts", []))
-                _respond(result)
-            elif cmd == "status":
-                _respond(_handle_status())
-            else:
-                _respond({"ok": False, "error": f"Unknown command: {cmd}"})
-        except Exception as exc:
-            _respond({"ok": False, "error": str(exc)})
-
-        # V3.3.16: RSS watchdog — V3.4.24: cross-platform via platform_utils.
-        rss_mb = get_rss_mb()
-        if rss_mb > 0 and rss_mb > 1500:
-            sys.exit(0)
-
-
-def _respond(data: dict) -> None:
-    sys.stdout.write(json.dumps(data) + "\n")
-    sys.stdout.flush()
-
-
-if __name__ == "__main__":
-    try:
-        _worker_main()
-    except KeyboardInterrupt:
-        sys.exit(0)

package/src/superlocalmemory/core/registry.py

@@ -1,121 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Agent registry — multi-agent profile isolation.
-
-Tracks which agents are using which profiles and prevents
-two agents from writing to the same profile simultaneously
-via an advisory lock mechanism. Persisted as JSON for
-survival across process restarts.
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: AGPL-3.0-or-later
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import time
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-class ProfileLockError(Exception):
-    """Raised when an agent tries to write-lock an already-locked profile."""
-
-
-class AgentRegistry:
-    """In-memory agent registry with JSON file persistence.
-
-    Each agent registers with an ID and a target profile.
-    Advisory write locks prevent two agents from mutating
-    the same profile at the same time.
-    """
-
-    def __init__(self, persist_path: Path | None = None) -> None:
-        self._agents: dict[str, dict[str, Any]] = {}
-        self._write_locks: dict[str, str] = {}  # profile_id -> agent_id
-        self._path = persist_path
-        if self._path and self._path.exists():
-            self._load()
-
-    # -- Public API ---------------------------------------------------------
-
-    def register_agent(self, agent_id: str, profile_id: str) -> None:
-        """Register an agent for a profile. Acquires advisory write lock."""
-        if agent_id in self._agents:
-            self.unregister_agent(agent_id)
-
-        holder = self._write_locks.get(profile_id)
-        if holder and holder != agent_id:
-            raise ProfileLockError(
-                f"Profile '{profile_id}' is locked by agent '{holder}'."
-            )
-
-        self._agents[agent_id] = {
-            "profile_id": profile_id,
-            "registered_at": time.time(),
-        }
-        self._write_locks[profile_id] = agent_id
-        self._save()
-        logger.info("Agent '%s' registered for profile '%s'", agent_id, profile_id)
-
-    def unregister_agent(self, agent_id: str) -> None:
-        """Remove an agent and release its write lock."""
-        entry = self._agents.pop(agent_id, None)
-        if entry:
-            profile_id = entry["profile_id"]
-            if self._write_locks.get(profile_id) == agent_id:
-                del self._write_locks[profile_id]
-            self._save()
-            logger.info("Agent '%s' unregistered", agent_id)
-
-    def get_agent_profile(self, agent_id: str) -> str:
-        """Return the profile ID for a registered agent.
-
-        Raises KeyError if the agent is not registered.
-        """
-        entry = self._agents.get(agent_id)
-        if entry is None:
-            raise KeyError(f"Agent '{agent_id}' is not registered.")
-        return entry["profile_id"]
-
-    def list_agents(self) -> list[dict[str, Any]]:
-        """Return a snapshot of all registered agents."""
-        return [
-            {
-                "agent_id": aid,
-                "profile_id": info["profile_id"],
-                "registered_at": info["registered_at"],
-            }
-            for aid, info in self._agents.items()
-        ]
-
-    # -- Persistence --------------------------------------------------------
-
-    def _save(self) -> None:
-        if not self._path:
-            return
-        self._path.parent.mkdir(parents=True, exist_ok=True)
-        data = {"agents": self._agents, "write_locks": self._write_locks}
-        self._path.write_text(json.dumps(data, indent=2), encoding="utf-8")
-
-    def _load(self) -> None:
-        if not self._path or not self._path.exists():
-            return
-        try:
-            data = json.loads(self._path.read_text(encoding="utf-8"))
-            self._agents = data.get("agents", {})
-            # D-01: write_locks from a prior process are meaningless after a
-            # process boundary — the agents that held them are dead.  Starting
-            # with no inherited locks prevents mcp_client (and any other agent)
-            # from being permanently blocked on every daemon restart.
-            self._write_locks = {}
-        except (json.JSONDecodeError, KeyError):
-            logger.warning("Corrupt registry file at %s — starting fresh.", self._path)
-            self._agents = {}
-            self._write_locks = {}

package/src/superlocalmemory/core/remember_admission.py

@@ -1,161 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-
-"""Journal-first service boundary for a durable, immediately-queryable remember."""
-
-from __future__ import annotations
-
-import math
-import time
-from collections.abc import Mapping
-from dataclasses import dataclass
-from typing import Any, Protocol
-
-from superlocalmemory.storage.admission_journal import (
-    Actor,
-    AdmissionJournal,
-    AdmissionJournalUnavailable,
-    PreparedAdmission,
-    RememberRequest,
-    TerminalAdmissionError,
-)
-
-
-class AdmissionRejected(RuntimeError):
-    """Canonical admission was not committed; the journal records its outcome."""
-
-    def __init__(self, error_code: str, *, retryable: bool = False) -> None:
-        super().__init__(error_code)
-        self.error_code = error_code
-        self.retryable = retryable
-
-
-@dataclass(frozen=True, slots=True)
-class RememberReceipt:
-    """Canonical receipt returned only after admission is queryable."""
-
-    payload: dict[str, Any]
-
-    @classmethod
-    def from_mapping(cls, receipt: Mapping[str, Any]) -> RememberReceipt:
-        return cls(payload=dict(receipt))
-
-
-@dataclass(frozen=True, slots=True)
-class RememberAdmissionCommand:
-    """Typed foreground input for a coordinator's bounded canonical transaction."""
-
-    journal_id: str
-    request_hash: str
-    request: RememberRequest
-    profile_id: str
-    idempotency_key: str
-
-    @classmethod
-    def from_prepared(
-        cls, prepared: PreparedAdmission, request: RememberRequest
-    ) -> RememberAdmissionCommand:
-        return cls(
-            journal_id=prepared.journal_id,
-            request_hash=prepared.request_hash,
-            request=request,
-            profile_id=prepared.profile_id,
-            idempotency_key=prepared.idempotency_key,
-        )
-
-
-class RememberCoordinator(Protocol):
-    def submit(self, command: RememberAdmissionCommand, *, wait_ms: int) -> Any: ...
-
-
-class RememberService:
-    """Apply the journaling pattern without doing enrichment inside admission."""
-
-    def __init__(self, journal: AdmissionJournal, coordinator: RememberCoordinator) -> None:
-        self._journal = journal
-        self._coordinator = coordinator
-
-    def remember(
-        self, request: RememberRequest, actor: Actor, *, deadline_ms: int
-    ) -> RememberReceipt:
-        if deadline_ms <= 0:
-            raise ValueError("deadline_ms must be greater than zero")
-        deadline = time.monotonic() + deadline_ms / 1_000
-        prepared = self._journal.prepare(
-            request,
-            actor,
-            deadline=deadline,
-        )
-        if prepared.original_receipt is not None:
-            return RememberReceipt.from_mapping(prepared.original_receipt)
-        if prepared.state == "rejected":
-            raise AdmissionRejected(prepared.error_code or "COMMAND_REJECTED")
-
-        command_request = self._journal.request_for(
-            prepared,
-            deadline=deadline,
-        )
-        dispatched = self._journal.mark_dispatched(
-            prepared.journal_id,
-            deadline=deadline,
-            known_prepared=prepared.state == "prepared",
-        )
-        if dispatched.original_receipt is not None:
-            return RememberReceipt.from_mapping(dispatched.original_receipt)
-        try:
-            result = self._coordinator.submit(
-                RememberAdmissionCommand.from_prepared(prepared, command_request),
-                wait_ms=_remaining_milliseconds(deadline),
-            )
-        except TerminalAdmissionError as exc:
-            self._journal.mark_rejected(
-                prepared.journal_id,
-                exc.error_code,
-                deadline=deadline,
-            )
-            raise AdmissionRejected(exc.error_code) from exc
-        state = _result_value(result, "state")
-        receipt = _result_value(result, "receipt") or {}
-        if state in {"committed", "duplicate"}:
-            if not isinstance(receipt, Mapping):
-                raise AdmissionRejected("COMMAND_REJECTED: canonical result had no receipt")
-            try:
-                committed = self._journal.mark_committed(
-                    prepared.journal_id,
-                    receipt,
-                    deadline=deadline,
-                )
-            except AdmissionJournalUnavailable:
-                # The canonical receipt is already durable and idempotent. Do
-                # not turn that committed write into an ambiguous client
-                # failure merely because the auxiliary journal exhausted the
-                # caller's remaining budget. The dispatched record is safe for
-                # retry/replay, which will recover the same immutable receipt.
-                return RememberReceipt.from_mapping(receipt)
-            return RememberReceipt.from_mapping(committed.original_receipt or receipt)
-
-        error_code = str(_result_value(result, "error_code") or "COMMAND_REJECTED")
-        if state == "rejected":
-            self._journal.mark_rejected(
-                prepared.journal_id,
-                error_code,
-                deadline=deadline,
-            )
-        raise AdmissionRejected(error_code, retryable=state != "rejected")
-
-
-def _result_value(result: Any, key: str) -> Any:
-    if isinstance(result, Mapping):
-        return result.get(key)
-    return getattr(result, key, None)
-
-
-def _remaining_seconds(deadline: float) -> float:
-    remaining = deadline - time.monotonic()
-    if remaining <= 0:
-        raise AdmissionJournalUnavailable("remember admission deadline expired")
-    return remaining
-
-
-def _remaining_milliseconds(deadline: float) -> int:
-    return max(1, math.ceil(_remaining_seconds(deadline) * 1_000))