| """Texts the teacher adds in the panel: a story or a dialogue, practised line by line like the course's conversation. |
| |
| The teacher gives each line twice: in Hebrew, and in Arabic written in Hebrew letters, as the course writes it |
| (pointed, geresh for the sounds Hebrew lacks, ّ for doubling: כִּיף חַאלַכּ). The scorer needs the line's phonemes |
| and the answer's voice needs it in Arabic letters, so each word is read here: |
| a word of the course (LEX in workbook.py), found by its transliteration, gets the course's own Arabic spelling and |
| accepted pronunciations. Dagesh, shva and the final letters' forms are not compared, and a word written without |
| points is found by its letters alone; |
| any other word is read by rule, letter by letter (`_guess`). Short vowels come from the points, so an unpointed |
| word that the course does not have is read badly. Such words are reported back to the teacher (`guessed`). |
| """ |
| from __future__ import annotations |
|
|
| import re |
|
|
| from .workbook import LEX, _variants |
|
|
| SHVA, DAGESH, SHADDA = "\u05b0", "\u05bc", "\u0651" |
| MARKS = re.compile("[\u05b0-\u05bc\u05c1\u05c2\u05c7\u0651]") |
| GERESH = "'\u05f3\u2019\u2018`\u00b4" |
| FINALS = {"ך": "כ", "ם": "מ", "ן": "נ", "ף": "פ", "ץ": "צ"} |
| VOWEL_OF = {"\u05b7": "a", "\u05b8": "a", "\u05b2": "a", "\u05b4": "i", "\u05bb": "u", "\u05b6": "e", "\u05b1": "e", |
| "\u05b5": "E", "\u05b9": "o", "\u05ba": "o", "\u05b3": "o", "\u05c7": "o"} |
| |
| CONS = {"א": ("ʔ", "ا"), "ב": ("b", "ب"), "ג": ("g", "ج"), "ד": ("d", "د"), "ה": ("h", "ه"), "ו": ("w", "و"), |
| "ז": ("z", "ز"), "ח": ("ħ", "ح"), "ט": ("tˤ", "ط"), "י": ("j", "ي"), "כ": ("k", "ك"), "ל": ("l", "ل"), |
| "מ": ("m", "م"), "נ": ("n", "ن"), "ס": ("s", "س"), "ע": ("ʕ", "ع"), "פ": ("f", "ف"), "צ": ("sˤ", "ص"), |
| "ק": ("ʔ", "ق"), "ר": ("r", "ر"), "ש": ("ʃ", "ش"), "ת": ("t", "ت")} |
| GERESHED = {"ג": ("dʒ", "ج"), "ח": ("x", "خ"), "ע": ("ɣ", "غ"), "ד": ("dˤ", "ض"), "ט": ("ðˤ", "ظ"), "ת": ("t", "ث"), |
| "ז": ("dʒ", "ج"), "צ": ("sˤ", "ص")} |
| PUNCT_AR = {"?": "؟", ",": "،", ";": "؛"} |
| Cluster = tuple[str, bool, str] |
|
|
|
|
| def _clusters(word: str) -> list[Cluster]: |
| """The word's letters, each with its geresh and points. A letter in brackets, the article's silent (ל), is left out.""" |
| out: list[list] = [] |
| for ch in re.sub(r"\([^)]*\)", "", word): |
| if "א" <= ch <= "ת": |
| out.append([FINALS.get(ch, ch), False, ""]) |
| elif out and ch in GERESH: |
| out[-1][1] = True |
| elif out and MARKS.fullmatch(ch): |
| out[-1][2] += ch |
| return [(l, g, m) for l, g, m in out] |
|
|
|
|
| def _key(cl: list[Cluster], points: bool = True) -> str: |
| """What two spellings of one word share: the letters and their vowels, without dagesh (but the vav's) and shva. |
| The article's vowel is one, hiriq or tsere.""" |
| def marks(k: int, letter: str, m: str) -> str: |
| keep = {"\u05b7" if c == "\u05b8" else c for c in m if c != SHVA and (c != DAGESH or letter == "ו")} |
| if k == 0 and letter == "א" and "\u05b4" in keep: |
| keep = keep - {"\u05b4"} | {"\u05b5"} |
| return "".join(sorted(keep)) |
| return "".join(l + "'" * g + (marks(k, l, m) if points else "") for k, (l, g, m) in enumerate(cl)) |
|
|
|
|
| def _lexicon() -> tuple[dict, dict]: |
| pointed, plain = {}, {} |
| for ar, (tr, ipas) in LEX.items(): |
| cl = _clusters(tr) |
| entry = (ar.partition("#")[0], ipas) |
| pointed.setdefault(_key(cl), entry) |
| plain.setdefault(_key(cl, False), entry) |
| return pointed, plain |
|
|
|
|
| POINTED, PLAIN = _lexicon() |
|
|
|
|
| def _guess(cl: list[Cluster], silent_l: bool = False) -> tuple[str, list[str]]: |
| """(Arabic spelling, readings) of a word the course does not have, from its letters and points. `silent_l`: the |
| word was written with the article's (ל), so its first vowel is the article.""" |
| phs: list[str] = [] |
| ar = "" |
| n, i = len(cl), 0 |
| bare = lambda c: not c[1] and not any(m in VOWEL_OF or m == SHADDA for m in c[2]) |
| pointed = any(m in VOWEL_OF for _, _, marks in cl for m in marks) |
| if n > 1 and cl[0][0] == "ו" and bare(cl[0]) and (DAGESH in cl[0][2] or SHVA in cl[0][2]): |
| phs, ar, i = ["u"], "و", 1 |
| start, prev = i, None |
| while i < n: |
| letter, geresh, marks = cl[i] |
| last, vowel = i == n - 1, next((VOWEL_OF[m] for m in marks if m in VOWEL_OF), None) |
| double = SHADDA in marks |
| i += 1 |
| if bare((letter, geresh, marks)) and i - 1 > start: |
| long = None |
| if letter == "א": |
| long, ar = ("a" if last else "aː"), ar + "ا" |
| if prev: |
| phs.pop() |
| elif letter == "י" and (prev in ("i", "E") or not prev and last or not pointed and not last): |
| long, ar = ("eː" if prev == "E" else "i" if last else "iː"), ar + "ي" |
| if prev: |
| phs.pop() |
| elif letter == "ו" and not prev and (DAGESH in marks or not pointed and not last): |
| long, ar = ("u" if last else "uː"), ar + "و" |
| elif letter == "ה" and last and (prev in ("a", "e", "E") or not pointed): |
| ar += "ة" |
| if not prev: |
| phs.append("a") |
| elif prev == "E": |
| phs[-1] = "e" |
| break |
| if long: |
| phs.append(long) |
| prev = None |
| continue |
| if letter == "ו" and DAGESH in marks and double and not vowel and not prev: |
| phs += ["u", "w", "w"] |
| ar, prev = ar + "وّ", None |
| continue |
| if letter == "ו" and vowel == "o" and not double and not prev and i - 1 > start: |
| phs.append("o" if last else "oː") |
| ar, prev = ar + "و", None |
| continue |
| ph, ar_letter = (GERESHED if geresh and letter in GERESHED else CONS)[letter] |
| if letter == "א" and i - 1 == start and vowel in ("i", "a", "E") and i < n and ( |
| cl[i][0] == "ל" and bare(cl[i]) and i + 1 < n or silent_l): |
| phs.append("i") |
| ar += "ال" |
| if cl[i][0] == "ל" and bare(cl[i]): |
| phs.append("l") |
| i += 1 |
| prev = None |
| continue |
| phs += [ph, ph] if double else [ph] |
| ar += ("ا" if i - 1 == start else "أ") if letter == "א" else ar_letter + (SHADDA if double else "") |
| prev = vowel |
| if vowel: |
| phs.append(("e" if last else "i") if vowel == "E" else vowel) |
| main = " ".join(phs) |
| return ar, [main] + ([main.replace("ʔ", "q") if not cl[start][0] == "א" else "ʔ" + main[1:].replace("ʔ", "q")] |
| if any(l == "ק" for l, _, _ in cl) else []) |
|
|
|
|
| def _word(token: str) -> tuple[str, list[str], bool] | None: |
| """(Arabic, readings, whether the course has the word) of one written word; None when it has no letters.""" |
| cl = _clusters(token) |
| if not cl: |
| return None |
| tail = "".join(PUNCT_AR.get(c, c) for c in re.search(r"[?!.,;:]*$", token)[0]) |
| pointed = any(m in VOWEL_OF for _, _, marks in cl for m in marks) |
| for cut, pre_ar, pre_ipa in ((0, "", ""), (1, "و", "u ")): |
| if cut and not (len(cl) > 1 and cl[0][0] == "ו" and not cl[0][1] and not any(m in VOWEL_OF for m in cl[0][2])): |
| break |
| hit = POINTED.get(_key(cl[cut:])) if pointed else PLAIN.get(_key(cl[cut:], False)) |
| if hit: |
| return pre_ar + hit[0] + tail, [pre_ipa + ipa for ipa in hit[1]], True |
| rest = cl[2:] if len(cl) > 2 and cl[0][0] == "א" and cl[1][0] == "ל" and not any(m in VOWEL_OF for m in cl[1][2]) else \ |
| cl[1:] if len(cl) > 1 and cl[0][0] == "א" and "(ל)" in token else None |
| hit = rest and (POINTED.get(_key(rest)) if pointed else PLAIN.get(_key(rest, False))) |
| if hit and not hit[0].startswith("ال"): |
| said = "i l " if rest is cl[2:] or len(rest) == len(cl) - 2 else "i " |
| double = lambda ipa: ipa if said == "i l " else f"{ipa.split()[0]} {ipa}" |
| return "ال" + hit[0] + tail, [said + double(ipa) for ipa in hit[1]], True |
| ar, ipas = _guess(cl, "(ל)" in token) |
| return (ar + tail, ipas, False) if ipas[0] else None |
|
|
|
|
| def read_line(tr: str) -> tuple[list[tuple[str, str, list[str]]], list[str]]: |
| """A line of Arabic in Hebrew letters as the words of a phrase, (Arabic, transliteration, readings) each, and |
| the words that were read by rule, as written.""" |
| words, guessed = [], [] |
| for token in tr.split(): |
| word = _word(token) |
| if word is None: |
| continue |
| ar, ipas, known = word |
| words.append((ar, token, ipas)) |
| if not known: |
| guessed.append(token.strip("?!.,;:\"()")) |
| return words, guessed |
|
|
|
|
| def text_phrases(cat: str, lines: list[list[str]]) -> tuple[list[dict], list[str]]: |
| """A text's lines ([Hebrew, transliteration] each) as phrases in the format of phrases.py, in the text's order, |
| and its words that were read by rule. `key` is what a recording of the line is kept under: the Hebrew, numbered |
| from its second appearance in the text ("כן (2)"), so that two lines with the same Hebrew stay apart.""" |
| out, guessed, seen = [], [], {} |
| for seq, (he, tr) in enumerate(lines, 1): |
| words, new = read_line(tr) |
| guessed += [w for w in new if w not in guessed] |
| seen[he] = seen.get(he, 0) + 1 |
| out.append(dict(cat=cat, he=he, tr=tr, variants=_variants(words), seq=seq, |
| key=he if seen[he] == 1 else f"{he} ({seen[he]})")) |
| return out, guessed |
|
|
