Add latincy-lexicon demos: lexicon lookup and paradigm generator

Two new pages wrapping latincy-lexicon v0.1.0:

- 11_lexicon_lookup_demo — contextual Whitaker's Words lookup over
a Latin sentence, with expandable per-token dictionary entries
(principal parts, age/frequency, all glosses)
- 12_paradigm_demo — full inflectional paradigm for any token,
with per-feature filter dropdowns

Shared lexicon_helpers.py caches one pipeline across both pages
(spaCy + whitakers_words + paradigm_generator), so the first visit
pays ~10-15s for spaCy load + JSON artifact build, and subsequent
page switches are instant. Preset sentences drawn from the
latincy-lexicon demo notebook (Aeneid, Caesar, Cicero, Catullus,
Ovid, plus two simple sentences).

Installs latincy-lexicon from the v0.1.0 git tag; flip to a PyPI
pin once the package is published.

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

app.py

@@ -24,5 +24,7 @@ st.markdown(
     - [Normalize U/V spelling](uv_normalizer_demo) with rule-based [latincy-uv](https://github.com/diyclassics/latincy-uv)
     - [Correct long-s OCR artifacts](long_s_demo) with [latincy-long-s](https://github.com/diyclassics/latincy-long-s)
     - [Restore Greek diacritics](diacritics_demo) with [latincy-diacritics](https://github.com/diyclassics/latincy-diacritics)
+    - [Look up Latin words in Whitaker's Words](lexicon_lookup_demo) with [latincy-lexicon](https://github.com/latincy/latincy-lexicon)
+    - [Generate full inflectional paradigms](paradigm_demo) for any Latin token
 """
 )

lexicon_helpers.py

@@ -0,0 +1,105 @@
+"""Shared helpers for latincy-lexicon demo pages (11, 12, 13)."""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+import streamlit as st
+
+
+# Preset sentences shared across all three lexicon demos.
+# Drawn from the latincy-lexicon demo notebook.
+PRESET_SENTENCES: dict[str, str] = {
+    "Simple — Poeta bonus": "Poeta bonus carmina pulchra scribit.",
+    "Simple — Gallia": "Gallia est omnis divisa in partes tres.",
+    "Aeneid I.1": (
+        "Arma virumque cano, Troiae qui primus ab oris "
+        "Italiam fato profugus Laviniaque venit litora."
+    ),
+    "Caesar BG I.1": (
+        "Gallia est omnis divisa in partes tres, quarum unam "
+        "incolunt Belgae, aliam Aquitani, tertiam qui ipsorum "
+        "lingua Celtae, nostra Galli appellantur."
+    ),
+    "Cicero Cat. I.1": (
+        "Quo usque tandem abutere, Catilina, patientia nostra? "
+        "Quam diu etiam furor iste tuus nos eludet?"
+    ),
+    "Catullus 5": (
+        "Vivamus mea Lesbia atque amemus, rumoresque senum "
+        "severiorum omnes unius aestimemus assis."
+    ),
+    "Ovid Met. I.1": (
+        "In nova fert animus mutatas dicere formas corpora."
+    ),
+}
+
+
+@st.cache_resource(show_spinner="Building Whitaker's Words data (first load only)…")
+def build_lexicon_artifacts() -> tuple[Path, Path]:
+    """Build lexicon.json + analyzer.json once per session.
+
+    Artifacts are cached under a temp directory. First call takes
+    ~5–10s; subsequent calls short-circuit via Streamlit's
+    cache_resource and are instant.
+    """
+    from latincy_lexicon.build import build
+
+    output_dir = Path(tempfile.gettempdir()) / "latincy-dashboard-lexicon"
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    lexicon_path = output_dir / "lexicon.json"
+    analyzer_path = output_dir / "analyzer.json"
+
+    if not (lexicon_path.exists() and analyzer_path.exists()):
+        build(output_dir=output_dir)
+
+    return lexicon_path, analyzer_path
+
+
+@st.cache_resource(show_spinner="Loading LatinCy pipeline…")
+def load_lexicon_pipeline(model_name: str):
+    """Load a LatinCy model with whitakers_words + paradigm_generator attached.
+
+    Cached per model_name — all three lexicon demo pages share the same
+    pipeline instance, so switching pages is instant after the first
+    load.
+    """
+    import spacy
+
+    nlp = spacy.load(model_name)
+    lexicon_path, analyzer_path = build_lexicon_artifacts()
+
+    nlp.add_pipe(
+        "whitakers_words",
+        config={
+            "lexicon_path": str(lexicon_path),
+            "analyzer_path": str(analyzer_path),
+        },
+        last=True,
+    )
+    nlp.add_pipe(
+        "paradigm_generator",
+        config={"analyzer_path": str(analyzer_path)},
+        last=True,
+    )
+    return nlp
+
+
+def sentence_picker(key: str, default_idx: int = 0) -> str:
+    """Render a preset dropdown + free-text area. Returns selected text."""
+    options = list(PRESET_SENTENCES.keys())
+    preset = st.selectbox(
+        "Preset sentence:",
+        options,
+        index=default_idx,
+        key=f"preset_{key}",
+    )
+    text = st.text_area(
+        "Latin text:",
+        value=PRESET_SENTENCES[preset],
+        height=100,
+        key=f"text_{key}",
+    )
+    return text

pages/11_lexicon_lookup_demo.py

@@ -0,0 +1,157 @@
+import pandas as pd
+import streamlit as st
+
+from lexicon_helpers import load_lexicon_pipeline, sentence_picker
+
+st.set_page_config(page_title="Lexicon Lookup Demo", layout="wide")
+st.sidebar.header("Lexicon Lookup Demo")
+
+st.title("Whitaker's Words Lexicon Lookup")
+st.markdown(
+    """
+Run Latin text through LatinCy + Whitaker's Words to get dictionary
+glosses and ranked parses for each token.
+"""
+)
+
+st.info(
+    "This lookup is designed for **contextual analysis**: entries are "
+    "ranked using upstream LatinCy annotations (POS, morphology, "
+    "dependency, NER). Single-word or fragment inputs may rank poorly "
+    "because those signals are missing or unreliable — give it a full "
+    "sentence for best results."
+)
+
+model_name = st.sidebar.selectbox(
+    "Choose model:",
+    ("la_core_web_lg", "la_core_web_md", "la_core_web_sm"),
+)
+
+nlp = load_lexicon_pipeline(model_name)
+
+tab1, tab2 = st.tabs(["Lookup", "About"])
+
+with tab1:
+    text = sentence_picker("lookup")
+
+    if st.button("Analyze", key="lookup_analyze"):
+        doc = nlp(text)
+        rows = []
+        lex_data = []
+        for token in doc:
+            if token.is_punct or token.is_space:
+                continue
+            lex = token._.lexicon or []
+            top_gloss = ""
+            if lex:
+                glosses = lex[0].get("glosses", [])
+                if isinstance(glosses, list) and glosses:
+                    top_gloss = glosses[0]
+                elif isinstance(glosses, str):
+                    top_gloss = glosses
+            rows.append(
+                {
+                    "Token": token.text,
+                    "Lemma": token.lemma_,
+                    "POS": token.pos_,
+                    "Top Gloss": top_gloss[:80],
+                }
+            )
+            lex_data.append({"text": token.text, "entries": lex})
+        st.session_state["lookup_rows"] = rows
+        st.session_state["lookup_lex"] = lex_data
+
+    if "lookup_rows" in st.session_state:
+        df = pd.DataFrame(st.session_state["lookup_rows"])
+        st.dataframe(
+            df,
+            use_container_width=True,
+            hide_index=True,
+            column_config={
+                "Token": st.column_config.TextColumn(width="small"),
+                "Lemma": st.column_config.TextColumn(width="small"),
+                "POS": st.column_config.TextColumn(width="small"),
+                "Top Gloss": st.column_config.TextColumn(width="large"),
+            },
+        )
+
+        st.markdown("---")
+        st.markdown("**Select a token for the full dictionary entry:**")
+        lex_data = st.session_state["lookup_lex"]
+        options = [f"{d['text']} ({i + 1})" for i, d in enumerate(lex_data)]
+        idx = st.selectbox(
+            "Token:",
+            range(len(options)),
+            format_func=lambda i: options[i],
+            key="lookup_token",
+        )
+
+        if idx is not None:
+            tok = lex_data[idx]
+            st.subheader(tok["text"])
+            if not tok["entries"]:
+                st.info("No lexicon entries for this token.")
+            else:
+                for j, entry in enumerate(tok["entries"], 1):
+                    headword = entry.get("headword") or entry.get("lemma", "?")
+                    pos = entry.get("pos", "?")
+                    st.markdown(f"**Entry {j}:** `{headword}` ({pos})")
+
+                    parts = entry.get("principal_parts")
+                    if parts:
+                        if isinstance(parts, list):
+                            parts = ", ".join(str(p) for p in parts)
+                        st.markdown(f"- Principal parts: `{parts}`")
+
+                    glosses = entry.get("glosses")
+                    if glosses:
+                        if isinstance(glosses, list):
+                            st.markdown(
+                                "- Glosses:\n"
+                                + "\n".join(f"  - {g}" for g in glosses[:6])
+                            )
+                        else:
+                            st.markdown(f"- Gloss: {glosses}")
+
+                    age = entry.get("age")
+                    freq = entry.get("frequency") or entry.get("freq")
+                    meta = []
+                    if age:
+                        meta.append(f"Age: `{age}`")
+                    if freq:
+                        meta.append(f"Frequency: `{freq}`")
+                    if meta:
+                        st.markdown("- " + "  |  ".join(meta))
+
+                    st.markdown("---")
+
+with tab2:
+    st.markdown(
+        """
+        ## About
+
+        This demo runs Latin text through the full LatinCy pipeline plus
+        the `whitakers_words` component from
+        [latincy-lexicon](https://github.com/latincy/latincy-lexicon),
+        which wraps [Whitaker's Words](https://mk270.github.io/whitakers-words/)
+        as a spaCy pipeline component.
+
+        Each token gets:
+
+        - `token._.gloss` — short definition from the top-ranked entry
+        - `token._.lexicon` — full dictionary entries with principal parts,
+          age/frequency metadata, and glosses
+        - `token._.ww` — ranked morphological parses from the WW stem+ending
+          engine
+
+        Entries are ranked using upstream LatinCy signals (POS match,
+        morphological features, dependency label, NER context) plus WW's
+        built-in frequency grades.
+
+        ### First-run note
+
+        On first load, the page builds the WW lexicon and analyzer JSON
+        artifacts in memory (~5–10s). Subsequent loads are instant —
+        Streamlit caches the pipeline for the session.
+        """
+    )

pages/12_paradigm_demo.py

@@ -0,0 +1,182 @@
+import pandas as pd
+import streamlit as st
+
+from lexicon_helpers import load_lexicon_pipeline, sentence_picker
+
+st.set_page_config(page_title="Paradigm Demo", layout="wide")
+st.sidebar.header("Paradigm Demo")
+
+st.title("Latin Paradigm Generator")
+st.markdown(
+    """
+Pick a token from a Latin sentence to see its complete inflectional
+paradigm — every form the lemma can take, generated from Whitaker's
+Words inflection tables.
+"""
+)
+
+model_name = st.sidebar.selectbox(
+    "Choose model:",
+    ("la_core_web_lg", "la_core_web_md", "la_core_web_sm"),
+)
+
+nlp = load_lexicon_pipeline(model_name)
+
+
+def _feats_to_dict(feats) -> dict:
+    """Normalize feats to a plain dict (accepts dict or UD-string)."""
+    if isinstance(feats, dict):
+        return feats
+    if isinstance(feats, str):
+        return dict(
+            kv.split("=", 1) for kv in feats.split("|") if "=" in kv
+        )
+    return {}
+
+
+tab1, tab2 = st.tabs(["Paradigm", "About"])
+
+with tab1:
+    text = sentence_picker("paradigm")
+
+    if st.button("Analyze", key="paradigm_analyze"):
+        doc = nlp(text)
+        tokens = []
+        for token in doc:
+            if token.is_punct or token.is_space:
+                continue
+            paradigm = token._.paradigm or []
+            # Serialize to plain dicts so we can stash in session state.
+            serialized = [
+                {
+                    "form": f.get("form") if isinstance(f, dict) else f.form,
+                    "lemma": f.get("lemma") if isinstance(f, dict) else f.lemma,
+                    "upos": f.get("upos") if isinstance(f, dict) else f.upos,
+                    "feats": _feats_to_dict(
+                        f.get("feats") if isinstance(f, dict) else f.feats
+                    ),
+                }
+                for f in paradigm
+            ]
+            tokens.append(
+                {
+                    "text": token.text,
+                    "lemma": token.lemma_,
+                    "pos": token.pos_,
+                    "paradigm": serialized,
+                }
+            )
+        st.session_state["paradigm_tokens"] = tokens
+
+    if "paradigm_tokens" in st.session_state:
+        tokens = st.session_state["paradigm_tokens"]
+
+        overview = pd.DataFrame(
+            [
+                {
+                    "Token": t["text"],
+                    "Lemma": t["lemma"],
+                    "POS": t["pos"],
+                    "Forms": len(t["paradigm"]),
+                }
+                for t in tokens
+            ]
+        )
+        st.dataframe(overview, use_container_width=True, hide_index=True)
+
+        st.markdown("---")
+        st.markdown("**Select a token to see its full paradigm:**")
+        options = [
+            f"{t['text']} — {t['lemma']} ({t['pos']})" for t in tokens
+        ]
+        idx = st.selectbox(
+            "Token:",
+            range(len(options)),
+            format_func=lambda i: options[i],
+            key="paradigm_token",
+        )
+
+        if idx is not None:
+            t = tokens[idx]
+            if not t["paradigm"]:
+                st.info(
+                    f"No paradigm available for {t['text']} "
+                    "(unknown lemma or closed-class word)."
+                )
+            else:
+                # Build a wide table: Form | UPOS | <feat columns>
+                rows = []
+                all_feats: list[str] = []
+                for f in t["paradigm"]:
+                    for k in f["feats"]:
+                        if k not in all_feats:
+                            all_feats.append(k)
+                for f in t["paradigm"]:
+                    row = {"Form": f["form"], "UPOS": f["upos"]}
+                    for k in all_feats:
+                        row[k] = f["feats"].get(k, "")
+                    rows.append(row)
+
+                st.markdown(
+                    f"### `{t['lemma']}` — {len(t['paradigm'])} forms"
+                )
+
+                # Optional feature filter
+                with st.expander("Filter by feature", expanded=False):
+                    filters: dict[str, str] = {}
+                    cols = st.columns(min(len(all_feats), 4) or 1)
+                    for i, feat in enumerate(all_feats):
+                        vals = sorted(
+                            {f["feats"].get(feat, "") for f in t["paradigm"]}
+                            - {""}
+                        )
+                        if not vals:
+                            continue
+                        with cols[i % len(cols)]:
+                            choice = st.selectbox(
+                                feat,
+                                ["(any)"] + vals,
+                                key=f"filter_{feat}",
+                            )
+                            if choice != "(any)":
+                                filters[feat] = choice
+
+                if filters:
+                    rows = [
+                        r
+                        for r in rows
+                        if all(r.get(k) == v for k, v in filters.items())
+                    ]
+                    st.caption(f"Showing {len(rows)} form(s) matching filters.")
+
+                df = pd.DataFrame(rows)
+                st.dataframe(df, use_container_width=True, hide_index=True)
+
+with tab2:
+    st.markdown(
+        """
+        ## About
+
+        The `paradigm_generator` component attaches a full inflectional
+        paradigm to each token via `token._.paradigm` — the inverse of
+        Whitaker's analyzer: given a lemma, produce every form the lemma
+        can take.
+
+        ### Form counts to expect
+
+        | POS | Forms | Notes |
+        |-----|-------|-------|
+        | Verb (regular) | 200–280 | Person × Number × Tense × Mood × Voice |
+        | Adjective (3 endings) | ~84 | Case × Number × Gender × Degree |
+        | Noun | 10–15 | Case × Number |
+        | `sum` (irregular) | ~143 | Includes suppletive stems (s-, es-, fu-, fo-) |
+
+        ### How it works
+
+        Each entry in the shipped analyzer JSON knows its inflection
+        pattern (declension or conjugation). The generator applies every
+        applicable ending from the WW inflection tables, filters by age
+        and frequency where appropriate, and returns forms tagged with
+        UD morphological features.
+        """
+    )

requirements.txt

@@ -9,5 +9,6 @@ la-latincy-lookups>=1.0.0
 spacy-streamlit==1.0.6
 latincy-diacritics @ https://huggingface.co/latincy/latincy-diacritics/resolve/main/latincy_diacritics-0.1.0-py3-none-any.whl
 latincy-preprocess>=0.2.0
+latincy-lexicon @ git+https://github.com/latincy/latincy-lexicon@v0.1.0
 streamlit==1.45.1
 watchdog==6.0.0