Add Stoicheia parsing for complete Hypotactic coverage

.gitignore

@@ -3,3 +3,5 @@ __pycache__/
 .logs/
 .build-stage-*/
 .build-backup-*/
+.stoicheia-cache/
+.hf-stoicheia/

CHANGELOG.md

@@ -10,6 +10,8 @@
   Sphragis sentence publication and its metadata.
 - Moved the scanned-line configurations to the separate `sphragis-metre`
   dataset.
+- Added a pinned, resumable Stoicheia parsing stage that supplies predicted
+  CoNLL-U for curated Hypotactic lines without gold syntax in `sphragis-metre`.
 
 ## 0.3.2-beta — 2026-08-18
 

README.md

@@ -224,7 +224,8 @@ Machine-readable reasons and pre-deduplication counts are recorded in
 python -m pip install -r requirements-build.txt
 python scripts/build_dataset.py --sources /path/to/frozen/checkouts \
   --metre-output ../sphragis-metre/data \
-  --metre-metadata ../sphragis-metre/metadata
+  --metre-metadata ../sphragis-metre/metadata \
+  --stoicheia-conllu .stoicheia-cache/hypotactic_conllu.jsonl
 python scripts/validate_publication.py --publication sentence --data data
 python scripts/validate_publication.py \
   --publication metre --data ../sphragis-metre/data

requirements-stoicheia.txt

@@ -0,0 +1,3 @@
+huggingface-hub>=0.34,<2
+safetensors>=0.5,<1
+transformers>=4.57,<5

scripts/build_dataset.py

@@ -161,6 +161,43 @@ VERSE_LINKS = {
 }
 
 
+# Files predating Hypotactic's embedded data-author/data-work metadata are
+# identified here from their stable upstream filenames. Received or disputed
+# corpora remain explicit so the normal conservative authorship policy can
+# exclude them rather than silently inventing labels.
+HYPOTACTIC_FILE_METADATA = {
+    "HHAphrodite": ("Homer/Anon", "Homeric Hymn to Aphrodite"),
+    "HHApollo": ("Homer/Anon", "Homeric Hymn to Apollo"),
+    "HHDemeter": ("Homer/Anon", "Homeric Hymn to Demeter"),
+    "HHermes": ("Homer/Anon", "Homeric Hymn to Hermes"),
+    "HHymns": ("Homer/Anon", "The Homeric Hymns"),
+    "aratus": ("Aratus", "Phaenomena"),
+    "batmumach": ("Pseudo-Homer", "Batrachomyomachia"),
+    "cleanthes": ("Cleanthes", "Hymn to Zeus"),
+    "colluthus": ("Colluthus", "Rape of Helen"),
+    "lycophron": ("Lycophron", "Alexandra"),
+    "persians": ("Aeschylus", "Persians"),
+    "prometheus": ("Aeschylus", "Prometheus Bound"),
+    "scutum": ("Hesiod", "Shield of Heracles"),
+    "seven": ("Aeschylus", "Seven Against Thebes"),
+    "theognis": ("Theognis", "Theognidea"),
+    "theogony": ("Hesiod", "Theogony"),
+    "tryph": ("Tryphiodorus", "Sack of Troy"),
+    "worksanddays": ("Hesiod", "Works and Days"),
+}
+
+HYPOTACTIC_CANONICAL_WORK_IDS = {
+    ("Aeschylus", "Persians"): "tlg0085.tlg002",
+    ("Aeschylus", "Prometheus Bound"): "tlg0085.tlg003",
+    ("Aeschylus", "Seven Against Thebes"): "tlg0085.tlg004",
+    ("Hesiod", "Theogony"): "tlg0020.tlg001",
+    ("Hesiod", "Works and Days"): "tlg0020.tlg002",
+    ("Hesiod", "Shield of Heracles"): "tlg0020.tlg003",
+    ("Homeric-Iliad", "Iliad"): "tlg0012.tlg001",
+    ("Homeric-Odyssey", "Odyssey"): "tlg0012.tlg002",
+}
+
+
 PEDALION_VERSE = {
     "achar.xml",
     "thesmo.xml",
@@ -587,6 +624,8 @@ def authorship_decision(sentence: Sentence) -> tuple[str | None, str | None]:
         author = f"Homeric-{work}"
 
     lowered_author = author.casefold()
+    if author == "Homer/Anon":
+        return None, "anonymous_or_received_homeric_hymn"
     if lowered_author.startswith("unknown"):
         return None, "unknown_author"
     if lowered_author.startswith("anonymous"):
@@ -1039,7 +1078,8 @@ class HypotacticParser(HTMLParser):
             self.word_depth = None
             self.word_text = []
         if self.line_depth == self.depth and tag == "div":
-            self.line["text"] = " ".join(self.line.pop("words"))
+            self.line["tokens"] = self.line.pop("words")
+            self.line["text"] = " ".join(self.line["tokens"])
             symbols = {"long": "–", "short": "⏑", "anceps": "×", "unknown": "?"}
             self.line["scansion"] = "".join(symbols[s["quantity"]] for s in self.line["syllables"])
             self.line["hypotactic_file"] = self.stem + ".html"
@@ -1050,6 +1090,7 @@ class HypotacticParser(HTMLParser):
                 "poem_sequence": self.poem.get("sequence", "1"),
             })
             if self.line["text"] and self.line["number"]:
