perf: shared cached model + background preload at home page

The parsing demo called spacy.load() directly on every rerun (the
@st .cache_resource loader beside it was dead code), so it reloaded the
~500MB lg model on every interaction — the main cause of its slowness.
The custom-label demo had the same uncached-load-per-rerun pattern.

Changes:
- Add model_helpers.py: one @st .cache_resource load_model() shared by all
read-only demos, so they reuse a single in-memory model instead of each
page caching its own copy. start_preload() warms the default lg model in
a daemon thread from app.py, so the model loads while the visitor reads
the home page and the first demo opened finds it already resident.
- Parsing/senter/NER/dependency demos now use the shared loader; drop their
per-page loaders and now-unused imports (spacy, gc, subprocess, json,
registry, and the dead load_model_in_subprocess helper).
- Custom-label demo keeps its OWN cached instance (it mutates the pipeline
via add_pipe("dcc_core")); sharing would leak that pipe into other demos.
Its load is now cached with an idempotent add_pipe guard.

Smoke-tested: shared loader returns a single instance, preload is
non-blocking, trf_vectors disabled, parse works.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

app.py

@@ -1,10 +1,17 @@
 import streamlit as st
 
+from model_helpers import start_preload
+
 st.set_page_config(
     page_title="LatinCy Dashboard | Home",
     page_icon="🏠",
 )
 
+# Warm the default lg model in a background thread while the visitor reads this
+# page, so the first demo they open finds it already loaded. Non-blocking and
+# idempotent — safe to call on every render.
+start_preload()
+
 st.write("# LatinCy Dashboard")
 
 st.sidebar.success("Select a demo above.")

model_helpers.py

@@ -0,0 +1,63 @@
+"""Shared spaCy model loading + background preload for the dashboard.
+
+Read-only demos import ``load_model()`` from here so they all share ONE model
+instance per name across the whole process, instead of each page caching its
+own copy (which multiplied a ~500 MB model across pages in RAM).
+``start_preload()`` warms the default model in a background thread from the
+home page, so navigating into a demo finds the model already resident.
+
+Demos that MUTATE their pipeline (e.g. the custom-label demo, which adds a
+component with ``add_pipe``) must NOT use this shared instance — they should
+cache their own copy — because mutating the shared model would leak the change
+into every other demo.
+"""
+
+import threading
+
+import spacy
+import streamlit as st
+
+DEFAULT_MODEL = "la_core_web_lg"
+
+# Single source of truth for loaded models, shared between the background
+# preloader and the synchronous loader. Guarded by _lock so a preload and a
+# concurrent load_model() can never start two loads of the same model.
+_models = {}
+_lock = threading.Lock()
+
+
+def _load(model_name):
+    """Load a model with no Streamlit (st.*) calls — safe off the main thread."""
+    nlp = spacy.load(model_name)
+    if "trf_vectors" in nlp.pipe_names:  # heavy, unused in these demos
+        nlp.disable_pipe("trf_vectors")
+    return nlp
+
+
+def _get(model_name):
+    with _lock:
+        if model_name not in _models:
+            _models[model_name] = _load(model_name)
+        return _models[model_name]
+
+
+def start_preload(model_name=DEFAULT_MODEL):
+    """Kick off a non-blocking background load of the default model.
+
+    Called from the home page so the model warms while the user reads the demo
+    list. Cheap to call repeatedly: once loaded, the worker returns at once.
+    """
+    if model_name in _models:
+        return
+    threading.Thread(target=_get, args=(model_name,), daemon=True).start()
+
+
+@st.cache_resource(show_spinner="Loading LatinCy model…")
+def load_model(model_name=DEFAULT_MODEL):
+    """Return the shared, cached spaCy model for ``model_name``.
+
+    Reuses the background-preloaded instance when ready; otherwise loads it once
+    synchronously. Read-only use only — do not ``add_pipe``/``disable`` on the
+    result, since every demo shares this instance.
+    """
+    return _get(model_name)

pages/1_parsing_demo.py

@@ -1,11 +1,8 @@
 import streamlit as st
-import spacy
 import pandas as pd
 import datetime
-import gc
-import subprocess
-import json
-from spacy.util import registry
+
+from model_helpers import load_model
 
 st.set_page_config(page_title="Parsing Demo", layout="wide")
 st.sidebar.header("Parsing Demo")
@@ -73,41 +70,12 @@ def analyze_text(text):
 
 st.title("LatinCy Text Analyzer")
 
