Datasets:
Modalities:
Text
Formats:
json
Size:
< 1K
Tags:
multilingual
mathematical-word-problems
natural-language-to-formal-language
multi-agent-systems
benchmark
conversational-interfaces
Download tests/test_lexicon.py from tailot/math-stratum: direct link, hf CLI and curl.
- Browser
- Download file 4.94 kB
-
https://huggingface.co/datasets/tailot/math-stratum/resolve/main/tests/test_lexicon.py
- Command line
-
hf download hf://datasets/tailot/math-stratum/tests/test_lexicon.py
-
curl -L -o test_lexicon.py https://huggingface.co/datasets/tailot/math-stratum/resolve/main/tests/test_lexicon.py
4.94 kB
| """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) | |