+                self.line["line_sequence"] = str(len(self.lines) + 1)
                 self.lines.append(self.line)
             self.line = None
             self.line_depth = None
@@ -1063,7 +1104,10 @@ def parse_hypotactic_file(path: Path) -> list[dict]:
     parser = HypotacticParser(path.stem)
     parser.feed(path.read_text(encoding="utf8"))
     # Older files do not carry book metadata; recover it from their stem.
-    book_match = re.match(r"(?:iliad|odyssey|dionysiaca|qsmyrnaeus)(\d+)$", path.stem)
+    book_match = re.match(
+        r"(?:apollonius|iliad|odyssey|dionysiaca|qsmyrnaeus)(\d+)$",
+        path.stem,
+    )
     for line in parser.lines:
         if not line["book"] and book_match:
             line["book"] = book_match.group(1)
@@ -1071,12 +1115,72 @@ def parse_hypotactic_file(path: Path) -> list[dict]:
     return parser.lines
 
 
-def load_hypotactic(root: Path) -> dict[str, list[dict]]:
+def load_hypotactic(root: Path, *, all_files: bool = False) -> dict[str, list[dict]]:
     html_root = root / "hypotactic_htmls_greek"
-    needed = sorted({stem for link in VERSE_LINKS.values() for stem in link["files"]})
+    needed = (
+        sorted(path.stem for path in html_root.glob("*.html"))
+        if all_files
+        else sorted({stem for link in VERSE_LINKS.values() for stem in link["files"]})
+    )
     return {stem: parse_hypotactic_file(html_root / f"{stem}.html") for stem in needed}
 
 
+def hypotactic_author_work(stem: str, line: dict) -> tuple[str, str, str]:
+    """Return curated upstream author/work labels and a stable work ID."""
+    if re.fullmatch(r"apollonius\d+", stem):
+        author, work = "Apollonius Rhodius", "Argonautica"
+    elif re.fullmatch(r"iliad\d+", stem):
+        author, work = "Homer", "Iliad"
+    elif re.fullmatch(r"odyssey\d+", stem):
+        author, work = "Homer", "Odyssey"
+    else:
+        author = line.get("hypotactic_author", "").strip()
+        work = line.get("hypotactic_work", "").strip()
+        fallback = HYPOTACTIC_FILE_METADATA.get(stem)
+        if fallback and stem in {"persians", "seven"}:
+            author, work = fallback
+        if fallback:
+            author = author or fallback[0]
+            work = work or fallback[1]
+        if not work:
+            work = {
+                "Moschus": "Poems", "Semonides": "Fragments",
+                "Solon": "Fragments", "Tyrtaeus": "Elegies",
+            }.get(author, stem)
+    author = canonical_author(author)
+    if author == "Homer" and work in {"Iliad", "Odyssey"}:
+        author = f"Homeric-{work}"
+    work_id = HYPOTACTIC_CANONICAL_WORK_IDS.get(
+        (author, work), f"hypotactic:{slug(author)}:{slug(work)}",
+    )
+    return author, work, work_id
+
+
+def hypotactic_line_key(line: dict) -> tuple[str, str, str, str, str]:
+    return (
+        line["hypotactic_file"], line["poem_sequence"], line["book"],
+        line["number"], line["line_sequence"],
+    )
+
+
+def curated_hypotactic_line(stem: str, line: dict) -> tuple[dict | None, str | None]:
+    if not any("GREEK" in unicodedata.name(char, "") for char in line["text"]):
+        return None, "no_greek_letters"
+    author, work, work_id = hypotactic_author_work(stem, line)
+    curated_author, reason = authorship_decision(Sentence(
+        source="hypotactic", source_file=f"{stem}.html",
+        source_sentence_id=":".join(hypotactic_line_key(line)),
+        author=author, work=work, work_id=work_id, text=line["text"], conllu="",
+        genre="verse",
+    ))
+    if reason:
+        return None, reason
+    return {
+        "author": curated_author, "work": work, "work_id": work_id,
+        "text": line["text"], "tokens": line["tokens"],
+    }, None
+
+
 def verse_sentence_order_key(sentence: Sentence) -> tuple:
     references = []
     for cite in sentence.native_cites:
