Delete app.py

app.py

@@ -1,1348 +0,0 @@
-#!/usr/bin/env python3
-"""
-Ontology Semantic Search — Production Gradio App
-=================================================
-• UI loads immediately with empty state
-• Assets are downloaded only when the user clicks "Download & Load"
-• Warm-loads model in background once assets are present
-• Semantic search via ChromaDB + SentenceTransformers
-• Raw SQL console (SELECT-only by default)
-• Rebuild index from SQLite
-
-Dataset : https://huggingface.co/datasets/sensein/ontology-sqlite-vectorstore
-Run     : python app_gradio.py
-"""
-
-from __future__ import annotations
-
-import inspect
-import os
-import re
-import shutil
-import sqlite3
-import threading
-import time
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-
-import pandas as pd
-import gradio as gr
-import chromadb
-from chromadb.config import Settings
-from chromadb.errors import InternalError
-from sentence_transformers import SentenceTransformer
-import torch
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Paths & defaults
-# ─────────────────────────────────────────────────────────────────────────────
-
-CACHE_DIR          = Path(os.getenv("ONTOLOGY_CACHE_DIR",    "."))
-DEFAULT_DB_PATH    = str(CACHE_DIR / os.getenv("ONTOLOGY_DB_NAME",     "bioportal.db"))
-DEFAULT_CHROMA     = str(CACHE_DIR / os.getenv("ONTOLOGY_CHROMA_NAME", "bioportal_chroma"))
-DEFAULT_COLLECTION = os.getenv("ONTOLOGY_COLLECTION",  "ontology_classes")
-DEFAULT_MODEL      = os.getenv("ONTOLOGY_EMBED_MODEL", "BAAI/bge-base-en-v1.5")
-
-# All supported models shown in the UI dropdowns
-MODEL_CHOICES = [
-    "BAAI/bge-base-en-v1.5",
-    "BAAI/bge-large-en-v1.5",
-    "BAAI/bge-small-en-v1.5",
-    "sentence-transformers/all-MiniLM-L6-v2",
-]
-
-HF_DATASET_REPO   = "sensein/ontology-sqlite-vectorstore"
-HF_DB_FILENAME    = "bioportal.db"
-HF_CHROMA_ARCHIVE = "bioportal_chroma.tar.gz"
-
-LOGO_URL          = "https://avatars.githubusercontent.com/u/47326880"
-QUERY_PREFIX      = "Represent this sentence for searching relevant passages: "
-
-CACHE_DIR.mkdir(parents=True, exist_ok=True)
-
-# ─────────────────────────────────────────────────────────────────────────────
-# CSS
-# ─────────────────────────────────────────────────────────────────────────────
-
-CUSTOM_CSS = """
-body, .gradio-container { font-family: 'Inter', system-ui, sans-serif !important; }
-
-#app-header {
-    display: flex;
-    align-items: center;
-    gap: 20px;
-    background: linear-gradient(135deg, #1e3a5f 0%, #0f2540 60%, #162d4a 100%);
-    border-radius: 12px;
-    padding: 20px 28px;
-    margin-bottom: 16px;
-    box-shadow: 0 4px 20px rgba(0,0,0,.25);
-}
-#app-header img {
-    width: 56px; height: 56px;
-    border-radius: 10px;
-    border: 2px solid rgba(255,255,255,.2);
-    flex-shrink: 0;
-}
-#app-header-text h1 {
-    margin: 0;
-    font-size: 1.6rem; font-weight: 700;
-    color: #fff; letter-spacing: -.4px;
-}
-#app-header-text p {
-    margin: 4px 0 0;
-    font-size: .875rem;
-    color: rgba(255,255,255,.65);
-}
-
-#status-bar textarea {
-    background: #f0fdf4 !important;
-    border: 1.5px solid #86efac !important;
-    border-radius: 8px !important;
-    color: #166534 !important;
-    font-size: .82rem !important;
-    font-family: 'JetBrains Mono', monospace !important;
-    padding: 6px 12px !important;
-    min-height: 36px !important;
-}
-
-#sidebar {
-    background: #f8fafc;
-    border: 1px solid #e2e8f0;
-    border-radius: 12px;
-    padding: 16px;
-}
-
-#query-box textarea {
-    font-size: 1rem !important;
-    border: 2px solid #cbd5e1 !important;
-    border-radius: 10px !important;
-    padding: 12px !important;
-    transition: border-color .15s;
-}
-#query-box textarea:focus { border-color: #3b82f6 !important; }
-
-#result-table table { font-size: .83rem !important; }
-#result-table th {
-    background: #1e3a5f !important;
-    color: #fff !important;
-    font-weight: 600 !important;
-    position: sticky; top: 0;
-}
-#result-table tr:hover td { background: #eff6ff !important; }
-
-#sql-editor textarea {
-    font-family: 'JetBrains Mono', 'Fira Code', monospace !important;
-    font-size: .88rem !important;
-    background: #0f172a !important;
-    color: #e2e8f0 !important;
-    border-radius: 8px !important;
-    border: 1.5px solid #334155 !important;
-}
-
-#dl-log textarea {
-    background: #fffbeb !important;
-    border: 1.5px solid #fcd34d !important;
-    border-radius: 8px !important;
-    color: #78350f !important;
-    font-size: .82rem !important;
-    font-family: 'JetBrains Mono', monospace !important;
-}
-"""
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Device helpers
-# ─────────────────────────────────────────────────────────────────────────────
-
-def pick_device(user_device: Optional[str] = None) -> str:
-    if user_device and user_device != "auto":
-        return user_device
-    if torch.cuda.is_available():
-        return "cuda"
-    if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
-        return "mps"
-    return "cpu"
-
-
-def make_embedder(model_name: str, device: str) -> SentenceTransformer:
-    emb = SentenceTransformer(model_name, device=device)
-    if device == "cuda":
-        try:
-            emb = emb.half()
-        except Exception:
-            pass
-    return emb
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Safe encode — handles sentence-transformers API differences across versions
-# ─────────────────────────────────────────────────────────────────────────────
-
-_encode_sig_cache: Dict[int, set] = {}
-
-def _safe_encode(emb: SentenceTransformer, sentences: List[str], *,
-                 normalize_embeddings: bool = True, batch_size: int = 32):
-    key = id(emb)
-    if key not in _encode_sig_cache:
-        _encode_sig_cache[key] = set(inspect.signature(emb.encode).parameters)
-    accepted = _encode_sig_cache[key]
-    kw: Dict[str, Any] = {}
-    if "normalize_embeddings" in accepted: kw["normalize_embeddings"] = normalize_embeddings
-    if "show_progress_bar"    in accepted: kw["show_progress_bar"]    = False
-    if "batch_size"           in accepted: kw["batch_size"]           = batch_size
-    if "num_workers"          in accepted: kw["num_workers"]          = 0
-    return emb.encode(sentences, **kw)
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# HuggingFace download  (called only when user clicks Download & Load)
-# ─────────────────────────────────────────────────────────────────────────────
-
-def _hf_url(filename: str) -> str:
-    return (
-        f"https://huggingface.co/datasets/{HF_DATASET_REPO}"
-        f"/resolve/main/{filename}"
-    )
-
-
-def download_assets(force: bool = False,
-                    progress_cb=None) -> Tuple[bool, str]:
-    import urllib.request
-
-    def _log(msg: str):
-        if progress_cb:
-            progress_cb(msg)
-        print(msg)
-
-    db_path     = Path(DEFAULT_DB_PATH)
-    chroma_path = Path(DEFAULT_CHROMA)
-
-    # ── SQLite DB ──────────────────────────────────────────────────────────
-    if db_path.exists() and not force:
-        _log(f"SQLite DB already present: {db_path}")
-    else:
-        url = _hf_url(HF_DB_FILENAME)
-        _log(f"Downloading SQLite DB...\n  {url}")
-        db_path.parent.mkdir(parents=True, exist_ok=True)
-        tmp = db_path.with_suffix(".tmp")
-        try:
-            def _hook(count, block, total):
-                if total > 0:
-                    pct = min(count * block / total * 100, 100)
-                    _log(f"  SQLite: {pct:.1f}%  "
-                         f"({count*block/1e6:.1f} MB / {total/1e6:.1f} MB)")
-            urllib.request.urlretrieve(url, tmp, reporthook=_hook)
-            tmp.rename(db_path)
-            _log(f"SQLite DB saved -> {db_path}")
-        except Exception as e:
-            if tmp.exists():
-                tmp.unlink()
-            return False, f"Failed to download SQLite DB: {e}"
-
-    # ── Pre-built Chroma index (optional) ─────────────────────────────────
-    if chroma_path.exists() and not force:
-        _log(f"Chroma index already present: {chroma_path}")
-    else:
-        url     = _hf_url(HF_CHROMA_ARCHIVE)
-        archive = CACHE_DIR / HF_CHROMA_ARCHIVE
-        _log(f"Attempting to download pre-built Chroma index...\n  {url}")
-        try:
-            def _hook2(count, block, total):
-                if total > 0:
-                    pct = min(count * block / total * 100, 100)
-                    _log(f"  Chroma: {pct:.1f}%  "
-                         f"({count*block/1e6:.1f} MB / {total/1e6:.1f} MB)")
-            urllib.request.urlretrieve(url, archive, reporthook=_hook2)
-            _log("Extracting Chroma index...")
-            import tarfile
-            if chroma_path.exists():
-                shutil.rmtree(chroma_path)
-            with tarfile.open(archive) as tf:
-                tf.extractall(CACHE_DIR)
-            archive.unlink(missing_ok=True)
-            _log(f"Chroma index extracted -> {chroma_path}")
-        except Exception as e:
-            _log(
-                f"Pre-built index not available ({e}).\n"
-                "Use the Rebuild Index tab to build it from the DB."
-            )
-            if archive.exists():
-                archive.unlink(missing_ok=True)
-
-    return True, "Assets ready."
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Runtime singleton
-# ─────────────────────────────────────────────────────────────────────────────
-
-@dataclass
-class Runtime:
-    embedder:   SentenceTransformer
-    col:        Any
-    db_con:     sqlite3.Connection
-    device:     str
-    model:      str
-    collection: str
-
-
-_runtime:     Optional[Runtime] = None
-_runtime_err: Optional[str]     = None
-_loading:     bool              = False   # False until explicitly triggered
-_load_log:    List[str]         = []
-_runtime_lock = threading.Lock()
-_db_lock      = threading.Lock()
-
-
-def _log_startup(msg: str):
-    _load_log.append(msg)
-    print(msg)
-
-
-def _open_sqlite(path: str) -> sqlite3.Connection:
-    con = sqlite3.connect(path, check_same_thread=False)
-    for p in (
-        "PRAGMA journal_mode=WAL",
-        "PRAGMA synchronous=NORMAL",
-        "PRAGMA temp_store=MEMORY",
-        "PRAGMA cache_size=-65536",
-    ):
-        con.execute(p)
-    return con
-
-
-def _open_chroma(chroma_path: str, collection_name: str):
-    client = chromadb.PersistentClient(
-        path=chroma_path,
-        settings=Settings(anonymized_telemetry=False),
-    )
-    col = client.get_or_create_collection(
-        name=collection_name,
-        metadata={"hnsw:space": "cosine"},
-    )
-    return client, col
-
-
-def _do_load(db_path: str, chroma_path: str, collection: str,
-             model_name: str, device: str):
-    global _runtime, _runtime_err, _loading
-    try:
-        t0 = time.time()
-        # Auto-correct model if it doesn't match the stored index dimension
-        if os.path.exists(chroma_path):
-            model_name = resolve_model_for_index(chroma_path, collection, model_name)
-        _log_startup(f"Loading model: {model_name} on {device}")
-        embedder = make_embedder(model_name, device)
-        # Warm-up: force PyTorch kernel init in the same thread the encoder runs in
-        _log_startup("Warming up model (dummy encode)...")
-        future = _encode_executor.submit(
-            _safe_encode, embedder, ["warmup"],
-            normalize_embeddings=True, batch_size=1,
-        )
-        future.result(timeout=120)
-        _log_startup("Model warm-up done.")
-        _log_startup(f"Model ready ({time.time()-t0:.1f}s). Opening Chroma...")
-        _, col = _open_chroma(chroma_path, collection)
-        _log_startup("Chroma ready. Opening SQLite...")
-        con = _open_sqlite(db_path)
-        with _runtime_lock:
-            _runtime = Runtime(
-                embedder=embedder, col=col, db_con=con,
-                device=device, model=model_name, collection=collection,
-            )
-        _log_startup(
-            f"Ready in {time.time()-t0:.1f}s | "
-            f"model={model_name} | dim={detect_collection_dim(chroma_path, collection)}"
-        )
-    except Exception as e:
-        with _runtime_lock:
-            _runtime_err = f"{type(e).__name__}: {e}"
-        _log_startup(f"Load failed: {e}")
-    finally:
-        _loading = False
-
-
-def get_runtime() -> Tuple[Optional[Runtime], Optional[str]]:
-    if _loading:
-        return None, "Loading — please wait a moment and retry."
-    with _runtime_lock:
-        if _runtime_err:
-            return None, f"Error: {_runtime_err}"
-        if _runtime is None:
-            return None, (
-                "No data loaded. "
-                "Go to the Data & Setup tab to download assets."
-            )
-        return _runtime, None
-
-
-def reload_runtime(db_path: str, chroma_path: str, collection: str,
-                   model_name: str, device: str) -> str:
-    global _runtime, _runtime_err, _loading
-    _loading = True
-    with _runtime_lock:
-        if _runtime:
-            try:
-                _runtime.db_con.close()
-            except Exception:
-                pass
-        _runtime     = None
-        _runtime_err = None
-        _load_log.clear()
-
-    threading.Thread(
-        target=_do_load,
-        args=(db_path, chroma_path, collection, model_name, device),
-        daemon=True,
-    ).start()
-
-    for _ in range(80):          # wait up to 20 s for fast reloads
-        time.sleep(0.25)
-        if not _loading:
-            break
-
-    rt, err = get_runtime()
-    if err:
-        return err
-    return (
-        f"Ready | model={rt.model} | "
-        f"device={rt.device} | collection={rt.collection}"
-    )
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Dimension → model mapping
-# ─────────────────────────────────────────────────────────────────────────────
-
-# Maps known embedding dimensions to a default model that produces them.
-# Used to auto-select the right model when the Chroma index already exists.
-_DIM_TO_MODEL: Dict[int, str] = {
-    384:  "BAAI/bge-small-en-v1.5",
-    768:  "BAAI/bge-base-en-v1.5",
-    1024: "BAAI/bge-large-en-v1.5",
-}
-
-
-def detect_collection_dim(chroma_path: str, collection_name: str) -> Optional[int]:
-    """
-    Open the existing Chroma collection and return the embedding dimension
-    by peeking at the first stored vector. Returns None if the collection is
-    empty or unreadable.
-    """
-    try:
-        client = chromadb.PersistentClient(
-            path=chroma_path,
-            settings=Settings(anonymized_telemetry=False),
-        )
-        col  = client.get_collection(name=collection_name)
-        peek = col.peek(limit=1)
-        embs = peek.get("embeddings")
-        if embs and len(embs) > 0 and len(embs[0]) > 0:
-            return len(embs[0])
-    except Exception:
-        pass
-    return None
-
-
-def resolve_model_for_index(chroma_path: str, collection_name: str,
-                             requested_model: str) -> str:
-    """
-    If the Chroma index exists and its dimension does not match the requested
-    model, return the best-matching model for the stored dimension instead and
-    log a warning. Otherwise return the requested model unchanged.
-    """
-    dim = detect_collection_dim(chroma_path, collection_name)
-    if dim is None:
-        return requested_model          # empty or new index — use what was asked
-
-    # Check what dimension the requested model would produce
-    probe_map = {v: k for k, v in _DIM_TO_MODEL.items()}
-    requested_dim = probe_map.get(requested_model)
-
-    if requested_dim is not None and requested_dim != dim:
-        fallback = _DIM_TO_MODEL.get(dim, requested_model)
-        print(
-            f"[dim-check] Index has dim={dim}, but '{requested_model}' "
-            f"produces dim={requested_dim}. "
-            f"Auto-switching to '{fallback}'."
-        )
-        return fallback
-
-    # Unknown model — do a quick encode to verify dimension
-    if requested_dim is None:
-        try:
-            import numpy as np
-            tmp_emb = SentenceTransformer(requested_model)
-            test_vec = tmp_emb.encode(["test"], normalize_embeddings=True)
-            actual_dim = int(test_vec.shape[1])
-            del tmp_emb
-            if actual_dim != dim:
-                fallback = _DIM_TO_MODEL.get(dim, requested_model)
-                print(
-                    f"[dim-check] Index has dim={dim}, model produces "
-                    f"dim={actual_dim}. Auto-switching to '{fallback}'."
-                )
-                return fallback
-        except Exception:
-            pass
-
-    return requested_model
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Startup — check local files only, never download automatically
-# ─────────────────────────────────────────────────────────────────────────────
-
-def _startup():
-    global _loading, _runtime_err
-    db_ok     = os.path.exists(DEFAULT_DB_PATH)
-    chroma_ok = os.path.exists(DEFAULT_CHROMA)
-
-    if db_ok and chroma_ok:
-        _loading = True
-        _do_load(
-            DEFAULT_DB_PATH, DEFAULT_CHROMA, DEFAULT_COLLECTION,
-            DEFAULT_MODEL, pick_device(),
-        )
-    elif not db_ok:
-        _runtime_err = (
-            f"SQLite DB not found at '{DEFAULT_DB_PATH}'. "
-            "Use the Data & Setup tab to download assets."
-        )
-    else:
-        _runtime_err = (
-            f"Chroma index not found at '{DEFAULT_CHROMA}'. "
-            "Use the Data & Setup tab to download it, "
-            "or use the Rebuild Index tab to build from the existing DB."
-        )
-
-
-threading.Thread(target=_startup, daemon=True).start()
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# SQLite helpers
-# ─────────────────────────────────────────────────────────────────────────────
-
-def fetch_synonyms(con: sqlite3.Connection, sqlite_id: int) -> List[str]:
-    return [r[0] for r in con.execute(
-        "SELECT synonym FROM synonyms WHERE class_id=? ORDER BY synonym",
-        (sqlite_id,),
-    ).fetchall()]
-
-
-def concept_details(con: sqlite3.Connection, class_uri: str) -> Optional[Dict[str, Any]]:
-    row = con.execute(
-        "SELECT id, ontology_id, preferred_label, definition, notation, obsolete "
-        "FROM classes WHERE class_uri=?", (class_uri,),
-    ).fetchone()
-    if not row:
-        return None
-    cid     = int(row[0])
-    syns    = con.execute(
-        "SELECT synonym, syn_type FROM synonyms "
-        "WHERE class_id=? ORDER BY synonym", (cid,)
-    ).fetchall()
-    parents = con.execute(
-        "SELECT parent_uri FROM parents "
-        "WHERE class_id=? ORDER BY parent_uri", (cid,)
-    ).fetchall()
-    return {
-        "sqlite_id":  cid,
-        "ontology":   row[1],
-        "label":      row[2],
-        "definition": row[3],
-        "notation":   row[4],
-        "obsolete":   bool(row[5]),
-        "synonyms":   [{"term": s[0], "type": s[1]} for s in syns],
-        "parents":    [p[0] for p in parents],
-    }
-
-
-def iter_classes_for_rebuild(con: sqlite3.Connection):
-    cur = con.execute(
-        "SELECT id, ontology_id, class_uri, "
-        "COALESCE(preferred_label,''), "
-        "COALESCE(notation,''), "
-        "COALESCE(obsolete,0) FROM classes"
-    )
-    for row in cur:
-        yield int(row[0]), row[1], row[2], row[3], row[4], int(row[5])
-
-
-def fetch_definition(con: sqlite3.Connection, sqlite_id: int) -> str:
-    row = con.execute(
-        "SELECT definition FROM classes WHERE id=?", (sqlite_id,)
-    ).fetchone()
-    return (row[0] or "").strip() if row else ""
-
-
-def build_embed_text(con: sqlite3.Connection, sqlite_id: int, label: str) -> str:
-    """
-    Embedding document structure:
-        LABEL: <preferred_label>
-        SYNONYMS: <syn1> | <syn2> | ...
-        DEFINITION: <full definition text>
-
-    All three sections are included when available so the vector captures
-    the concept name, all surface forms, and the semantic definition.
-    """
-    label = (label or "").strip()
-    syns  = [s.strip() for s in fetch_synonyms(con, sqlite_id) if (s or "").strip()]
-    defn  = fetch_definition(con, sqlite_id)
-
-    parts: List[str] = []
-
-    if label:
-        parts.append(f"LABEL: {label}")
-
-    if syns:
-        parts.append("SYNONYMS: " + " | ".join(syns[:64]))
-
-    if defn:
-        parts.append(f"DEFINITION: {defn}")
-
-    return "\n".join(parts) or f"sqlite_id={sqlite_id}"
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Query embedding cache  (avoids re-encoding identical queries)
-# ─────────────────────────────────────────────────────────────────────────────
-
-import concurrent.futures
-from functools import lru_cache
-_encode_executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
-
-@lru_cache(maxsize=256)
-def _cached_query_vec(model_id: int, query: str) -> tuple:
-    """
-    Encode a query string and return the embedding as a tuple (hashable).
-    Keyed on model object id so cache is invalidated on model reload.
-    """
-    rt, _ = get_runtime()
-    if rt is None:
-        return ()
-    vec = _safe_encode(
-        rt.embedder, [QUERY_PREFIX + query],
-        normalize_embeddings=True, batch_size=1,
-    )
-    return tuple(vec[0].tolist())
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Semantic search
-# ─────────────────────────────────────────────────────────────────────────────
-
-def semantic_search(
-    query: str, *, rt: Runtime,
-    n_results: int, ontology: Optional[str],
-    include_obsolete: bool, min_score: Optional[float],
-    details: bool,
-) -> List[Dict[str, Any]]:
-    # Use cached embedding if same query was seen before
-    cached = _cached_query_vec(id(rt.embedder), query)
-    if cached:
-        vec = [list(cached)]
-    else:
-        vec = _safe_encode(
-            rt.embedder, [QUERY_PREFIX + query],
-            normalize_embeddings=True, batch_size=1,
-        ).tolist()
-
-    where: Dict[str, Any] = {}
-    if ontology:
-        where["ontology_id"] = ontology
-    if not include_obsolete:
-        where["obsolete"] = "0"
-
-    kw: Dict[str, Any] = {
-        "query_embeddings": vec,
-        "n_results": int(n_results),
-    }
-    if where:
-        kw["where"] = where
-
-    res       = rt.col.query(**kw)
-    ids       = res.get("ids",       [[]])[0]
-    metadatas = res.get("metadatas", [[]])[0]
-    distances = res.get("distances", [[]])[0]
-
-    out: List[Dict[str, Any]] = []
-    with _db_lock:
-        for i in range(len(ids)):
-            meta      = metadatas[i] or {}
-            score     = round(1.0 - float(distances[i]), 4)
-            if min_score is not None and score < min_score:
-                continue
-            sqlite_id = int(meta.get("sqlite_id") or 0)
-            class_uri = meta.get("class_uri", "")
-            item: Dict[str, Any] = {
-                "score":     score,
-                "ontology":  meta.get("ontology_id",     ""),
-                "label":     meta.get("preferred_label", ""),
-                "notation":  meta.get("notation",        ""),
-                "uri":       class_uri,
-                "sqlite_id": sqlite_id,
-                "obsolete":  meta.get("obsolete",        ""),
-                "synonyms":  fetch_synonyms(rt.db_con, sqlite_id) if sqlite_id else [],
-            }
-            if details and class_uri:
-                item["details"] = concept_details(rt.db_con, class_uri)
-            out.append(item)
-    return out
-
-
-def results_to_df(results: List[Dict[str, Any]]) -> pd.DataFrame:
-    return pd.DataFrame([{
-        "score":     r["score"],
-        "label":     r["label"],
-        "ontology":  r["ontology"],
-        "notation":  r["notation"],
-        "obsolete":  r["obsolete"],
-        "synonyms":  ", ".join((r.get("synonyms") or [])[:5]),
-        "uri":       r["uri"],
-        "sqlite_id": r["sqlite_id"],
-    } for r in results])
-
-
-def results_to_md(results: List[Dict[str, Any]], show_details: bool) -> str:
-    if not results:
-        return "*No results found.*"
-    lines: List[str] = []
-    for idx, r in enumerate(results, 1):
-        bar = "█" * int(r["score"] * 10) + "░" * (10 - int(r["score"] * 10))
-        lines.append(
-            f"### {idx}. {r.get('label','')}  "
-            f"`{r.get('score')}`  `{bar}`"
-        )
-        lines.append("| Field | Value |")
-        lines.append("|---|---|")
-        lines.append(f"| **Ontology** | {r.get('ontology','')} |")
-        if r.get("notation"):
-            lines.append(f"| **Notation** | {r['notation']} |")
-        lines.append(f"| **URI** | `{r.get('uri','')}` |")
-        lines.append(f"| **Obsolete** | {r.get('obsolete','')} |")
-        syns = r.get("synonyms") or []
-        if syns:
-            head = ", ".join(syns[:15])
-            tail = f" *...+{len(syns)-15} more*" if len(syns) > 15 else ""
-            lines.append(f"| **Synonyms** | {head}{tail} |")
-        if show_details and r.get("details"):
-            d = r["details"]
-            if d.get("definition"):
-                lines += ["", "> **Definition**", f"> {d['definition']}"]
-            if d.get("parents"):
-                ps   = d["parents"][:20]
-                tail = (f"\n*...+{len(d['parents'])-20} more*"
-                        if len(d["parents"]) > 20 else "")
-                lines += [
-                    "", "**Parents**",
-                    "\n".join(f"- `{p}`" for p in ps) + tail,
-                ]
-        lines.append("")
-    return "\n".join(lines)
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# SQL console
-# ─────────────────────────────────────────────────────────────────────────────
-
-_SELECT_RE = re.compile(r"^\s*(with\s+[\s\S]+?\s+)?select\b", re.IGNORECASE)
-_FORBID_RE = re.compile(
-    r"\b(attach|detach|pragma|vacuum|reindex|drop|alter"
-    r"|create|replace|truncate)\b",
-    re.IGNORECASE,
-)
-
-
-def run_sql(sql: str, con: sqlite3.Connection, *,
-            select_only: bool = True,
-            max_rows: int = 1000) -> Tuple[pd.DataFrame, str]:
-    sql = (sql or "").strip().rstrip(";")
-    if not sql:
-        return pd.DataFrame(), "Enter a SQL query."
-    if select_only:
-        if not _SELECT_RE.match(sql):
-            return pd.DataFrame(), "Blocked: only SELECT (or WITH ... SELECT) is allowed."
-        if _FORBID_RE.search(sql):
-            return pd.DataFrame(), "Blocked: query contains forbidden keywords."
-        if max_rows > 0 and not re.search(r"\blimit\b", sql, re.IGNORECASE):
-            sql = f"{sql} LIMIT {int(max_rows)}"
-    with _db_lock:
-        cur  = con.execute(sql)
-        cols = [d[0] for d in (cur.description or [])]
-        rows = cur.fetchall()
-    if not cols:
-        return pd.DataFrame(), f"OK — rows affected: {cur.rowcount}"
-    return pd.DataFrame(rows, columns=cols), f"OK — {len(rows)} rows returned."
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Rebuild
-# ─────────────────────────────────────────────────────────────────────────────
-
-def rebuild_chroma(*, db_path: str, chroma_path: str,
-                   collection_name: str,
-                   embedder: SentenceTransformer,
-                   batch_size: int = 256,
-                   progress=None) -> Tuple[str, int]:
-    if not os.path.exists(db_path):
-        return f"SQLite DB not found: {db_path}", 0
-
-    if os.path.exists(chroma_path):
-        shutil.rmtree(chroma_path)
-    os.makedirs(chroma_path, exist_ok=True)
-
-    client = chromadb.PersistentClient(
-        path=chroma_path,
-        settings=Settings(anonymized_telemetry=False),
-    )
-    col = client.get_or_create_collection(
-        name=collection_name,
-        metadata={"hnsw:space": "cosine"},
-    )
-    con   = sqlite3.connect(db_path)
-    total = 0
-    tick  = 0
-    ids:   List[str]            = []
-    docs:  List[str]            = []
-    metas: List[Dict[str, Any]] = []
-
-    def _flush():
-        nonlocal total, tick
-        emb = _safe_encode(
-            embedder, docs,
-            normalize_embeddings=True,
-            batch_size=min(64, batch_size),
-        ).tolist()
-        col.upsert(ids=ids, documents=docs, metadatas=metas, embeddings=emb)
-        total += len(ids)
-        ids.clear(); docs.clear(); metas.clear()
-        if progress is not None:
-            tick = (tick + 1) % 200
-            progress(tick / 200.0, desc=f"Indexed {total:,} vectors...")
-
-    for sid, oid, uri, label, notation, obsolete in iter_classes_for_rebuild(con):
-        ids.append(f"{oid}::{sid}")
-        docs.append(build_embed_text(con, sid, label))
-        metas.append({
-            "ontology_id":     oid,
-            "class_uri":       uri,
-            "preferred_label": label    or "",
-            "notation":        notation or "",
-            "obsolete":        str(int(obsolete)),
-            "sqlite_id":       str(sid),
-        })
-        if len(ids) >= batch_size:
-            _flush()
-
-    if ids:
-        _flush()
-    if progress is not None:
-        progress(1.0, desc=f"Done — {total:,} vectors.")
-    con.close()
-    return "Rebuild complete.", total
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# UI callbacks
-# ─────────────────────────────────────────────────────────────────────────────
-
-def ui_status_poll() -> str:
-    if _loading:
-        steps = [
-            "[ ] Detecting device...",
-            "[ ] Loading embedding model (this may take a minute)...",
-            "[ ] Opening Chroma vector index...",
-            "[ ] Opening SQLite database...",
-        ]
-        # Show how many steps are done based on log content
-        done = 0
-        log_text = " ".join(_load_log).lower()
-        if "loading model"  in log_text: done = 1
-        if "model warm-up done" in log_text: done = 2
-        if "chroma ready"      in log_text: done = 3
-
-        lines = []
-        for i, step in enumerate(steps):
-            if i < done:
-                lines.append(step.replace("[ ]", "[x]"))
-            elif i == done:
-                lines.append(step.replace("[ ]", "-->"))
-            else:
-                lines.append(step)
-
-        last = _load_log[-1] if _load_log else "Starting..."
-        lines.append(f"\nLast update: {last}")
-        return "\n".join(lines)
-
-    rt, err = get_runtime()
-    if err:
-        return f"Not ready: {err}"
-    return (
-        f"Ready  |  model={rt.model}  |  "
-        f"device={rt.device}  |  collection={rt.collection}  |  "
-        f"dim={detect_collection_dim(DEFAULT_CHROMA, DEFAULT_COLLECTION)}"
-    )
-
-
-def ui_download_and_reload(force: bool, device_choice: str,
-                            model_name: str):
-    log: List[str] = []
-    ok, msg = download_assets(force=force, progress_cb=log.append)
-    log.append(msg)
-    if not ok:
-        joined = "\n".join(log)
-        return joined, joined
-    log.append("Loading runtime...")
-    status = reload_runtime(
-        DEFAULT_DB_PATH, DEFAULT_CHROMA, DEFAULT_COLLECTION,
-        model_name.strip(), pick_device(device_choice),
-    )
-    log.append(status)
-    return "\n".join(log), status
-
-
-def ui_warm_load(db_path, chroma_path, collection,
-                 model_name, device_choice) -> str:
-    db_path     = db_path.strip()
-    chroma_path = chroma_path.strip()
-    collection  = collection.strip()
-    model_name  = model_name.strip()
-    if not os.path.exists(db_path):
-        return f"SQLite DB not found: {db_path}"
-    if not os.path.exists(chroma_path):
-        return f"Chroma path not found: {chroma_path}"
-    return reload_runtime(
-        db_path, chroma_path, collection,
-        model_name, pick_device(device_choice),
-    )
-
-
-def ui_search(query, n_results, ontology, include_obsolete,
-              use_min_score, min_score, details):
-    t0    = time.time()
-    query = (query or "").strip()
-    if not query:
-        return pd.DataFrame(), "Enter a query.", ""
-    rt, err = get_runtime()
-    if err:
-        return pd.DataFrame(), err, ""
-    try:
-        results = semantic_search(
-            query, rt=rt,
-            n_results        = int(n_results),
-            ontology         = ontology.strip() or None,
-            include_obsolete = include_obsolete,
-            min_score        = (min_score if use_min_score else None),
-            details          = details,
-        )
-        dt = (time.time() - t0) * 1000
-        return (
-            results_to_df(results),
-            f"{len(results)} results | {dt:.0f} ms | device={rt.device}",
-            results_to_md(results, details),
-        )
-    except InternalError as e:
-        corrupted = any(p in str(e).lower()
-                        for p in ["eof", "pickle", "hnsw"])
-        msg = (
-            "Chroma index appears corrupted. Use the Rebuild tab."
-            if corrupted else f"Chroma error: {e}"
-        )
-        return pd.DataFrame(), msg, ""
-    except Exception as e:
-        return pd.DataFrame(), f"{type(e).__name__}: {e}", ""
-
-
-def ui_sql(sql, select_only, max_rows):
-    rt, err = get_runtime()
-    if err:
-        return pd.DataFrame(), err
-    try:
-        return run_sql(
-            sql, rt.db_con,
-            select_only=select_only,
-            max_rows=int(max_rows),
-        )
-    except Exception as e:
-        return pd.DataFrame(), f"{type(e).__name__}: {e}"
-
-
-def ui_rebuild(db_path, chroma_path, collection, model_name,
-               device_choice, batch_size, progress=gr.Progress()):
-    rt, err = get_runtime()
-    if err:
-        return err, 0
-    db_path     = db_path.strip()
-    chroma_path = chroma_path.strip()
-    collection  = collection.strip()
-    if not os.path.exists(db_path):
-        return f"SQLite DB not found: {db_path}", 0
-    try:
-        status, total = rebuild_chroma(
-            db_path=db_path, chroma_path=chroma_path,
-            collection_name=collection, embedder=rt.embedder,
-            batch_size=int(batch_size), progress=progress,
-        )
-        reload_runtime(
-            db_path, chroma_path, collection,
-            model_name.strip(), pick_device(device_choice),
-        )
-        return f"{status} ({total:,} vectors)", total
-    except Exception as e:
-        return f"{type(e).__name__}: {e}", 0
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Build theme (outside Blocks — works for all Gradio versions)
-# ─────────────────────────────────────────────────────────────────────────────
-
-try:
-    _theme = gr.themes.Base(
-        primary_hue=gr.themes.colors.blue,
-        secondary_hue=gr.themes.colors.slate,
-        neutral_hue=gr.themes.colors.slate,
-        font=[gr.themes.GoogleFont("Inter"), "system-ui", "sans-serif"],
-        font_mono=[gr.themes.GoogleFont("JetBrains Mono"), "monospace"],
-    )
-except Exception:
-    _theme = "default"
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Gradio UI
-# ─────────────────────────────────────────────────────────────────────────────
-
-with gr.Blocks(title="Ontology Semantic Search") as demo:
-
-    # ── Header ────────────────────────────────────────────────────────────
-    gr.HTML(f"""
-    <div id="app-header">
-        <img src="{LOGO_URL}" alt="Sensein logo" />
-        <div id="app-header-text">
-            <h1>Ontology Semantic Search</h1>
-            <p>Semantic search over ontologies &mdash;
-               ChromaDB &middot; SentenceTransformers &middot; SQLite</p>
-        </div>
-    </div>
-    """)
-
-    runtime_status = gr.Textbox(
-        label="Runtime Status",
-        value="Checking local assets...",
-        interactive=False,
-        elem_id="status-bar",
-    )
-
-    with gr.Tabs():
-
-        # ── Search ────────────────────────────────────────────────────────
-        with gr.Tab("Search"):
-            with gr.Row(equal_height=False):
-                with gr.Column(scale=1, min_width=260, elem_id="sidebar"):
-                    gr.Markdown("#### Filters")
-                    c_n       = gr.Slider(label="Top-K results", minimum=1,
-                                          maximum=100, value=20, step=1)
-                    c_onto    = gr.Textbox(label="Ontology filter",
-                                           placeholder="e.g. NCIT, HP, GO",
-                                           value="")
-                    c_obs     = gr.Checkbox(label="Include obsolete terms",
-                                            value=False)
-                    c_usemsco = gr.Checkbox(label="Enable min-score filter",
-                                            value=False)
-                    c_mscore  = gr.Slider(label="Min score", minimum=0.0,
-                                          maximum=1.0, value=0.5, step=0.01)
-                    c_detail  = gr.Checkbox(label="Show definitions & parents",
-                                            value=False)
-
-                with gr.Column(scale=4):
-                    c_query = gr.Textbox(
-                        label="Search query",
-                        placeholder=(
-                            "e.g.  lung cancer  "
-                            "·  astrocyte  "
-                            "·  myocardial infarction"
-                        ),
-                        lines=2,
-                        elem_id="query-box",
-                    )
-                    with gr.Row():
-                        btn_search = gr.Button("Search", variant="primary", scale=3)
-                        btn_clear  = gr.Button("Clear", scale=1)
-
-                    search_status = gr.Textbox(
-                        label="", value="", interactive=False,
-                        show_label=False, elem_id="status-bar",
-                    )
-                    search_table = gr.Dataframe(
-                        label="Results", interactive=False,
-                        wrap=True, row_count=(0, "dynamic"),
-                        elem_id="result-table",
-                    )
-                    search_md = gr.Markdown(value="")
-
-        # ── SQL Console ───────────────────────────────────────────────────
-        with gr.Tab("SQL Console"):
-            gr.Markdown(
-                "Query the SQLite database directly. "
-                "**SELECT-only** mode is enabled by default."
-            )
-            with gr.Row():
-                with gr.Column(scale=3):
-                    c_sql = gr.Textbox(
-                        label="SQL Query",
-                        value=(
-                            "SELECT ontology_id, COUNT(*) AS n\n"
-                            "FROM classes\n"
-                            "GROUP BY ontology_id\n"
-                            "ORDER BY n DESC\n"
-                            "LIMIT 20;"
-                        ),
-                        lines=8,
-                        elem_id="sql-editor",
-                    )
-                    with gr.Row():
-                        sql_run       = gr.Button("Execute", variant="primary")
-                        c_select_only = gr.Checkbox(
-                            label="SELECT-only (recommended)", value=True
-                        )
-                        c_max_rows    = gr.Slider(
-                            label="Row limit", minimum=10,
-                            maximum=10000, value=1000, step=10,
-                        )
-                with gr.Column(scale=1, elem_id="sidebar"):
-                    gr.Markdown("#### Example queries")
-                    gr.Markdown("""
-```sql
--- Count per ontology
-SELECT ontology_id, COUNT(*) n
-FROM classes
-GROUP BY ontology_id
-ORDER BY n DESC;
-
--- Label search
-SELECT * FROM classes
-WHERE preferred_label LIKE '%cancer%'
-LIMIT 50;
-
--- List tables
-SELECT name FROM sqlite_master
-WHERE type='table';
-```
-""")
-            sql_status = gr.Textbox(label="Status", value="", interactive=False)
-            sql_table  = gr.Dataframe(
-                label="Results", interactive=False,
-                wrap=True, row_count=(0, "dynamic"),
-            )
-
-        # ── Data & Setup ──────────────────────────────────────────────────
-        with gr.Tab("Data & Setup"):
-            with gr.Row():
-                with gr.Column(scale=2):
-                    gr.Markdown(f"""
-### Download from HuggingFace
-Dataset: [`{HF_DATASET_REPO}`](https://huggingface.co/datasets/{HF_DATASET_REPO})
-
-Downloads:
-- **`{HF_DB_FILENAME}`** — SQLite ontology database
-- **`{HF_CHROMA_ARCHIVE}`** — pre-built vector index *(if available)*
-
-Assets are saved to **`{CACHE_DIR}/`** and skipped silently if already present.
-If the pre-built index is unavailable, use the **Rebuild Index** tab after downloading the DB.
-""")
-                    c_force    = gr.Checkbox(
-                        label="Force re-download (overwrite existing files)",
-                        value=False,
-                    )
-                    c_dl_model = gr.Dropdown(label="Embedding model",
-                                             choices=MODEL_CHOICES,
-                                             value=DEFAULT_MODEL)
-                    c_dl_dev   = gr.Dropdown(
-                        label="Device",
-                        choices=["auto", "cpu", "cuda", "mps"],
-                        value="auto",
-                    )
-                    btn_dl = gr.Button("Download & Load", variant="primary")
-                    dl_log = gr.Textbox(
-                        label="Download log", value="", lines=14,
-                        interactive=False, elem_id="dl-log",
-                    )
-                with gr.Column(scale=1, elem_id="sidebar"):
-                    gr.Markdown("#### Asset paths")
-                    gr.Markdown(f"""
-| Asset | Path |
-|---|---|
-| SQLite DB | `{DEFAULT_DB_PATH}` |
-| Chroma index | `{DEFAULT_CHROMA}` |
-| Collection | `{DEFAULT_COLLECTION}` |
-| Model | `{DEFAULT_MODEL}` |
-""")
-                    gr.Markdown("#### Env overrides")
-                    gr.Markdown("""
-```bash
-ONTOLOGY_CACHE_DIR=./cache
-ONTOLOGY_DB_NAME=bioportal.db
-ONTOLOGY_CHROMA_NAME=bioportal_chroma
-ONTOLOGY_COLLECTION=ontology_classes
-ONTOLOGY_EMBED_MODEL=BAAI/bge-small-en-v1.5
-```
-""")
-
-        # ── Rebuild Index ─────────────────────────────────────────────────
-        with gr.Tab("Rebuild Index"):
-            gr.Markdown(
-                "Re-embed all classes from SQLite into a fresh Chroma index. "
-                "Use this if the pre-built index was unavailable or is corrupted."
-            )
-            with gr.Row():
-                with gr.Column(scale=2):
-                    with gr.Row():
-                        c_rb_db     = gr.Textbox(label="SQLite DB path",
-                                                  value=DEFAULT_DB_PATH)
-                        c_rb_chroma = gr.Textbox(label="Chroma path",
-                                                  value=DEFAULT_CHROMA)
-                    with gr.Row():
-                        c_rb_col   = gr.Textbox(label="Collection",
-                                                 value=DEFAULT_COLLECTION)
-                        c_rb_model = gr.Dropdown(label="Embedding model",
-                                                  choices=MODEL_CHOICES,
-                                                  value=DEFAULT_MODEL)
-                        c_rb_dev   = gr.Dropdown(
-                            label="Device",
-                            choices=["auto", "cpu", "cuda", "mps"],
-                            value="auto",
-                        )
-                    c_rb_batch  = gr.Slider(label="Batch size", minimum=32,
-                                             maximum=2048, value=256, step=32)
-                    btn_rebuild = gr.Button("Start Rebuild", variant="stop")
-                with gr.Column(scale=1, elem_id="sidebar"):
-                    gr.Markdown("#### Notes")
-                    gr.Markdown("""
-- Rebuilding **deletes** the existing Chroma directory first.
-- Duration depends on DB size and hardware.
-- The runtime is hot-reloaded automatically after rebuild.
-- Use `bge-small` for fastest rebuilds; `bge-large` for highest quality.
-""")
-            rebuild_status = gr.Textbox(label="Status", value="",
-                                         interactive=False)
-            rebuild_total  = gr.Number(label="Vectors indexed", value=0,
-                                        precision=0, interactive=False)
-
-        # ── Advanced Config ───────────────────────────────────────────────
-        with gr.Tab("Advanced Config"):
-            gr.Markdown(
-                "Change paths, model, or device at runtime and reload "
-                "without restarting the server."
-            )
-            with gr.Row():
-                with gr.Column():
-                    adv_db     = gr.Textbox(label="SQLite DB path",
-                                             value=DEFAULT_DB_PATH)
-                    adv_chroma = gr.Textbox(label="Chroma path",
-                                             value=DEFAULT_CHROMA)
-                    adv_col    = gr.Textbox(label="Collection name",
-                                             value=DEFAULT_COLLECTION)
-                    adv_model  = gr.Dropdown(label="Embedding model",
-                                             choices=MODEL_CHOICES,
-                                             value=DEFAULT_MODEL)
-                    adv_device = gr.Dropdown(
-                        label="Device",
-                        choices=["auto", "cpu", "cuda", "mps"],
-                        value="auto",
-                    )
-                    adv_btn    = gr.Button("Apply & Reload Runtime",
-                                           variant="primary")
-                    adv_status = gr.Textbox(label="Status", value="",
-                                             interactive=False)
-                with gr.Column(elem_id="sidebar"):
-                    gr.Markdown("#### Model options")
-                    gr.Markdown("""
-| Model | Size | Speed | Quality |
-|---|---|---|---|
-| `bge-small-en-v1.5` | 130 MB | Fast | Good |
-| `bge-base-en-v1.5`  | 440 MB | Med  | Better |
-| `bge-large-en-v1.5` | 1.3 GB | Slow | Best |
-| `all-MiniLM-L6-v2`  | 90 MB  | Fastest | Fair |
-""")
-
-    # ── Event wiring ──────────────────────────────────────────────────────
-    btn_search.click(
-        fn=ui_search,
-        inputs=[c_query, c_n, c_onto, c_obs, c_usemsco, c_mscore, c_detail],
-        outputs=[search_table, search_status, search_md],
-    )
-    c_query.submit(
-        fn=ui_search,
-        inputs=[c_query, c_n, c_onto, c_obs, c_usemsco, c_mscore, c_detail],
-        outputs=[search_table, search_status, search_md],
-    )
-
-    def _clear():
-        return "", pd.DataFrame(), "", ""
-
-    btn_clear.click(
-        fn=_clear, inputs=[],
-        outputs=[c_query, search_table, search_status, search_md],
-    )
-
-    sql_run.click(
-        fn=ui_sql,
-        inputs=[c_sql, c_select_only, c_max_rows],
-        outputs=[sql_table, sql_status],
-    )
-
-    btn_dl.click(
-        fn=ui_download_and_reload,
-        inputs=[c_force, c_dl_dev, c_dl_model],
-        outputs=[dl_log, runtime_status],
-    )
-
-    btn_rebuild.click(
-        fn=ui_rebuild,
-        inputs=[c_rb_db, c_rb_chroma, c_rb_col,
-                c_rb_model, c_rb_dev, c_rb_batch],
-        outputs=[rebuild_status, rebuild_total],
-    ).then(fn=ui_status_poll, inputs=[], outputs=[runtime_status])
-
-    adv_btn.click(
-        fn=ui_warm_load,
-        inputs=[adv_db, adv_chroma, adv_col, adv_model, adv_device],
-        outputs=[adv_status],
-    ).then(fn=ui_status_poll, inputs=[], outputs=[runtime_status])
-
-    # Refresh status on page load
-    demo.load(fn=ui_status_poll, inputs=[], outputs=[runtime_status])
-
-    # Auto-poll every 2 s while the background thread is still loading.
-    # gr.Timer is available in Gradio 4.x+; fall back gracefully if not.
-    try:
-        _timer = gr.Timer(value=2)
-        _timer.tick(fn=ui_status_poll, inputs=[], outputs=[runtime_status])
-    except AttributeError:
-        pass  # older Gradio — user can click Reload in Advanced Config
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Launch
-# ─────────────────────────────────────────────────────────────────────────────
-
-if __name__ == "__main__":
-    launch_kwargs: Dict[str, Any] = {
-        "server_name": "0.0.0.0",
-        "server_port": int(os.getenv("PORT", 7860)),
-    }
-
-    # Gradio 6+ moved theme/css to launch(); older versions take them in Blocks.
-    # Detect which style this install supports.
-    import inspect as _inspect
-    _launch_sig = set(_inspect.signature(demo.launch).parameters)
-    if "theme" in _launch_sig:
-        launch_kwargs["theme"] = _theme
-        launch_kwargs["css"]   = CUSTOM_CSS
-    # show_api removed in Gradio 6
-    if "show_api" in _launch_sig:
-        launch_kwargs["show_api"] = False
-
-    demo.queue().launch(**launch_kwargs)