Sync from kink_cli (Docker Space)

api.py

@@ -138,6 +138,25 @@ def _warn_or_fail_ephemeral_store(path: Path) -> None:
         raise RuntimeError(msg)
 
 
+def _boot_phase(name: str) -> "_BootTimer":
+    return _BootTimer(name)
+
+
+class _BootTimer:
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self._t0 = 0.0
+
+    def __enter__(self) -> "_BootTimer":
+        self._t0 = time.monotonic()
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        dt = time.monotonic() - self._t0
+        status = "err" if exc_type else "ok"
+        print(f"[kink_cli boot] phase={self.name} seconds={dt:.2f} status={status}", flush=True)
+
+
 def _get_backend() -> Backend:
     """Open SQLite + warm caches on first use so uvicorn can bind before a multi‑GB Hub download finishes."""
     global _backend_impl
@@ -146,25 +165,33 @@ def _get_backend() -> Backend:
     with _backend_lock:
         if _backend_impl is not None:
             return _backend_impl
-        ensure_media_cache(MEDIA_ROOT)
-        path = ensure_store_db(_default_store)
+        total_t0 = time.monotonic()
+        with _boot_phase("media_cache"):
+            ensure_media_cache(MEDIA_ROOT)
+        with _boot_phase("ensure_store_db"):
+            path = ensure_store_db(_default_store)
         _warn_or_fail_ephemeral_store(path)
-        _restore_user_snapshot_on_boot(path)
-        b = Backend(path)
+        with _boot_phase("user_snapshot_restore"):
+            _restore_user_snapshot_on_boot(path)
+        with _boot_phase("backend_ctor"):
+            b = Backend(path)
         # Catalog must be ready before the first recommendations request. Build it once here:
         # starting a warm thread and then blocking can double-build on slow cpu-basic Spaces.
-        b._catalog()
+        with _boot_phase("catalog_build"):
+            b._catalog()
         # PPR / full similarity graph warm is RAM-heavy on multi‑GB catalogs; skip only that on
         # small Spaces (see Dockerfile KINK_SKIP_HEAVY_WARM).
         if os.environ.get("KINK_SKIP_HEAVY_WARM", "").strip().lower() not in ("1", "true", "yes", "on"):
-            from backend.recsys_graph import warm_ppr_caches
+            with _boot_phase("ppr_warm"):
+                from backend.recsys_graph import warm_ppr_caches
 
-            warm_ppr_caches(b)
+                warm_ppr_caches(b)
         _backend_impl = b
         if os.environ.get("KINK_BACKGROUND_PPR_WARM", "").strip().lower() in ("1", "true", "yes", "on"):
             from backend.recsys_graph import warm_ppr_caches_in_background
 
             warm_ppr_caches_in_background(b)
+        print(f"[kink_cli boot] phase=total seconds={time.monotonic() - total_t0:.2f} status=ok", flush=True)
         return b
 
 

backend/catalog.py

@@ -29,10 +29,60 @@ from models import (
     FetlifePictureRef,
     Kink,
     KinkExample,
+    KinkLemma,
     KinkScenarioParent,
     SimilarityEdge,
 )
 
+
+def _lemma_name_hash(name: str) -> str:
+    """Fingerprint a kink name so the lemma cache invalidates when the name changes."""
+    import hashlib
+    return hashlib.sha1(name.encode("utf-8")).hexdigest()
+
+
+def _load_cached_lemma_signatures(
+    self,
+    candidates: dict[str, dict[str, Any]],
+) -> tuple[dict[str, str], list[tuple[str, str, str]]]:
+    """Return (cached_lemmas_by_kid, empty_writebacks_list).
+
+    A cached row is only returned when its ``name_hash`` matches the current candidate name —
+    stale rows are silently ignored (caller will recompute and overwrite).
+    """
+    try:
+        with self._sqlite() as conn:
+            rows = conn.execute("SELECT kink_id, name_hash, signature FROM kinklemma").fetchall()
+    except sqlite3.OperationalError:
+        return {}, []
+    cached: dict[str, str] = {}
+    for row in rows:
+        kid = row["kink_id"]
+        if kid not in candidates:
+            continue
+        if row["name_hash"] != _lemma_name_hash(str(candidates[kid].get("name", "") or "")):
+            continue
+        cached[kid] = row["signature"] or ""
+    return cached, []
+
+
+def _persist_cached_lemma_signatures(
+    self,
+    rows: list[tuple[str, str, str]],
+) -> None:
+    if not rows:
+        return
+    try:
+        with self._sqlite() as conn:
+            conn.executemany(
+                "INSERT INTO kinklemma (kink_id, name_hash, signature) VALUES (?, ?, ?) "
+                "ON CONFLICT(kink_id) DO UPDATE SET name_hash=excluded.name_hash, signature=excluded.signature",
+                rows,
+            )
+            conn.commit()
+    except sqlite3.OperationalError:
+        return
+
 _IMAGE_TOKEN_RE = re.compile(r"[a-z0-9]+")
 _IMAGE_RELEVANCE_STOPWORDS = {"and", "the", "play", "sex", "in", "with"}
 _PRODUCT_FLAG_KEYS = (
@@ -603,6 +653,7 @@ def _mark_runtime_duplicates(
     # "Cuddling after sex") that ``merge_signature``'s sorted-token-set misses. F1 0.80 on the
     # hand-labeled set vs F1 0.29 for ``merge_signature`` alone — see scripts/merge_dedup_eval.py.
     lemma_groups: defaultdict[tuple[str, str], list[str]] = defaultdict(list)
+    cached_lemmas, lemma_writebacks = _load_cached_lemma_signatures(self, candidates)
     for kid, summary in candidates.items():
         cluster = str(summary.get("cluster", "") or "")
         name = str(summary.get("name", "") or "")
@@ -612,9 +663,14 @@ def _mark_runtime_duplicates(
         cf = compact_form(name)
         if len(cf) >= 8:
             compact_groups[(cluster, cf)].append(kid)
-        lemma_sig = lemma_signature(name)
+        if kid in cached_lemmas:
+            lemma_sig = cached_lemmas[kid]
+        else:
+            lemma_sig = lemma_signature(name)
+            lemma_writebacks.append((kid, _lemma_name_hash(name), lemma_sig))
         if lemma_sig:
             lemma_groups[(cluster, lemma_sig)].append(kid)
+    _persist_cached_lemma_signatures(self, lemma_writebacks)
 
     def _canonical_key(kid: str) -> tuple[int, int, float, int, str]:
         """Sort key — higher is better. Strict preference: has_definition first, then well-cased

models.py

@@ -151,6 +151,19 @@ class Alias(SQLModel, table=True):
     source_id: str = Field(foreign_key="source.id")
 
 
+class KinkLemma(SQLModel, table=True):
+    """Per-kink cached spaCy lemma signature used by play-dedupe at catalog build.
+
+    Populated lazily on first build and persisted so subsequent boots avoid the ~55s
+    spaCy pass over the full catalog. `name_hash` is the kink name at the time the
+    signature was computed; a name change forces a recompute via the dedupe loop.
+    """
+
+    kink_id: str = Field(primary_key=True, foreign_key="kink.id")
+    name_hash: str
+    signature: str
+
+
 class KinkFacet(SQLModel, table=True):
     id: str = Field(primary_key=True)
     kink_id: str = Field(foreign_key="kink.id", index=True)