bcv-commons/aligned-lex

aligned_lex — published surface → Strong's lexicons

The attested target-word → Strong's mapping mined by the aligner, one language per partition, for consumption by bcv-commons (and downstream, the bcv-query monorepo as external resources/).

Layout — why the data isn't in git

Per-language lexicons are regenerated whenever the method/model/spine/source improves. Committing them would bloat git history without bound at scale (thousands of languages × re-runs). So:

aligned_lex/
  README.md            # committed — this file
  manifest.json        # committed — per-language metadata + content hash (the durable record)
  iso=<iso>/           # GIT-IGNORED — the bulk data, published out-of-band
    data.parquet

The Parquet partitions are published to a data channel (a Hugging Face dataset or object storage), keyed by the manifest's content_sha256. manifest.json is git's small, diffable record of what exists and what it hashes to — it changes only when the data actually changes.

Schema (per row)

column	type	meaning
surface	string	target rendering, lowercased (content tokens; may be multi-word)
strong	string	Strong's number (H#### OT / G#### NT)
count	int32	times this (surface → strong) pair was aligned
share	float32	count / Σ count for that surface = P(strong | surface) — which sense
hi_conf	float32	fraction of this pair's alignments that were intersection-backed (both eflomal directions agreed, score ≥ 0.9) — how much to trust the alignment

iso is recovered from the Hive partition path (iso=<iso>/), so a dataset read yields it as a column for free. Two orthogonal confidence axes: share = which Strong's; hi_conf = alignment reliability. Rows are grouped by surface, strongest sense first. A consumer picks the argmax-share Strong's and can threshold on hi_conf/count to trade coverage for precision.

Authentication (one-time)

The push reads a cached Hugging Face login, so you authenticate once and every future --publish (any language, any change) reuses it — no token to pass each run:

python3 -c "from huggingface_hub import login; login()"   # prompts once → ~/.cache/huggingface/token
python3 -c "from huggingface_hub import HfApi; print(HfApi().whoami()['name'])"   # verify

Use a fine-grained token (huggingface.co/settings/tokens) scoped to write on just the target dataset/org — same convenience, minimal blast radius. Prefer this to export HF_TOKEN=… in your shell profile: same persistence, but the token isn't injected into every process's environment. Re-run login() only if you rotate/revoke the token.

Regenerate / add a language

# 1. align (produces out/align_eflomal_<iso>_*.jsonl)
python3 -m strongs_aligner.run_pilot --method eflomal --ot --usj-dir <usj> --iso <iso>
# 2. export → aligned_lex/iso=<iso>/data.parquet  +  update manifest.json   (needs the [publish] extra)
python3 -m strongs_aligner.export_lex --iso <iso> --method eflomal --lang-name <Name>
# 3. publish the partition + manifest + this card to a HF dataset (auth: see above)
python3 -m strongs_aligner.export_lex --iso <iso> --publish bcv-commons/aligned-lex --create
#    (append --dry-run to preview the upload without pushing)

pip install -e '.[publish]' for the Parquet writer + HF uploader (pyarrow, huggingface_hub). Use --format tsv for a plain-text partition instead. Publishing thousands of languages: keep each folder < 10k files and squash history on the data channel (see the Hugging Face storage limits). The push uploads only this language's partition plus the shared manifest.json/README.md — other languages are untouched.

Provenance & quality

Per-language provenance (method, min_count, testament, row/surface/Strong's counts, hi_conf_ge_0.9, spine tags, content hash) lives in manifest.json. Quality basis: promoted after the gold benchmark passed — eflomal scores 91.8% (fra) / 95.6% (hau) token-weighted top-1 vs Clear-Bible manual alignments (docs/benchmark.md). ind has no manual gold; it inherits trust from the method's cross-language validation. These are raw aligned counts, not hand-checked — use share/hi_conf to threshold.