"""The data files: six varieties must describe the same stratum, in their own words.""" import json from pathlib import Path import pytest from lgstratum import canonical, decide, lexicon, segment ROOT = Path(__file__).resolve().parents[1] LANGS = lexicon.codes() def _raw(lang): return json.loads((ROOT / "lexicon" / ("%s.json" % lang)).read_text(encoding="utf-8")) def test_all_six_varieties_are_present_and_named(): assert sorted(LANGS) == ["ar", "en", "es", "hi", "it", "zh"] assert len(LANGS) == len(set(LANGS)) for lang in LANGS: assert lexicon.language_name(lang), lang def test_every_variety_carries_the_same_sections(): shapes = {lang: sorted(_raw(lang)) for lang in LANGS} first = shapes[LANGS[0]] for lang in LANGS[1:]: assert shapes[lang] == first, lang def test_every_variety_names_every_reading_state(): states = set(decide.CEILING) assert len(states) == 8 for lang in LANGS: assert set(lexicon.reading_labels(lang)) == states, lang def test_every_variety_translates_the_labels_the_reply_needs(): needed = {"status", "understood", "answer", "assurance", "notes", "math_layer", "check", "examples"} reference = sorted(lexicon.labels(LANGS[0])) for lang in LANGS: labels = lexicon.labels(lang) assert sorted(labels) == reference, lang assert needed <= set(labels), lang assert "{n}" in labels["assurance"], lang def test_every_variety_translates_every_reason(): reference = sorted(lexicon.reason_texts(LANGS[0])) assert len(reference) == 18 for lang in LANGS: assert sorted(lexicon.reason_texts(lang)) == reference, lang for key in reference: assert lexicon.translate_reason(lang, key).strip(), (lang, key) def test_every_variety_covers_the_same_kinds(): kinds = set(canonical.KINDS) for lang in LANGS: assert set(lexicon.patterns(lang)) <= kinds, lang assert set(lexicon.patterns(lang)), lang def _atoms(text): """The atoms of a shape, folded the way the two readers fold them when they scan a sentence.""" return [segment.fold(atom) for _kind, atom in segment.atomize(text)] def _consecutive(needle, hay): return any(hay[start:start + len(needle)] == needle for start in range(len(hay) - len(needle) + 1)) def test_every_pattern_is_announced_by_a_verb_of_its_own_kind(): # A shape that promises one operation must carry the word that names it: otherwise a reader # could match a frame whose operation it never heard announced. The comparison runs over the # folded atom sequences of the readers, because a written accent or a joined article is not a # different word, and a verb phrase may span several atoms. for lang in LANGS: verbs = lexicon.verbs(lang) for kind, shapes in lexicon.patterns(lang).items(): announced = [_atoms(phrase) for phrase, kinds in verbs.items() if kind in kinds] assert announced, "%s has no verb for %s" % (lang, kind) for shape in shapes: atoms = _atoms(shape) assert any(_consecutive(phrase, atoms) for phrase in announced), "%s %r" % (lang, shape) def test_words_written_inside_a_pattern_are_known_words(): # The filler of a frame may be a word of the variety -- the Italian frame for an inverse matrix # writes the word for matrix itself. A reader must know it, or it reports an unknown word in a # sentence that this bundle is supposed to read. for lang in LANGS: index = lexicon.phrase_index(lang) for word in lexicon.pattern_literals(lang): assert word in index, "%s writes %r in a pattern but does not know it" % (lang, word) def test_the_examples_of_each_variety_are_written_in_that_variety(): # The example lines show what the stratum can be asked; they are data, so they stay in the # language under study, and they must not be copies of another variety. for lang in LANGS: examples = _raw(lang).get("examples") or [] assert examples, lang for other in LANGS: if other == lang: continue assert set(examples).isdisjoint(set(_raw(other).get("examples") or [])), (lang, other) def test_the_reasons_of_all_varieties_ask_for_the_same_fillers(): # A reason template may name what it wants filled in -- the word, the kind, the detail -- but # those names are identifiers, not prose: every variety must ask for the same ones, so that the # renderer has one set of fields to supply and never leaves a brace in front of a reader. import re pattern = re.compile(r"\{([a-z_]+)\}") for key in lexicon.reason_texts(LANGS[0]): reference = set(pattern.findall(lexicon.reason_texts(LANGS[0])[key])) for lang in LANGS[1:]: assert set(pattern.findall(lexicon.reason_texts(lang)[key])) == reference, (lang, key)