| """Amharic gemination from HornMorpho analyses. |
| |
| Amharic gemination (consonant doubling) changes meaning but is not written in |
| Ge'ez script. HornMorpho (Michael Gasser, https://github.com/hltdi/HornMorpho) |
| computes it while analysing a word, and keeps it in the `seg` field if and only |
| if you call |
| |
| hm.anal('a', word, degem=False) |
| |
| With the default degem=True the marks are stripped. With degem=False, the |
| character `/` stands immediately before every geminated character of the |
| morphemic segmentation, whatever caused the doubling: the root template, the |
| passive/reciprocal prefix t- assimilating to the first root consonant, a |
| suffix such as the auxiliary -all, a lexicon entry, or reduplication. |
| |
| Example segs (degem=False): |
| |
| ይገኛል passive imperfect ----ይ</ገ/ኝ>---ኣ/ል--- ገ (t- prefix), ኛ (root), ል (suffix) |
| ክልል noun -<ክ/ልል>------ ል (lexicon) |
| የሚገኙ relative የ--/ም--ይ</ገ/ኝ>ኡ------ ሚ (prefix), ገ (t- prefix), ኙ (root) |
| |
| The seg is morphemic, not a copy of the surface word: vowels merge across |
| morpheme boundaries (ቀም + ኣል gives ቀማል), palatalisation changes letters |
| (ን + ኢ gives ኝ), and the glottal letter of a vowel-initial suffix disappears. |
| This module therefore aligns the seg letters to the surface word by consonant |
| series and moves each `/` to the surface character it aligned with. |
| |
| Do not read gemination from the `+gemN` feature instead. It only describes the |
| root template, so it misses every geminate created by a prefix or suffix, and |
| in reduplicated stems N counts template slots, not root consonants. |
| |
| Usage: |
| python gemination.py ይገኛል ክልል መለወጥ (needs HornMorpho, see INSTALL.md) |
| |
| >>> from gemination import reading_gemination |
| >>> reading_gemination("ይገኛል", {"seg": "----ይ</ገ/ኝ>---ኣ/ል---"})["pos"] |
| [1, 2] |
| |
| Positions are 0-based indices into the word's Unicode characters (one Ge'ez |
| fidel per index). |
| |
| Lexicon v3 rules (on by default; pass rules=False for the v2 behaviour). Each |
| is backed by more than one independent source, see the dataset card: |
| causative_glottal a causative prefix ስ- or ስተ- on a glottal-initial root |
| holds the next root consonant (ማሳደ፟ግ, አስታው፟ስ); |
| HornMorpho leaves it out of many segs |
| relative_m_light the relative prefix's ም before a subject prefix |
| (የሚ-, እንደሚ-, በሚ-, የምን-, የማይ-) is not held |
| relative_exist with relative የ-, the reading of አለ "exist" (ለ held) |
| is ranked above አለ "say" (ያለው, ያሉት) |
| """ |
| import difflib |
| import re |
| import sys |
|
|
| GEM_PRE = "/" |
| GEM_MARK = "፟" |
| BOUNDARY = set("-<>") |
| GEEZ = re.compile(r"[ሀ-]") |
| GLOTTAL = {(0x12A0 - 0x1200) // 8, (0x12D0 - 0x1200) // 8} |
| |
| PALATAL = {"ሽ": "ስ", "ች": "ት", "ጭ": "ጥ", "ኝ": "ን", "ዥ": "ዝ", "ጅ": "ድ", "ይ": "ል"} |
| |
| HOMOPHONE = {"ሥ": "ስ", "ሕ": "ህ", "ኅ": "ህ", "ፅ": "ጽ", "ኽ": "ህ"} |
| |
| LABIAL_SERIES = {0x1248: 0x1240, 0x12B0: 0x12A8, 0x1310: 0x1308, 0x1288: 0x1280, 0x12C0: 0x12B8} |
|
|
| SOURCES = ("root", "t-prefix", "prefix", "suffix", "lexicon", "reduplication") |
|
|
|
|
| def series(ch): |
| return (ord(ch) - 0x1200) // 8 |
|
|
|
|
| def _key(ch): |
| """Alignment key: consonant series, with labialised, homophone and palatal |
| spellings folded to their base and both glottal series merged.""" |
| base = 0x1200 + series(ch) * 8 |
| base = LABIAL_SERIES.get(base, base) |
| sixth = chr(base + 5) |
| sixth = HOMOPHONE.get(sixth, sixth) |
| sixth = PALATAL.get(sixth, sixth) |
| s = series(sixth) |
| return "G" if s in GLOTTAL else s |
|
|
|
|
| def parse_seg(seg): |
| """Seg string -> list of (char, geminated, region, source) for its Ge'ez |
| characters. region: 'pre' before '<', 'stem' inside <...>, 'suf' after '>'. |
| |
| source (only for geminated characters) is inferred from the seg alone: |
| prefix '/' before '<' (for example the relative yä-m- in የሚ) |
| suffix '/' after '>' (the auxiliary -all, plural -očč, -nna) |
| t-prefix '/' opens the stem ('</X'), sits on a boundary ('/-X'), |
| or doubles an unassimilated ተ- ('/ተ-'): the passive or |
| reciprocal t- merging into the next consonant |
| lexicon stem without internal boundaries in a noun-shaped seg: an |
| unanalysed dictionary entry that stores the gemination |
| reduplication the same consonant series occurs earlier in the same |
| morpheme (frequentative stems such as ገለባ/በጥ). Roots |
| whose second half repeats the first (ግልግል, ስብስብ) also |
| land here. |
| root any other stem geminate: the root's template |
| """ |
| stem = seg[seg.find("<") + 1:seg.find(">")] if "<" in seg and ">" in seg else "" |
| lexical = "<" in seg and "-" not in stem and seg[:seg.find("<")].count("-") <= 2 |
| out, pending, opens, region, last, morph = [], False, False, "pre", "", [] |
| for i, ch in enumerate(seg): |
| if ch == GEM_PRE: |
| pending = True |
| nxt = seg[i + 1:i + 3] |
| opens = last == "<" or nxt[:1] == "-" or nxt == "ተ-" |
| elif ch == "<": |
| region, morph = "stem", [] |
| elif ch == ">": |
| region = "suf" |
| elif ch == "-": |
| if region == "stem": |
| morph = [] |
| elif GEEZ.match(ch): |
| src = None |
| if pending: |
| if region == "pre": |
| src = "prefix" |
| elif region == "suf": |
| src = "suffix" |
| elif opens: |
| src = "t-prefix" |
| elif lexical: |
| src = "lexicon" |
| elif series(ch) in {series(c) for c in morph}: |
| src = "reduplication" |
| else: |
| src = "root" |
| out.append((ch, pending, region, src)) |
| if region == "stem": |
| morph.append(ch) |
| pending = opens = False |
| if ch != "-": |
| last = ch |
| return out |
|
|
|
|
| def seg_to_positions(word, seg): |
| """-> ([(surface index, region, source)], ok). ok is False when a geminated |
| seg character could not be aligned to the surface word.""" |
| segc = parse_seg(seg) |
| a = [_key(c) for c, _, _, _ in segc] |
| b = [_key(c) for c in word] |
| sm = difflib.SequenceMatcher(None, a, b, autojunk=False) |
| m = {} |
| for tag, i1, i2, j1, j2 in sm.get_opcodes(): |
| if tag == "equal" or (tag == "replace" and i2 - i1 == j2 - j1): |
| for k in range(i2 - i1): |
| m[i1 + k] = j1 + k |
| pos, ok = {}, True |
| for i, (_, gem, region, src) in enumerate(segc): |
| if not gem: |
| continue |
| if i in m: |
| pos.setdefault(m[i], (region, src)) |
| else: |
| ok = False |
| return sorted((p, r, s) for p, (r, s) in pos.items()), ok |
|
|
|
|
| CAUSATIVE_GLOTTAL = re.compile(r"(ስተ?-ኣ)([ሀ-])") |
| RELATIVE_M = re.compile(r"/ም(?=-+(?:ይ|እን|ት|ኣ))") |
|
|
|
|
| def apply_rules(seg): |
| """Apply the v3 seg rules. -> (new seg, names of the rules that fired).""" |
| if not seg: |
| return seg, [] |
| fired = [] |
| new = CAUSATIVE_GLOTTAL.sub(r"\1/\2", seg) |
| if new != seg: |
| fired.append("causative_glottal") |
| if "<" in new: |
| pre, rest = new.split("<", 1) |
| light = RELATIVE_M.sub("ም", pre) |
| if light != pre: |
| fired.append("relative_m_light") |
| new = light + "<" + rest |
| return new, fired |
|
|
|
|
| def relative_exist_first(word, patterns): |
| """v3: with relative የ-, put the existence reading of አለ (ለ held) first. |
| Bare ያለ is left alone: it can also be privative 'without', which holds nothing.""" |
| if word == "ያለ": |
| return patterns |
| for i, p in enumerate(patterns): |
| if any("<ኣ/ለ>" in s and s.split("<")[0].replace("-", "") == "የ" for s in p["segs"]): |
| if i: |
| p["rules"] = sorted(set(p.get("rules", [])) | {"relative_exist"}) |
| patterns = [p] + patterns[:i] + patterns[i + 1:] |
| return patterns |
| return patterns |
|
|
|
|
| def native_first(word, patterns, taps): |
| """Put a native speaker's tapped positions first. taps: word -> positions.""" |
| if word not in taps: |
| return patterns |
| pos = sorted(taps[word]) |
| for i, p in enumerate(patterns): |
| if p["pos"] == pos: |
| p["native"] = True |
| return [p] + patterns[:i] + patterns[i + 1:] |
| return [{"pos": pos, "letters": [word[k] for k in pos], "sources": ["native"] * len(pos), "freq": None, |
| "pos_tags": [], "ok": True, "segs": [], "rules": [], "native": True}] + patterns |
|
|
|
|
| def reading_gemination(word, reading, final="suffix", rules=True): |
| """Geminated surface positions for one HornMorpho reading (a dict with a |
| 'seg' from hm.anal(..., degem=False)). |
| |
| final: what to do with a geminate on the last character. |
| "suffix" (default) drop it only if it comes from a suffix and the last |
| letter is sixth order, so no vowel follows. In practice this is |
| the auxiliary -all of ይገኛል: it is not audible before a pause |
| and Armbruster never marks it. Vowel-final suffixes (-allu) and |
| stem-final geminates (ይሰ፟ጥ፟) are kept. |
| "keep" keep every geminate. |
| "drop" drop any word-final geminate. |
| """ |
| seg = reading.get("seg") or "" |
| used, fired = apply_rules(seg) if rules else (seg, []) |
| items, ok = seg_to_positions(word, used) |
| last = len(word) - 1 |
| if final == "suffix" and word: |
| sixth = (ord(word[last]) - 0x1200) % 8 == 5 |
| items = [x for x in items if not (x[0] == last and x[1] == "suf" and sixth)] |
| elif final == "drop": |
| items = [x for x in items if x[0] != last] |
| return {"pos": [p for p, _, _ in items], "letters": [word[p] for p, _, _ in items], |
| "sources": [s for _, _, s in items], "ok": ok, "seg": seg, "rules": fired} |
|
|
|
|
| def word_gemination(word, readings, final="suffix", rules=True): |
| """Distinct gemination patterns over all readings of a word, most frequent |
| root first (HornMorpho's 'freq'). Readings that differ only in grammar but |
| geminate the same positions share one pattern.""" |
| pats = {} |
| for r in readings: |
| g = reading_gemination(word, r, final, rules) |
| f = r.get("freq") or 0 |
| e = pats.get(tuple(g["pos"])) |
| if e is None: |
| e = pats[tuple(g["pos"])] = {"pos": g["pos"], "letters": g["letters"], "sources": g["sources"], |
| "freq": f, "pos_tags": set(), "ok": True, "segs": [], "rules": set()} |
| elif f > e["freq"]: |
| e["freq"], e["sources"] = f, g["sources"] |
| e["pos_tags"].add(str(r.get("pos"))) |
| e["segs"].append(g["seg"]) |
| e["ok"] = e["ok"] and g["ok"] |
| e["rules"].update(g["rules"]) |
| out = sorted(pats.values(), key=lambda e: -e["freq"]) |
| for e in out: |
| e["pos_tags"], e["rules"] = sorted(e["pos_tags"]), sorted(e["rules"]) |
| return relative_exist_first(word, out) if rules else out |
|
|
|
|
| def mark(word, pos): |
| """Write the gemination mark U+135F after each geminated character.""" |
| s = set(pos) |
| return "".join(c + (GEM_MARK if i in s else "") for i, c in enumerate(word)) |
|
|
|
|
| def analyze(word, final="suffix", rules=True): |
| """Run HornMorpho on one word and return its gemination patterns.""" |
| import hm |
| try: |
| rs = list(hm.anal("a", word, degem=False)) |
| except Exception: |
| rs = [] |
| return word_gemination(word, rs, final, rules) |
|
|
|
|
| if __name__ == "__main__": |
| for w in sys.argv[1:] or ["ይገኛል", "ክልል", "መለወጥ"]: |
| pats = analyze(w) |
| if not pats: |
| print(f"{w}\tno analysis") |
| for p in pats: |
| print(f"{w}\t{mark(w, p['pos'])}\tpositions={p['pos']}\tsources={p['sources']}\t" |
| f"pos={','.join(p['pos_tags'])}\troot_freq={p['freq']}\tseg={p['segs'][0]}") |
|
|
