scripts/model_facing.py

"""Produce the scheme-neutral, identifier-free CoNLL-U that models are given.

Sphragis draws on seven annotation projects whose author inventories do not
overlap. Every convention that separates those projects therefore separates
authors as well, and a model can score highly by recognizing the annotator
instead of the writer. This module reduces every published tree to one shared
representation and lifts the project-specific material into a separate audit
column.

The transformation, in order:

* editorial punctuation tokens are removed and the tree is re-indexed, because
  UD PROIEL does not tokenize punctuation at all and its absence alone
  identifies its single author;
* word forms and lemmas are lowercased with ``grc_utils.lower_grc``, because
  capitalization marks sentence openings and proper nouns inconsistently
  across projects and editions;
* XPOS, UPOS, FEATS and DEPREL are collapsed onto the shared inventories in
  :mod:`syntax_normalization`;
* MISC is cleared, because ``NativeRel``/``NativeHead``/``HeadRepair`` mark the
  natively converted projects on every token and ``SpaceAfter`` marks UD
  Perseus alone;
* the ``# text`` comment is dropped, because the ``text`` column already
  carries it.

Everything removed from MISC is returned as a compact ``native_syntax``
record so the original annotation stays auditable and remappable.
"""

from __future__ import annotations

import re
import unicodedata

from grc_utils import lower_grc, vowel

try:
    from scripts.syntax_normalization import (
        CORE_XPOS_POS,
        CORE_XPOS_TO_UPOS,
        canonical_feats,
        core_deprel,
        core_feats,
        core_upos,
        core_xpos,
        is_editorial_punctuation,
        normalize_cc_heads,
        punctuationless_tokens,
    )
except ModuleNotFoundError:  # Direct execution from the scripts directory.
    from syntax_normalization import (
        CORE_XPOS_POS,
        CORE_XPOS_TO_UPOS,
        canonical_feats,
        core_deprel,
        core_feats,
        core_upos,
        core_xpos,
        is_editorial_punctuation,
        normalize_cc_heads,
        punctuationless_tokens,
    )


TOKEN_ID = re.compile(r"\d+")
TOKEN_FIELDS = frozenset(
    ("id", "form", "lemma", "upos", "feats", "head", "deprel")
)
AUDIT_MISC_KEYS = ("NativeRel", "NativeHead", "HeadRepair", "HeadConverted")


# Elision is written differently by every project, and the difference alone
# identifies the source. AGDT and UD Perseus mark it with a trailing combining
# comma (δ̓, ἀλλ̓); Gorman uses three different apostrophe characters in the same
# corpus (᾽, ʼ, ’); Pedalion and PROIEL use ’. Stripping the mark leaves the
# same truncated word form everywhere, which is the only scheme-neutral choice.
SMOOTH_BREATHING = "\u0313"
ROUGH_BREATHING = "\u0314"
KORONIS = "\u0343"
ELISION_MARKS = frozenset((SMOOTH_BREATHING, ROUGH_BREATHING, KORONIS))
RHO = "\u03c1"


def strip_elision(value: str) -> str:
    """Remove a word-final elision mark written as a combining breathing.

    A breathing on a vowel is ordinary orthography (ὁ, οὐ, εἰ), so only a
    trailing mark whose base letter is a consonant can be an elision. Rho is
    the one consonant that carries a breathing in its own right: the rough
    breathing of ῥ is kept, while a smooth breathing on rho is the elision
    convention (ἄῤ for ἄρα). Elided ῥα appears as ῥ̓ in some sources and as ῤ̓
    in others, so marks are removed to a fixed point rather than one at a
    time: ῥ̓ keeps the rough breathing rho is entitled to, while ῤ̓ loses both.
    Reaching a fixed point is what makes this idempotent, which
    check_model_facing_conllu relies on to verify every published form.
    """
    decomposed = unicodedata.normalize("NFD", value)
    while len(decomposed) > 1 and decomposed[-1] in ELISION_MARKS:
        base = next(
            (
                character for character in reversed(decomposed[:-1])
                if not unicodedata.combining(character)
            ),
            None,
        )
        elided = base is not None and not vowel(base) and not (
            base == RHO and decomposed[-1] == ROUGH_BREATHING
        )
        if not elided:
            break
        decomposed = decomposed[:-1]
    return unicodedata.normalize("NFC", decomposed)


def normalize_form(value: str) -> str:
    """Return a word form or lemma in the shared orthography.

    Order matters. Bracketed and hyphenated forms go first, so that an elision
    mark inside them ([τ̓]) is word-final by the time it is looked for, and NFC
    goes last, because lowercasing a capital that has no precomposed polytonic
    form (Ρ̓ῶμε) leaves a decomposed string that would not compare equal to its
    own normalization.
    """
    if not value or value == "_":
        # A source project that gives no lemma writes "" or "_"; both are
        # published as the CoNLL-U placeholder.
        return "_"
    cleaned = "".join(punctuationless_tokens(value))
    if not cleaned:
        # Only a lemma can get here (forms without a Greek letter are dropped
        # as tokens); an all-apparatus lemma such as ?? or ... is unknown.
        return "_"
    return unicodedata.normalize("NFC", lower_greek(strip_elision(cleaned)))