@@ -1176,7 +1280,7 @@ def hypotactic_source_records(lines: list[dict], revisions: dict[str, str]) -> l
         source_record(
             "hypotactic", revisions, source_file,
             ",".join(
-                f"{line['poem_sequence']}:{line['book']}:{line['number']}"
+                f"{line['poem_sequence']}:{line['book']}:{line['number']}:{line['line_sequence']}"
                 for line in file_lines
             ),
         )
@@ -1367,6 +1471,152 @@ def align_verse_blocks(
     return sentence_rows, metre_rows, alignment_stats
 
 
+STOICHEIA_MODEL_ID = "Ericu950/Stoicheia-tagger-parser"
+STOICHEIA_MODEL_REVISION = "cd8ae1658c364874c3b6f4df37bd1d46313e3cea"
+
+
+def load_stoicheia_predictions(path: Path) -> dict[tuple[str, ...], dict]:
+    predictions = {}
+    with path.open(encoding="utf-8") as handle:
+        for number, raw in enumerate(handle, 1):
+            try:
+                row = json.loads(raw)
+            except json.JSONDecodeError as error:
+                raise ValueError(f"invalid Stoicheia JSONL line {number}") from error
+            key = tuple(row["key"])
+            if key in predictions:
+                raise ValueError(f"duplicate Stoicheia prediction key: {key}")
+            if row["model"] != STOICHEIA_MODEL_ID:
+                raise ValueError(f"unexpected Stoicheia model at line {number}")
+            if row["model_revision"] != STOICHEIA_MODEL_REVISION:
+                raise ValueError(f"unexpected Stoicheia revision at line {number}")
+            predictions[key] = row
+    return predictions
+
+
+def stoicheia_source_record() -> dict:
+    return {
+        "source": "stoicheia_tagger_parser",
+        "source_file": STOICHEIA_MODEL_ID,
+        "source_sentence_id": "",
+        "url": f"https://huggingface.co/{STOICHEIA_MODEL_ID}",
+        "revision": STOICHEIA_MODEL_REVISION,
+        "license": "Apache-2.0",
+        "annotation_provenance": (
+            "automatic lemma, POS, morphology, and dependency prediction"
+        ),
+        "syntax_scheme": "Stoicheia AGDT heads converted to Universal Dependencies",
+    }
+
+
+def predicted_metre_rows(
+    all_hypotactic: dict[str, list[dict]],
+    predictions: dict[tuple[str, ...], dict],
+    gold_rows: list[dict],
+    revisions: dict[str, str],
+) -> tuple[list[dict], dict]:
+    """Fill lines without a gold tree with pinned Stoicheia predictions."""
+    lines_by_key = {
+        hypotactic_line_key(line): line
+        for lines in all_hypotactic.values()
+        for line in lines
+    }
+    eligible = {}
+    excluded = Counter()
+    for stem, lines in all_hypotactic.items():
+        for line in lines:
+            curated, reason = curated_hypotactic_line(stem, line)
+            if reason:
+                excluded[reason] += 1
+            else:
+                eligible[hypotactic_line_key(line)] = curated
+    if set(predictions) != set(eligible):
+        missing = set(eligible) - set(predictions)
+        extra = set(predictions) - set(eligible)
+        raise ValueError(
+            f"Stoicheia cache is incomplete or stale: missing={len(missing)} extra={len(extra)}"
+        )
+    gold_keys = {
+        (row["hypotactic_file"], row["poem_sequence"], row["book"], row["line_number"])
+        for row in gold_rows
+    }
+    output = []
+    excluded_disputed = 0
+    for key, prediction in sorted(predictions.items()):
+        if key[:4] in gold_keys:
+            continue
+        line = lines_by_key.get(key)
+        if line is None:
+            raise ValueError(f"Stoicheia prediction has no Hypotactic line: {key}")
+        if normalize(prediction["text"]) != line["normalized"]:
+            raise ValueError(f"Stoicheia prediction text drifted from Hypotactic: {key}")
+        author = eligible[key]["author"]
+        work = eligible[key]["work"]
+        work_id = eligible[key]["work_id"]
+        if (prediction["author"], prediction["work"]) != (author, work):
+            raise ValueError(f"Stoicheia prediction authorship drifted: {key}")
+        line_number = numeric_line_number(line["number"])
+        if line_number is not None and any(
+            start <= line_number <= end
+            for start, end in DISPUTED_VERSE_PASSAGES.get((author, work), ())
+        ):
+            excluded_disputed += 1
+            continue
+        hyp_record = hypotactic_source_records([line], revisions)[0]
+        model_record = stoicheia_source_record()
+        records = [hyp_record, model_record]
+        output.append({
+            "id": "vm-" + stable_id(work_id, *key),
+            "parent_sentence_ids": [],
+            "author": author,
+            "work": work,
+            "work_id": work_id,
+            "genre": "verse_metre",
+            "text": line["text"],
+            "conllu": prediction["conllu"],
+            "cts_urn": "",
+            "passage": line["number"],
+            "alignment_component_id": None,
+            "component_line_index": None,
+            "book": line["book"],
+            "poem_sequence": line["poem_sequence"],
+            "line_number": line["number"],
+            "metre": line["metre"] or "unspecified",
+            "syllables": json.dumps(line["syllables"], ensure_ascii=False),
+            "hypotactic_file": line["hypotactic_file"],
+            "treebank_source": "stoicheia_tagger_parser",
+            "syntax_annotation": "predicted",
+            "source_records": json.dumps(records, ensure_ascii=False, sort_keys=True),
+            "licenses": sorted({record["license"] for record in records}),
+            "dedup_key": hashlib.sha256(line["normalized"].encode()).hexdigest(),
+        })
+    for row in gold_rows:
+        row["syntax_annotation"] = "gold"
+    return output, {
+        "model": STOICHEIA_MODEL_ID,
+        "model_revision": STOICHEIA_MODEL_REVISION,
+        "predictions_in_cache": len(predictions),
+        "hypotactic_lines_total": len(lines_by_key),
+        "hypotactic_lines_excluded_before_parsing": sum(excluded.values()),
+        "hypotactic_lines_excluded_by_reason": dict(sorted(excluded.items())),
+        "gold_lines": len(gold_rows),
+        "gold_keys": len(gold_keys),
+        "predicted_lines_added": len(output),
+        "predictions_superseded_by_gold": sum(key[:4] in gold_keys for key in predictions),
+        "predicted_disputed_lines_excluded": excluded_disputed,
+        "predicted_head_repair_tokens": sum(
+            line.endswith("\tHeadRepair=Yes")
+            for row in output
+            for line in row["conllu"].splitlines()
+        ),
+        "predicted_tokens": sum(
+            bool(line) and not line.startswith("#")
+            for row in output
+            for line in row["conllu"].splitlines()
+        ),
+    }
+
+
 def numeric_line_number(value: str) -> int | None:
     match = re.match(r"^(\d+)", str(value))
     return int(match.group(1)) if match else None
@@ -1582,7 +1832,8 @@ def validate_source_verse_alignment(rows_by_base_config: dict[str, list[dict]])
     for row in rows_by_base_config["verse_sentence"]:
         components[row["alignment_component_id"]]["sentences"].append(row)
     for row in rows_by_base_config["verse_metre"]:
-        components[row["alignment_component_id"]]["lines"].append(row)
+        if row["alignment_component_id"] is not None:
+            components[row["alignment_component_id"]]["lines"].append(row)
     for component in components.values():
         sentences = sorted(
             component["sentences"], key=lambda row: row["component_sentence_index"],
@@ -1748,6 +1999,7 @@ def main() -> None:
     parser.add_argument("--metadata", type=Path, default=Path("metadata"))
     parser.add_argument("--metre-output", type=Path, required=True)
     parser.add_argument("--metre-metadata", type=Path, required=True)
+    parser.add_argument("--stoicheia-conllu", type=Path, required=True)
     args = parser.parse_args()
 
     revisions = {
@@ -1809,7 +2061,7 @@ def main() -> None:
     sentences, dedup_stats = deduplicate_sentences(sentence_input)
     assign_splits(sentences)
 
-    hyp = load_hypotactic(args.sources / "hypotactic")
+    hyp = load_hypotactic(args.sources / "hypotactic", all_files=True)
     verse_input, verse_curation = curate_sentences(agdt_verse + pedalion_verse)
     verse_sentence, verse_metre, alignment_stats = align_verse_blocks(
         verse_input, hyp, revisions,
@@ -1817,6 +2069,11 @@ def main() -> None:
     verse_sentence, verse_metre, passage_curation = exclude_disputed_verse_components(
         verse_sentence, verse_metre,
     )
+    stoicheia_predictions = load_stoicheia_predictions(args.stoicheia_conllu)
+    predicted_metre, stoicheia_stats = predicted_metre_rows(
+        hyp, stoicheia_predictions, verse_metre, revisions,
+    )
+    verse_metre.extend(predicted_metre)
     assign_splits(verse_sentence)
     assign_splits(verse_metre)
 
@@ -1857,9 +2114,16 @@ def main() -> None:
         key: {**SOURCE_INFO[key], "revision": revision}
         for key, revision in revisions.items()
     }
+    all_source_revisions["stoicheia_tagger_parser"] = {
+        "url": f"https://huggingface.co/{STOICHEIA_MODEL_ID}",
+        "license": "Apache-2.0",
+        "annotation": "automatic morphosyntactic and dependency annotation",
+        "scheme": "Stoicheia AGDT heads converted to Universal Dependencies",
+        "revision": STOICHEIA_MODEL_REVISION,
+    }
     sentence_source_revisions = {
         key: value for key, value in all_source_revisions.items()
-        if key != "hypotactic"
+        if key not in {"hypotactic", "stoicheia_tagger_parser"}
     }
     sentence_report = {
         "authorship_curation": {
@@ -1909,6 +2173,7 @@ def main() -> None:
         },
         "splitting": sentence_report["splitting"],
         "alignment": alignment_stats,
+        "automatic_syntax": stoicheia_stats,
         "excluded": sentence_report["excluded"],
     }
     publications = (

scripts/dataset_variants.py

@@ -143,6 +143,7 @@ def _provenance(row: dict) -> dict:
     keys = (
         "id", "work", "work_id", "cts_urn", "passage", "treebank_source",
         "book", "poem_sequence", "line_number", "hypotactic_file",
+        "syntax_annotation",
     )
     return {key: row.get(key) for key in keys if key in row}
 
@@ -247,6 +248,10 @@ def _aggregate_chunk(base_config: str, rows: list[dict], target: int, split: str
                 rows[0]["hypotactic_file"]
                 if len({row["hypotactic_file"] for row in rows}) == 1 else None
             ),
+            "syntax_annotation": (
+                rows[0]["syntax_annotation"]
+                if len({row["syntax_annotation"] for row in rows}) == 1 else "mixed"
+            ),
         })
     return chunk
 
@@ -306,6 +311,11 @@ def make_dataset_variants(
             "row_unit": "line" if base_config == "verse_metre" else "sentence",
             "shared_source_selection_target": BOTTLENECK_TARGET,
             "discarded_source_row_ids": bottleneck_discarded,
+            **({
+                "syntax_annotations": dict(Counter(
+                    row["syntax_annotation"] for row in shared_rows
+                )),
+            } if base_config == "verse_metre" else {}),
         }
         for target in CHUNK_TARGETS:
             config = f"{base_config}_{target}"
@@ -348,5 +358,10 @@ def make_dataset_variants(
                 },
                 "mixed_work_chunks": dict(mixed_work_chunks),
                 "chunking_seed": CHUNKING_SEED,
+                **({
+                    "syntax_annotations": dict(Counter(
+                        row["syntax_annotation"] for row in variant_rows
+                    )),
+                } if base_config == "verse_metre" else {}),
             }
     return variants, report

scripts/stoicheia_parse_hypotactic.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python3
+"""Create resumable Stoicheia CoNLL-U predictions for curated Hypotactic lines."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+import sys
+import time
+import unicodedata
+
+import torch
+from huggingface_hub import snapshot_download
+from transformers import AutoModel
+
+try:
+    from scripts.build_dataset import (
+        curated_hypotactic_line,
+        hypotactic_line_key,
+        load_hypotactic,
+        normalize,
+    )
+except ModuleNotFoundError:
+    from build_dataset import (
+        curated_hypotactic_line,
+        hypotactic_line_key,
+        load_hypotactic,
+        normalize,
+    )
+
+
+MODEL_ID = "Ericu950/Stoicheia-tagger-parser"
+MODEL_REVISION = "cd8ae1658c364874c3b6f4df37bd1d46313e3cea"
+
+
+def retained_line(stem: str, line: dict) -> dict | None:
+    curated, reason = curated_hypotactic_line(stem, line)
+    if reason:
+        return None
+    return {
+        "key": list(hypotactic_line_key(line)),
+        **curated,
+    }
+
+
+def load_completed(path: Path) -> set[tuple[str, ...]]:
+    completed = set()
+    if not path.exists():
+        return completed
+    with path.open(encoding="utf-8") as handle:
+        for number, raw in enumerate(handle, 1):
+            try:
+                row = json.loads(raw)
+            except json.JSONDecodeError as error:
+                raise ValueError(f"invalid checkpoint JSON at line {number}") from error
+            completed.add(tuple(row["key"]))
+    return completed
+
+
+def repair_tree(words: list[dict]) -> list[dict]:
+    """Make the greedy biaffine decode a single rooted, acyclic UD tree."""
+    if not words:
+        raise ValueError("Stoicheia decoded no Greek tokens")
+    n = len(words)
+    original = [(int(word.get("head") or 0), word.get("deprel")) for word in words]
+    heads = [int(word.get("head") or 0) for word in words]
+    roots = [
+        index for index, (word, head) in enumerate(zip(words, heads), 1)
+        if head == 0 and word["upos"] != "PUNCT"
+    ]
+    primary = roots[0] if roots else next(
+        (index for index, word in enumerate(words, 1) if word["upos"] != "PUNCT"), 1,
+    )
+    for index, word in enumerate(words, 1):
+        head = heads[index - 1]
+        if index == primary:
+            heads[index - 1] = 0
+            word["deprel"] = "root"
+        elif head < 0 or head > n or head in {0, index}:
+            heads[index - 1] = primary
+            word["deprel"] = "punct" if word["upos"] == "PUNCT" else "dep"
+        elif word.get("deprel") == "root":
+            word["deprel"] = "dep"
+
+    changed = True
+    while changed:
+        changed = False
+        for token_id in range(1, n + 1):
+            trail = []
+            cursor = token_id
+            while cursor:
+                if cursor in trail:
+                    cycle = trail[trail.index(cursor):]
+                    break_id = min(cycle)
+                    heads[break_id - 1] = 0 if break_id == primary else primary
+                    words[break_id - 1]["deprel"] = (
+                        "root" if break_id == primary else "dep"
+                    )
+                    changed = True
+                    break
+                trail.append(cursor)
+                cursor = heads[cursor - 1]
+            if changed:
+                break
+    for word, head, (old_head, old_deprel) in zip(words, heads, original):
+        word["head"] = head
+        word["head_repair"] = head != old_head or word.get("deprel") != old_deprel
+    return words
+
+
+def restore_alphabetic_non_greek_tokens(
+    tokens: list[str], words: list[dict],
+) -> list[dict]:
+    """Restore alphabetic tokens the character model intentionally omits."""
+    old_to_new = {}
+    merged = []
+    decoded_index = 0
+    for token in tokens:
+        has_greek = any("GREEK" in unicodedata.name(char, "") for char in token)
+        if has_greek:
+            if decoded_index >= len(words) or words[decoded_index]["form"] != token:
+                raise ValueError("Stoicheia form order differs from Hypotactic tokens")
+            decoded_index += 1
+            old_to_new[decoded_index] = len(merged) + 1
+            merged.append(dict(words[decoded_index - 1]))
+        elif normalize(token):
+            merged.append({
+                "form": token, "lemma": token, "upos": "X", "xpos": "x--------",
+                "feats": {}, "head": 0, "deprel": "dep", "_restored": True,
+            })
+    if decoded_index != len(words):
+        raise ValueError("Stoicheia returned unexpected extra forms")
+    for word in merged:
+        if word.pop("_restored", False):
+            continue
+        if word.get("head"):
+            word["head"] = old_to_new[word["head"]]
+    return merged
+
+
+def encode_conllu(text: str, tokens: list[str], words: list[dict]) -> str:
+    words = restore_alphabetic_non_greek_tokens(tokens, words)
+    words = repair_tree(words)
+    lines = [f"# text = {text}"]
+    for index, word in enumerate(words, 1):
+        feats = word.get("feats") or {}
+        feat_text = "|".join(f"{key}={feats[key]}" for key in sorted(feats)) or "_"
+        lines.append("\t".join([
+            str(index), word["form"], word.get("lemma") or "_",
+            word.get("upos") or "X", word.get("xpos") or "_", feat_text,
+            str(word["head"]), word.get("deprel") or "dep", "_",
+            "HeadRepair=Yes" if word["head_repair"] else "_",
+        ]))
+    conllu = "\n".join(lines) + "\n\n"
+    forms = "".join(word["form"] for word in words)
+    if normalize(forms) != normalize(text):
+        raise ValueError("Stoicheia forms do not cover the Hypotactic line")
+    return conllu
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--hypotactic", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--batch-size", type=int, default=64)
+    parser.add_argument("--log-every", type=int, default=1024)
+    args = parser.parse_args()
+
+    all_lines = load_hypotactic(args.hypotactic, all_files=True)
+    retained = [
+        row
+        for stem, lines in sorted(all_lines.items())
+        for line in lines
+        if (row := retained_line(stem, line)) is not None
+    ]
+    keys = [tuple(row["key"]) for row in retained]
+    if len(keys) != len(set(keys)):
+        raise ValueError("Hypotactic line keys are not unique")
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    completed = load_completed(args.output)
+    pending = [row for row in retained if tuple(row["key"]) not in completed]
+    print(
+        f"inventory retained={len(retained)} completed={len(completed)} "
+        f"pending={len(pending)} model={MODEL_ID}@{MODEL_REVISION}",
+        flush=True,
+    )
+    if not pending:
+        return
+
+    local = snapshot_download(
+        MODEL_ID, revision=MODEL_REVISION,
+        allow_patterns=["*.json", "*.txt", "*.py", "*.model", "*.safetensors"],
+    )
+    sys.path.insert(0, local)
+    from processing_char_bert_joint import CharBertJointProcessor
+
+    device = torch.device("cuda")
+    model = AutoModel.from_pretrained(
+        local, trust_remote_code=True, dtype=torch.bfloat16,
+    ).to(device).eval()
+    processor = CharBertJointProcessor.from_pretrained(local)
+    print(
+        f"loaded model device={device} dtype={next(model.parameters()).dtype} "
+        f"batch_size={args.batch_size}",
+        flush=True,
+    )
+
+    started = time.monotonic()
+    with args.output.open("a", encoding="utf-8", buffering=1) as handle:
+        for start in range(0, len(pending), args.batch_size):
+            items = pending[start:start + args.batch_size]
+            batch = processor([item["tokens"] for item in items])
+            model_batch = {
+                key: value.to(device, non_blocking=True)
+                for key, value in batch.items() if not key.startswith("_")
+            }
+            with torch.inference_mode():
+                output = model(**model_batch)
+            decoded = processor.decode(output, batch, ud=True)
+            if len(decoded) != len(items):
+                raise RuntimeError("Stoicheia returned the wrong batch cardinality")
+            for item, words in zip(items, decoded):
+                result = {
+                    **{key: item[key] for key in ("key", "author", "work", "work_id", "text")},
+                    "conllu": encode_conllu(item["text"], item["tokens"], words),
+                    "model": MODEL_ID,
+                    "model_revision": MODEL_REVISION,
+                }
+                handle.write(json.dumps(result, ensure_ascii=False, sort_keys=True) + "\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+            done = start + len(items)
+            if done == len(pending) or done % args.log_every < args.batch_size:
+                elapsed = time.monotonic() - started
+                rate = done / elapsed if elapsed else 0
+                print(
+                    f"progress new={done}/{len(pending)} total={len(completed) + done}/"
+                    f"{len(retained)} rate={rate:.1f}_lines_s elapsed={elapsed:.1f}s",
+                    flush=True,
+                )
+
+
+if __name__ == "__main__":
+    main()

slurm/rebuild_dataset.slurm

@@ -19,6 +19,7 @@ repo=/nobackup/proj/flash/dionysus/personal/cleland/sphragis
 metre_repo=/nobackup/proj/flash/dionysus/personal/cleland/sphragis-metre
 sources=/nobackup/proj/flash/dionysus/personal/cleland/.sphregis-investigation.VmoHEE
 python=/nobackup/proj/flash/dionysus/personal/cleland/.venv-sphregis-build-gpu/bin/python
+stoicheia_conllu="${repo}/.stoicheia-cache/hypotactic_conllu.jsonl"
 stage="${repo}/.build-stage-${SLURM_JOB_ID}"
 backup="${repo}/.build-backup-${SLURM_JOB_ID}"
 metre_stage="${metre_repo}/.build-stage-${SLURM_JOB_ID}"
@@ -29,12 +30,14 @@ echo "[$(date --iso-8601=seconds)] host=$(hostname) job=${SLURM_JOB_ID} stage=${
 test -x "$python"
 test -d "$sources"
 test -d "$metre_repo/.git"
+test -s "$stoicheia_conllu"
 mkdir -p "$stage" "$backup" "$metre_stage" "$metre_backup"
 
 echo "[$(date --iso-8601=seconds)] rebuilding all configurations from pinned sources"
 srun --kill-on-bad-exit=1 "$python" -u scripts/build_dataset.py \
   --sources "$sources" --output "$stage/data" --metadata "$stage/metadata" \
-  --metre-output "$metre_stage/data" --metre-metadata "$metre_stage/metadata"
+  --metre-output "$metre_stage/data" --metre-metadata "$metre_stage/metadata" \
+  --stoicheia-conllu "$stoicheia_conllu"
 
 echo "[$(date --iso-8601=seconds)] independently validating both staged publications"
 srun --kill-on-bad-exit=1 "$python" -u scripts/validate_publication.py \

slurm/stoicheia_parse_hypotactic.slurm

@@ -0,0 +1,47 @@
+#!/bin/bash
+#SBATCH --job-name=sphragis-stoicheia
+#SBATCH --account=naiss2026-3-353-gpu
+#SBATCH --partition=gpu
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=16
+#SBATCH --gpus=1
+#SBATCH --mem=128G
+#SBATCH --time=12:00:00
+#SBATCH --output=/nobackup/proj/flash/dionysus/personal/cleland/sphragis/.logs/%x-%j.out
+#SBATCH --error=/nobackup/proj/flash/dionysus/personal/cleland/sphragis/.logs/%x-%j.err
+
+set -Eeuo pipefail
+trap 'status=$?; echo "[$(date --iso-8601=seconds)] FATAL line=${LINENO} command=${BASH_COMMAND} status=${status}" >&2; exit "$status"' ERR
+source /nobackup/proj/flash/dionysus/personal/cleland/sphragis/slurm/date_logs.sh
+
+repo=/nobackup/proj/flash/dionysus/personal/cleland/sphragis
+sources=/nobackup/proj/flash/dionysus/personal/cleland/.sphregis-investigation.VmoHEE
+python=/nobackup/proj/flash/dionysus/personal/cleland/sphragis_models/.venv/bin/python
+output="$repo/.stoicheia-cache/hypotactic_conllu.jsonl"
+export HF_HOME="${SNIC_TMP}/sphragis-stoicheia-hf"
+export PYTHONUNBUFFERED=1
+
+cd "$repo"
+echo "[$(date --iso-8601=seconds)] host=$(hostname) job=${SLURM_JOB_ID} starting Stoicheia parsing"
+echo "[$(date --iso-8601=seconds)] gpu=$(nvidia-smi --query-gpu=name,memory.total --format=csv,noheader)"
+test -x "$python"
+mkdir -p "$(dirname "$output")" "$HF_HOME"
+df -h "$SNIC_TMP"
+
+if ! "$python" -c 'import torch, transformers, huggingface_hub, safetensors, edlib, pyarrow' 2>/dev/null; then
+  echo "[$(date --iso-8601=seconds)] installing pinned Stoicheia inference requirements"
+  "$python" -m pip install --disable-pip-version-check \
+    -r requirements-build.txt -r requirements-stoicheia.txt
+fi
+"$python" - <<'PY'
+import torch, transformers
+print(f"runtime torch={torch.__version__} transformers={transformers.__version__} cuda={torch.cuda.is_available()}", flush=True)
+assert torch.cuda.is_available()
+PY
+
+srun --kill-on-bad-exit=1 "$python" -u scripts/stoicheia_parse_hypotactic.py \
+  --hypotactic "$sources/hypotactic" --output "$output" \
+  --batch-size 64 --log-every 1024
+
+echo "[$(date --iso-8601=seconds)] completed lines=$(wc -l < "$output") bytes=$(stat -c %s "$output")"

tests/test_split_stratification.py

@@ -160,6 +160,35 @@ def test_metre_chunks_concatenate_every_constituent_syllable() -> None:
                 ]
 
 
+def test_metre_syntax_origin_is_explicit_and_provenance_matches() -> None:
+    atomic_origins = set()
+    for split in SPLITS:
+        rows = pq.read_table(
+            config_path(METRE_ROOT, "verse_metre", 1, split),
+            columns=["syntax_annotation", "treebank_source", "source_records"],
+        ).to_pylist()
+        for row in rows:
+            origin = row["syntax_annotation"]
+            atomic_origins.add(origin)
+            sources = {record["source"] for record in json.loads(row["source_records"])}
+            assert "hypotactic" in sources
+            if origin == "predicted":
+                assert row["treebank_source"] == "stoicheia_tagger_parser"
+                assert "stoicheia_tagger_parser" in sources
+            else:
+                assert origin == "gold"
+                assert "stoicheia_tagger_parser" not in sources
+    assert atomic_origins == {"gold", "predicted"}
+
+    for suffix in (10, 100):
+        for split in SPLITS:
+            origins = set(pq.read_table(
+                config_path(METRE_ROOT, "verse_metre", suffix, split),
+                columns=["syntax_annotation"],
+            )["syntax_annotation"].to_pylist())
+            assert origins <= {"gold", "predicted", "mixed"}
+
+
 def test_scansion_is_not_published() -> None:
     for suffix in (1, 10, 100):
         for split in SPLITS: