Datasets:

Urdatorn
/

sphragis

"""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"
            )

	"""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"
	)