def lower_greek(value: str) -> str:
    """Lowercase Greek without disturbing ``_`` placeholders or markup.

    ``grc_utils.lower_grc`` handles the precomposed polytonic letters, which
    ``str.lower`` gets wrong; it does not cover a handful of bare capitals
    (Ι, Ρ, Ά) or the stray Latin letters a few source files contain, so those
    fall back to ``str.lower`` character by character.
    """
    if not value or value == "_":
        return value
    return "".join(
        character if not character.isupper() else character.lower()
        for character in lower_grc(value)
    )


GREEK_LETTER = re.compile(r"[\u0370-\u03ff\u1f00-\u1fff]")


def is_word_token(form: str) -> bool:
    """A published token must contain a Greek letter.

    A letter, not merely a code point of the Greek blocks: the spacing
    breathings and accents (῾, ᾿, ´) live in the same block and are symbols.

    Everything else is editorial apparatus that survived upstream tokenisation:
    Pedalion's ``g`` gap markers, fragment numbers, backtick quotation marks,
    which Unicode files as a modifier symbol rather than punctuation, and a
    combining elision mark that was tokenised on its own. None of it is the
    author's Greek, and every one of them identifies a source file.
    """
    # The archaic numeral letters (stigma, digamma, koppa, sampi) count as
    # letters here; a sentence that contains one is excluded as unrepresentable
    # by tracks.remove_unrepresentable_rows, and the span and crop reductions
    # (tracks.normalize, syntax_text_normalize) give them no extent.
    return any(
        GREEK_LETTER.match(character) and unicodedata.category(character).startswith("L")
        for character in unicodedata.normalize("NFC", form)
    )


def is_punctuation_token(form: str) -> bool:
    """Decide from the form alone whether a token is editorial punctuation.

    The tag is deliberately not consulted. Some upstream trees have their tag
    column offset against their forms, so that real words carry ``PUNCT`` and
    the commas beside them carry word tags; trusting the tag there deletes the
    words and keeps the commas. A form without a Greek letter is punctuation or
    apparatus whatever it was tagged.
    """
    return not is_word_token(form)


def punctuationless_text(text: str) -> str:
    """Return a text unit in the same orthography as its CoNLL-U forms."""
    cleaned = "".join(
        " " if is_editorial_punctuation(character) else character
        for character in text
    )
    return " ".join(
        strip_elision(word) for word in cleaned.split() if is_word_token(word)
    )


def _rows(conllu: str) -> list[list[str]]:
    rows = []
    for line in conllu.splitlines():
        if not line or line.startswith("#"):
            continue
        columns = line.split("\t")
        if len(columns) != 10:
            raise ValueError(f"CoNLL-U line does not have ten columns: {line!r}")
        if not TOKEN_ID.fullmatch(columns[0]):
            raise ValueError(
                f"published CoNLL-U must contain only integer token rows: {columns[0]!r}"
            )
        rows.append(columns)
    if not rows:
        raise ValueError("cannot finalize an empty CoNLL-U document")
    return rows


def _native_record(index: int, source_id: int, misc: str) -> dict | None:
    """Lift one token's source annotation out of MISC.

    ``token`` indexes the published token; ``source_token`` and ``head`` are
    the source document's own numbering, which ``NativeHead`` refers to.
    """
    if not misc or misc == "_":
        return None
    values = {}
    for item in misc.split("|"):
        key, _, value = item.partition("=")
        if key in AUDIT_MISC_KEYS:
            values[key] = value
    if not values:
        return None
    return {
        "token": index,
        "source_token": source_id,
        "relation": values.get("NativeRel"),
        "head": values.get("NativeHead"),
        "head_repair": values.get("HeadRepair") == "Yes",
        # The Prague-style native head was rewritten to the UD convention.
        "head_converted": values.get("HeadConverted") == "Yes",
    }