-# Using object notation
-first_model = "la_core_web_lg"
-first_model_version = spacy.info(first_model)["version"]
-
-
-# Function to unload the current model
-@st.cache_resource
-def load_model(model_name):
-    gc.collect()  # Attempt to free memory
-    nlp = spacy.load(model_name)
-    try:
-        if "trf_vectors" in nlp.pipe_names:  # Disable trf_vectors if it exists
-            nlp.disable_pipe("trf_vectors")
-    except Exception as e:
-        st.warning(f"Failed to disable 'trf_vectors': {e}")
-    return nlp
-
-
-# Function to load model in a subprocess to avoid conflicts
-def load_model_in_subprocess(model_name):
-    script = (
-        "import spacy, json; "
-        'nlp = spacy.load("' + model_name + '"); '
-        "print(json.dumps(nlp.meta))"
-    )
-    result = subprocess.run(["python", "-c", script], capture_output=True, text=True)
-    if result.returncode != 0:
-        raise RuntimeError(f"Failed to load model {model_name}: {result.stderr}")
-    return json.loads(result.stdout)
-
-
-model_name = "la_core_web_lg"  # Hardcoded to use only the lg model
-nlp = spacy.load(model_name)  # Directly load the lg model
+# Shared, cached lg model — warmed at startup by the home-page preloader, so
+# this returns instantly on all but the very first (cold) load.
+model_name = "la_core_web_lg"
+nlp = load_model(model_name)
 
-st.write(f"Loaded model: {model_name} (v{spacy.info(model_name)['version']})")
+st.write(f"Loaded model: {model_name} (v{nlp.meta['version']})")
 
 df = None
 

pages/2_custom_label_demo.py

@@ -46,10 +46,19 @@ model_selectbox = st.sidebar.selectbox(
     ("la_core_web_lg", "la_core_web_md", "la_core_web_sm")
 )
 
-nlp = spacy.load(model_selectbox)
-
-# Add component to pipeline
-nlp.add_pipe("dcc_core", last=True)
+# This demo mutates its pipeline (adds the dcc_core component), so it caches
+# its OWN instance rather than sharing the read-only model from model_helpers —
+# mutating a shared model would leak dcc_core into the other demos. The guard
+# keeps add_pipe idempotent across Streamlit reruns of the cached instance.
+@st.cache_resource
+def load_dcc_model(model_name):
+    nlp = spacy.load(model_name)
+    if "dcc_core" not in nlp.pipe_names:
+        nlp.add_pipe("dcc_core", last=True)
+    return nlp
+
+
+nlp = load_dcc_model(model_selectbox)
 
 tab1, tab2 = st.tabs(["Analyze", "About"])
 

pages/3_senter_demo.py

@@ -1,17 +1,13 @@
 import streamlit as st
-import spacy
 import datetime
 
+from model_helpers import load_model
+
 st.set_page_config(page_title="Sentence Segmenter", layout="wide")
 st.sidebar.header("Sentence Segmenter")
 
 
-# Load spaCy model (Latin large)
-@st.cache_resource
-def load_model():
-    return spacy.load("la_core_web_lg")
-
-
+# Shared, cached lg model (warmed by the home-page preloader)
 nlp = load_model()
 
 st.title("Latin Sentence Segmenter")

pages/4_ner_demo.py

@@ -1,7 +1,8 @@
 import streamlit as st
-import spacy
 from spacy_streamlit import visualize_ner
 
+from model_helpers import load_model
+
 st.set_page_config(page_title="NER Demo", layout="wide")
 st.sidebar.header("NER Demo")
 
@@ -23,11 +24,6 @@ model_selectbox = st.sidebar.selectbox(
 )
 
 
-@st.cache_resource
-def load_model(model_name):
-    return spacy.load(model_name)
-
-
 nlp = load_model(model_selectbox)
 
 tab1, tab2 = st.tabs(["Recognize", "About"])

pages/5_dependency_demo.py

@@ -1,7 +1,8 @@
 import streamlit as st
-import spacy
 from spacy_streamlit import visualize_parser
 
+from model_helpers import load_model
+
 st.set_page_config(page_title="Dependency Demo", layout="wide")
 st.sidebar.header("Dependency Demo")
 
@@ -32,11 +33,6 @@ model_selectbox = st.sidebar.selectbox(
 compact = st.sidebar.checkbox("Compact mode", value=False)
 
 
-@st.cache_resource
-def load_model(model_name):
-    return spacy.load(model_name)
-
-
 nlp = load_model(model_selectbox)
 
 tab1, tab2 = st.tabs(["Parse", "About"])