ResearchOS / src /api /persist.py
Kagzy's picture
feedback persistence; probe traffic excluded from v2 metrics
273dddc verified
Raw History Blame Contribute Delete
4.16 kB
"""Keep the feedback database across restarts of a free Hugging Face Space.
A free Space's disk is ephemeral: every restart, rebuild or sleep starts from
the repository again. The feedback database - queries, clicks, votes and the
v2 retry funnel, including the retried-then-clicked pairs meant to become
training data - would be wiped each time, so the live measurement could
never accumulate.
When FEEDBACK_REPO (a dataset repo id, e.g. "you/researchos-feedback") and
HF_TOKEN (a write token) are set as Space secrets, the database is restored
from that private dataset on boot and snapshotted back every few minutes.
Unset, nothing happens: local runs keep their file on a real disk anyway.
The snapshot uses SQLite's online backup API, so it is consistent even while
requests are writing; copying the file directly could capture a torn page.
It is only uploaded when the database actually changed.
"""
from __future__ import annotations
import os
import shutil
import sqlite3
import tempfile
import threading
import time
from contextlib import closing
from pathlib import Path
SYNC_EVERY_S = 600.0
def _settings() -> tuple[str, str] | None:
repo, token = os.environ.get("FEEDBACK_REPO"), os.environ.get("HF_TOKEN")
return (repo, token) if repo and token else None
def restore(db_path: str) -> bool:
"""Pull the last snapshot down before the app opens the database."""
settings = _settings()
if settings is None or Path(db_path).exists():
return False
repo, token = settings
try:
from huggingface_hub import hf_hub_download
cached = hf_hub_download(repo, Path(db_path).name, repo_type="dataset", token=token)
Path(db_path).parent.mkdir(parents=True, exist_ok=True)
shutil.copyfile(cached, db_path)
print(f"[persist] restored {db_path} from {repo}", flush=True)
return True
except Exception as exc: # noqa: BLE001 - first boot has nothing to restore
print(f"[persist] nothing restored ({type(exc).__name__}); starting fresh", flush=True)
return False
def _fingerprint(db_path: str) -> tuple[int, ...]:
# closing(): sqlite3's own context manager commits but never closes.
with closing(sqlite3.connect(db_path)) as conn:
return tuple(
conn.execute(f"SELECT COALESCE(MAX(id), 0) FROM {t}").fetchone()[0]
for t in ("queries", "citation_clicks", "votes", "errors")
)
def snapshot_once(db_path: str, repo: str, token: str, last: tuple | None) -> tuple | None:
"""Upload a consistent copy if anything changed. Returns the new fingerprint."""
current = _fingerprint(db_path)
if current == last:
return last
from huggingface_hub import HfApi
with tempfile.TemporaryDirectory() as tmp:
snap = Path(tmp) / Path(db_path).name
with closing(sqlite3.connect(db_path)) as src, closing(sqlite3.connect(snap)) as dst:
src.backup(dst)
api = HfApi(token=token)
api.create_repo(repo, repo_type="dataset", private=True, exist_ok=True)
api.upload_file(path_or_fileobj=str(snap), path_in_repo=snap.name, repo_id=repo,
repo_type="dataset", commit_message="feedback snapshot")
return current
def start_sync(db_path: str, every_s: float = SYNC_EVERY_S) -> threading.Thread | None:
"""Snapshot in the background for the life of the process."""
settings = _settings()
if settings is None:
return None
repo, token = settings
def loop() -> None:
last = None
while True:
time.sleep(every_s)
try:
last = snapshot_once(db_path, repo, token, last)
except Exception as exc: # noqa: BLE001 - never take the app down
print(f"[persist] snapshot failed: {type(exc).__name__}: {exc}", flush=True)
thread = threading.Thread(target=loop, name="feedback-sync", daemon=True)
thread.start()
print(f"[persist] syncing {db_path} to {repo} every {every_s / 60:.0f} min", flush=True)
return thread