def finalize_conllu(conllu: str) -> tuple[list[dict], list[dict]]:
    """Return one sentence as published tokens, plus its audit records.

    Punctuation tokens are dropped and every dependent that hung from one is
    re-attached to that token's nearest surviving ancestor, so the result is
    still a single connected tree.
    """
    rows = _rows(conllu)
    by_id = {int(row[0]): row for row in rows}
    dropped = {int(row[0]) for row in rows if is_punctuation_token(row[1])}
    kept = [row for row in rows if int(row[0]) not in dropped]
    if not kept:
        raise ValueError("removing punctuation left no tokens")

    kept_ids = {int(row[0]) for row in kept}

    def surviving_ancestor(token_id: int) -> int:
        head = int(by_id[token_id][6])
        seen = {token_id}
        while head and head not in kept_ids:
            if head in seen or head not in by_id:
                return 0
            seen.add(head)
            head = int(by_id[head][6])
        return head

    resolved = {int(row[0]): surviving_ancestor(int(row[0])) for row in kept}
    # Coordinators hang on the conjunct that follows them in every project;
    # UD Perseus alone put them on the first conjunct, and that named it.
    kept_ids_in_order = [int(row[0]) for row in kept]
    resolved = dict(zip(kept_ids_in_order, normalize_cc_heads(
        kept_ids_in_order,
        [resolved[token_id] for token_id in kept_ids_in_order],
        [row[7] for row in kept],
    )))
    roots = [token_id for token_id, head in resolved.items() if head == 0]
    primary_root = roots[0] if roots else int(kept[0][0])
    id_map = {int(row[0]): new_id for new_id, row in enumerate(kept, 1)}

    native: list[dict] = []
    output: list[dict] = []
    for row in kept:
        old_id = int(row[0])
        record = _native_record(id_map[old_id], old_id, row[9])
        if record is not None:
            native.append(record)

        head = resolved[old_id]
        if old_id == primary_root:
            new_head, relation = 0, "root"
        else:
            # A source tree with more than one root, or one whose root was the
            # punctuation token just removed, still has to publish exactly one.
            new_head = id_map[head] if head else id_map[primary_root]
            relation = core_deprel(row[7])
            if relation in {"root", "punct"}:
                relation = "dep"

        xpos = core_xpos(row[4])
        if xpos[0] == "u":
            # A surviving token tagged as punctuation comes from a tree whose
            # tag column is offset; its real part of speech is unknown.
            xpos = "x" + xpos[1:]
        # XPOS is folded into FEATS here and not published: the two carried
        # different distinctions and had already drifted apart.
        feats = canonical_feats(xpos, row[5])
        output.append({
            "id": id_map[old_id],
            "form": normalize_form(row[1]),
            "lemma": normalize_form(row[2]),
            "upos": core_upos(xpos),
            "feats": None if feats == "_" else feats,
            "head": new_head,
            "deprel": relation,
        })
    return output, native


def source_conllu_blocks(unit: str) -> list[str]:
    """Split a source CoNLL-U unit into its sentence blocks."""
    return [block for block in unit.split("\n\n") if block.strip()]


def finalize_conllu_unit(unit: str) -> tuple[list[list[dict]], list[dict]]:
    """Finalize every sentence in one source CoNLL-U unit.

    A Sphragis Metre line can span a sentence boundary, in which case its unit
    holds two or more blocks, each numbered from 1. They must be finalized
    separately: merging them would collide their token ids, point heads across
    a sentence boundary and leave the unit with more than one root. Every audit
    record carries ``sentence``, so that ``token`` stays unambiguous.
    """
    blocks = source_conllu_blocks(unit)
    if not blocks:
        raise ValueError("cannot finalize an empty CoNLL-U unit")
    sentences = []
    native: list[dict] = []
    for index, block in enumerate(blocks):
        tokens, block_native = finalize_conllu(block)
        sentences.append(tokens)
        native.extend({**record, "sentence": index} for record in block_native)
    return sentences, native


CORE_UPOS = frozenset(CORE_XPOS_TO_UPOS.values()) - {"PUNCT"}


def check_model_facing_conllu(unit: list[list[dict]], where: str) -> None:
    """Assert every invariant the model-facing representation guarantees.

    Each of these removes a channel through which the annotating project, and
    therefore the author, could be recognized without reading the Greek.
    """
    assert unit, f"{where}: CoNLL-U unit contains no sentence"
    for index, sentence in enumerate(unit):
        _check_sentence(sentence, f"{where}, sentence {index}")


def _check_sentence(sentence: list[dict], where: str) -> None:
    assert sentence, f"{where}: sentence contains no token"
    ids = [token["id"] for token in sentence]
    assert ids == list(range(1, len(ids) + 1)), f"{where}: token ids are not contiguous"
    heads = [token["head"] for token in sentence]
    assert heads.count(0) == 1, f"{where}: expected exactly one root, got {heads.count(0)}"
    for token in sentence:
        assert set(token) == TOKEN_FIELDS, f"{where}: unexpected token fields {set(token)}"
        assert token["head"] in range(0, len(ids) + 1), (
            f"{where}: head {token['head']} is outside the sentence"
        )
        upos, deprel = token["upos"], token["deprel"]
        assert upos in CORE_UPOS, f"{where}: UPOS {upos!r} is outside the shared inventory"
        assert upos != "PUNCT", f"{where}: punctuation tokens are not published"
        assert core_deprel(deprel) == deprel and deprel != "punct", (
            f"{where}: DEPREL {deprel!r} is outside the shared inventory"
        )
        feats = token["feats"]
        assert feats is None or (feats != "_" and core_feats(feats) == feats), (
            f"{where}: FEATS {feats!r} is outside the shared inventory"
        )
        for name in ("form", "lemma"):
            value = token[name]
            if value == "_":
                continue
            assert value == normalize_form(value), (
                f"{where}: {name} {value!r} is not in the shared orthography"
            )