thaiphon 0.2.0__py3-none-any.whl

thaiphon/__init__.py

@@ -0,0 +1,21 @@
+"""thaiphon — Thai phonological transliteration engine."""
+
+from thaiphon.api import (
+    analyze,
+    analyze_word,
+    list_schemes,
+    transcribe,
+    transcribe_sentence,
+    transcribe_word,
+)
+
+__version__ = "0.2.0"
+__all__ = [
+    "__version__",
+    "analyze",
+    "analyze_word",
+    "list_schemes",
+    "transcribe",
+    "transcribe_sentence",
+    "transcribe_word",
+]

thaiphon/api.py

@@ -0,0 +1,139 @@
+"""Public API: transcribe, analyze, list_schemes."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, Literal
+
+from thaiphon.errors import UnsupportedSchemeError
+from thaiphon.model.candidate import AnalysisResult
+from thaiphon.registry import RENDERERS
+
+if TYPE_CHECKING:
+    from thaiphon.pipeline.runner import PipelineRunner
+
+ReadingProfile = Literal[
+    "everyday", "careful_educated", "learned_full", "etalon_compat"
+]
+
+_runner: PipelineRunner | None = None
+
+
+def _get_runner() -> PipelineRunner:
+    global _runner
+    if _runner is None:
+        from thaiphon.pipeline.runner import PipelineRunner
+
+        _runner = PipelineRunner()
+    return _runner
+
+
+def analyze(
+    text: str,
+    *,
+    is_final_in_compound: bool = True,
+    profile: ReadingProfile = "everyday",
+) -> AnalysisResult:
+    return _get_runner().analyze(
+        text, is_final_in_compound=is_final_in_compound, profile=profile
+    )
+
+
+def analyze_word(
+    text: str, *, profile: ReadingProfile = "everyday"
+) -> AnalysisResult:
+    return _get_runner().analyze(text, profile=profile)
+
+
+def list_schemes() -> tuple[str, ...]:
+    # Ensure built-in renderers are registered before reporting.
+    from thaiphon import renderers  # noqa: F401
+
+    return RENDERERS.keys()
+
+
+def transcribe(
+    text: str,
+    scheme: str = "tlc",
+    *,
+    format: Literal["text", "html"] = "text",
+    profile: ReadingProfile = "everyday",
+    _is_sentence_final: bool = True,
+) -> str:
+    from thaiphon import renderers  # noqa: F401
+    from thaiphon.renderers.base import RenderContext
+
+    if scheme not in RENDERERS:
+        raise UnsupportedSchemeError(scheme)
+    renderer = RENDERERS.get(scheme)
+    ctx = RenderContext(format=format, profile=profile)
+    result = analyze(
+        text, is_final_in_compound=_is_sentence_final, profile=profile
+    )
+    return renderer.render_word(result.best, ctx)
+
+
+def transcribe_word(
+    text: str,
+    scheme: str = "tlc",
+    *,
+    format: Literal["text", "html"] = "text",
+    profile: ReadingProfile = "everyday",
+    _is_sentence_final: bool = True,
+) -> str:
+    return transcribe(
+        text,
+        scheme=scheme,
+        format=format,
+        profile=profile,
+        _is_sentence_final=_is_sentence_final,
+    )
+
+
+def transcribe_sentence(
+    text: str,
+    scheme: str = "tlc",
+    *,
+    format: Literal["text", "html"] = "text",
+    profile: ReadingProfile = "everyday",
+    segmenter: Callable[[str], Sequence[str]] | None = None,
+) -> str:
+    """Segment ``text`` into words, transcribe each, join with spaces.
+
+    Words appearing mid-compound have their M-602 length overrides
+    reverted (see :mod:`thaiphon.lexicons.length_overrides`). Words
+    that are the last token pass through with overrides applied.
+    """
+    from thaiphon.segmentation import longest as _longest
+
+    seg = segmenter if segmenter is not None else _longest.segment
+    words = tuple(seg(text))
+    if not words:
+        return ""
+    out: list[str] = []
+    last = len(words) - 1
+    for i, w in enumerate(words):
+        if not w or w.isspace():
+            continue
+        is_last = i == last
+        out.append(
+            transcribe_word(
+                w,
+                scheme=scheme,
+                format=format,
+                profile=profile,
+                _is_sentence_final=is_last,
+            )
+        )
+    return " ".join(out)
+
+
+__all__ = [
+    "ReadingProfile",
+    "analyze",
+    "analyze_word",
+    "list_schemes",
+    "transcribe",
+    "transcribe_sentence",
+    "transcribe_word",
+]

thaiphon/derivation/__init__.py

@@ -0,0 +1,18 @@
+"""Pure-function derivation primitives: onset, vowel, coda, type, tone."""
+
+from thaiphon.derivation.coda import FinalAnalysis, resolve_coda
+from thaiphon.derivation.onset import OnsetAnalysis, resolve_onset
+from thaiphon.derivation.syllable_type import classify
+from thaiphon.derivation.tone import assign_tone
+from thaiphon.derivation.vowel import VowelAnalysis, resolve_vowel
+
+__all__ = [
+    "FinalAnalysis",
+    "OnsetAnalysis",
+    "VowelAnalysis",
+    "assign_tone",
+    "classify",
+    "resolve_coda",
+    "resolve_onset",
+    "resolve_vowel",
+]

thaiphon/derivation/coda.py

@@ -0,0 +1,36 @@
+"""Coda resolution via the M-301 26→6 collapse."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from thaiphon.model.enums import SyllableType
+from thaiphon.model.phoneme import Phoneme
+from thaiphon.tables import final_collapse
+
+# Stops → DEAD; sonorants/semi-vowels → LIVE.
+_STOPS: frozenset[str] = frozenset({"p̚", "t̚", "k̚"})
+
+
+@dataclass(frozen=True, slots=True)
+class FinalAnalysis:
+    phoneme: Phoneme | None
+    syllable_type_hint: SyllableType | None
+
+
+def resolve_coda(final_char: str | None) -> FinalAnalysis:
+    if final_char is None or final_char == "":
+        return FinalAnalysis(phoneme=None, syllable_type_hint=None)
+    ipa = final_collapse.collapse(final_char)
+    if ipa in _STOPS:
+        return FinalAnalysis(
+            phoneme=Phoneme(ipa),
+            syllable_type_hint=SyllableType.DEAD,
+        )
+    return FinalAnalysis(
+        phoneme=Phoneme(ipa, is_sonorant=True),
+        syllable_type_hint=SyllableType.LIVE,
+    )
+
+
+__all__ = ["FinalAnalysis", "resolve_coda"]

thaiphon/derivation/onset.py

@@ -0,0 +1,118 @@
+"""Onset resolution: class, ห/อ-leading, clusters, vowel-initial."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from thaiphon.lexicons import o_leading as o_leading_lex
+from thaiphon.model.enums import ConsonantClass, EffectiveClass
+from thaiphon.model.letters import HO_HIP, O_ANG, YO_YAK
+from thaiphon.model.phoneme import Cluster, Phoneme
+from thaiphon.tables import clusters as clusters_tbl
+from thaiphon.tables import consonants as consonants_tbl
+from thaiphon.tables.clusters import RARE_CLUSTERS as _RARE_CLUSTERS
+from thaiphon.tables.leaders import H_LEADABLE_SONORANTS as _H_LEADABLE
+
+# M-510: hard-coded 4-word อ-leading set (full forms).
+_O_LEADING_WORDS: frozenset[str] = o_leading_lex.O_LEADING_WORDS
+
+
+@dataclass(frozen=True, slots=True)
+class OnsetAnalysis:
+    onset: Phoneme | Cluster | None
+    effective_class: EffectiveClass
+    consumed: int
+    leading_silent: str | None = None
+
+
+def _effective(cls: ConsonantClass) -> EffectiveClass:
+    if cls is ConsonantClass.HIGH:
+        return EffectiveClass.HIGH
+    if cls is ConsonantClass.MID:
+        return EffectiveClass.MID
+    return EffectiveClass.LOW
+
+
+def _phoneme_for(letter: str, as_onset: bool = True) -> Phoneme:
+    info = consonants_tbl.lookup(letter)
+    ipa = info.onset_ipa if as_onset else (info.coda_ipa or info.onset_ipa)
+    aspirated = ipa.endswith("ʰ")
+    sonorant = info.cls is ConsonantClass.LOW_SONORANT
+    return Phoneme(ipa, is_aspirated=aspirated, is_sonorant=sonorant)
+
+
+def resolve_onset(chars: Sequence[str]) -> OnsetAnalysis:
+    """Resolve the onset from leading characters of a syllable.
+
+    `chars` is the raw character sequence starting at a consonant (or vowel
+    prefix already stripped). Returns a small analysis: onset value, effective
+    class for tone lookup, number of chars consumed, and any silent leader.
+    """
+    if not chars:
+        # Empty onset — implicit อ at word start.
+        return OnsetAnalysis(
+            onset=Phoneme("ʔ"),
+            effective_class=EffectiveClass.MID,
+            consumed=0,
+        )
+
+    first = chars[0]
+
+    # Vowel-initial: leading char is a vowel mark / prevowel → implicit glottal.
+    if first not in consonants_tbl.CONSONANTS:
+        return OnsetAnalysis(
+            onset=Phoneme("ʔ"),
+            effective_class=EffectiveClass.MID,
+            consumed=0,
+        )
+
+    # M-510: อ-leading check against the 4-word closed set.
+    if first == O_ANG and len(chars) >= 2 and chars[1] == YO_YAK:
+        full = "".join(chars)
+        if full in _O_LEADING_WORDS:
+            return OnsetAnalysis(
+                onset=Phoneme("j", is_sonorant=True),
+                effective_class=EffectiveClass.MID,
+                consumed=2,
+                leading_silent=O_ANG,
+            )
+        # Fall through to standard handling.
+
+    # M-500: ห-leading.
+    if first == HO_HIP and len(chars) >= 2 and chars[1] in _H_LEADABLE:
+        second = chars[1]
+        return OnsetAnalysis(
+            onset=_phoneme_for(second),
+            effective_class=EffectiveClass.HIGH,
+            consumed=2,
+            leading_silent=HO_HIP,
+        )
+
+    # M-520: true clusters (only when a non-consonant follows, i.e. no third
+    # consonant that would turn this into onset+initial-consonant pair).
+    if len(chars) >= 2 and chars[1] in consonants_tbl.CONSONANTS:
+        second = chars[1]
+        if (
+            clusters_tbl.is_cluster(first, second)
+            and (first, second) not in _RARE_CLUSTERS
+        ):
+            info1 = consonants_tbl.lookup(first)
+            p1 = _phoneme_for(first)
+            p2 = _phoneme_for(second)
+            return OnsetAnalysis(
+                onset=Cluster(p1, p2),
+                effective_class=_effective(info1.cls),
+                consumed=2,
+            )
+
+    # Single consonant onset.
+    info = consonants_tbl.lookup(first)
+    return OnsetAnalysis(
+        onset=_phoneme_for(first),
+        effective_class=_effective(info.cls),
+        consumed=1,
+    )
+
+
+__all__ = ["OnsetAnalysis", "resolve_onset"]

thaiphon/derivation/syllable_type.py

@@ -0,0 +1,28 @@
+"""M-303: live/dead syllable classification."""
+
+from __future__ import annotations
+
+from thaiphon.derivation.coda import FinalAnalysis
+from thaiphon.model.enums import SyllableType, VowelLength
+
+
+def classify(
+    vowel_length: VowelLength,
+    coda: FinalAnalysis,
+    has_written_vowel: bool = True,
+) -> SyllableType:
+    """Classify a syllable as LIVE or DEAD.
+
+    LIVE: long open vowel, sonorant-final syllable (/m n ŋ w j/),
+          or special vowels that are always LIVE regardless of surface form.
+    DEAD: stop-final syllable (/p̚ t̚ k̚/) or short open vowel.
+    """
+    if coda.syllable_type_hint is not None:
+        return coda.syllable_type_hint
+    # No coda → determined by vowel length.
+    if vowel_length is VowelLength.LONG:
+        return SyllableType.LIVE
+    return SyllableType.DEAD
+
+
+__all__ = ["classify"]

thaiphon/derivation/tone.py

@@ -0,0 +1,18 @@
+"""Thin typed adapter over the M-410 tone matrix."""
+
+from __future__ import annotations
+
+from thaiphon.model.enums import EffectiveClass, SyllableType, Tone, ToneMark, VowelLength
+from thaiphon.tables import tone_matrix
+
+
+def assign_tone(
+    effective_class: EffectiveClass,
+    syllable_type: SyllableType,
+    vowel_length: VowelLength,
+    tone_mark: ToneMark,
+) -> Tone:
+    return tone_matrix.lookup(effective_class, syllable_type, vowel_length, tone_mark)
+
+
+__all__ = ["assign_tone"]

thaiphon/derivation/vowel.py

@@ -0,0 +1,242 @@
+"""Vowel quality + length resolution (M-200, M-203, M-206, M-308, M-600, M-204)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from thaiphon.errors import ParseError
+from thaiphon.model.enums import VowelLength
+from thaiphon.model.letters import (
+    MAI_HAN_AKAT,
+    MAITAIKHU,
+    O_ANG,
+    RO_RUA,
+    SARA_A,
+    SARA_AA,
+    SARA_AE,
+    SARA_AI_MAIMALAI,
+    SARA_AI_MAIMUAN,
+    SARA_AM,
+    SARA_E,
+    SARA_I,
+    SARA_II,
+    SARA_O,
+    SARA_U,
+    SARA_UE,
+    SARA_UEE,
+    SARA_UU,
+    TONE_MARKS,
+    WO_WAEN,
+    YO_YAK,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class VowelAnalysis:
+    quality: str  # IPA quality symbol, e.g. "a", "iː" not yet — just "i" + length
+    length: VowelLength
+    inserted_vowel: bool = False
+    offglide: str | None = None
+    notes: tuple[str, ...] = ()
+
+
+# Simple above/below/after vowel marks: (mark, length, IPA quality).
+_SIMPLE_MARKS: dict[str, tuple[str, VowelLength]] = {
+    SARA_I: ("i", VowelLength.SHORT),
+    SARA_II: ("i", VowelLength.LONG),
+    SARA_UE: ("ɯ", VowelLength.SHORT),
+    SARA_UEE: ("ɯ", VowelLength.LONG),
+    SARA_U: ("u", VowelLength.SHORT),
+    SARA_UU: ("u", VowelLength.LONG),
+    MAI_HAN_AKAT: ("a", VowelLength.SHORT),
+}
+
+
+def _strip_tones(s: str) -> str:
+    return "".join(c for c in s if c not in TONE_MARKS)
+
+
+def resolve_vowel(
+    syllable_chars: str,
+    onset_consumed: int,
+    has_final: bool,
+    tone_mark_present: bool,
+    final_char: str | None = None,
+) -> VowelAnalysis:
+    """Resolve vowel quality + length for a single syllable.
+
+    `syllable_chars` is the full raw syllable. `onset_consumed` is the
+    absolute offset into the (tone-stripped) string where vowel material
+    begins — i.e. any leading pre-vowel plus onset consonants already count.
+    """
+    del tone_mark_present  # reserved; current analysis doesn't branch on it
+
+    # Work on a tone-stripped copy so we can pattern-match cleanly.
+    s = _strip_tones(syllable_chars)
+
+    # Pre-base vowels (เ แ โ ใ ไ) — need special handling; they appear before onset.
+    pre = s[0] if s else ""
+
+    if pre == SARA_AI_MAIMUAN:
+        # ใ — always short /a/ + /j/ offglide; LIVE syllable.
+        return VowelAnalysis("a", VowelLength.SHORT, offglide="j")
+    if pre == SARA_AI_MAIMALAI:
+        # ไ — same surface behaviour as ใ.
+        return VowelAnalysis("a", VowelLength.SHORT, offglide="j")
+
+    # เ◌ family.
+    if pre == SARA_E:
+        # `onset_consumed` is absolute (includes the pre-vowel).
+        rest = s[onset_consumed:]  # chars after เ + onset
+        # เ◌า — /aw/, short open, LIVE (special).
+        if rest.startswith(SARA_AA):
+            # เอา = aw short LIVE. Check for ะ at end → เ◌าะ → /ɔ/ short.
+            if rest == SARA_AA + SARA_A:
+                return VowelAnalysis("ɔ", VowelLength.SHORT)
+            # เ◌าะ + final → ◌็อ closed variant (handled via MAITAIKHU pattern)
+            return VowelAnalysis("a", VowelLength.SHORT, offglide="w")
+        # เ◌ียะ / เ◌ีย — centring diphthong /iə/.
+        if rest.startswith(SARA_II + YO_YAK):
+            # R-CENT-001 Case B: เ◌ียว is /iː/ + /w/, NOT centring /iːə/.
+            # When ``_find_final`` has extracted ``ว`` as the coda the ย
+            # that survives in ``rest`` was orthographic filler for the
+            # /iː/ nucleus — there is no centring offglide before /w/.
+            if final_char == WO_WAEN:
+                return VowelAnalysis("i", VowelLength.LONG)
+            # เ◌ียะ short, เ◌ีย long.
+            tail = rest[2:]
+            if tail == SARA_A:
+                return VowelAnalysis("iə", VowelLength.SHORT)
+            # long: with or without final.
+            return VowelAnalysis("iə", VowelLength.LONG)
+        # เ◌ือะ / เ◌ือ — centring diphthong /ɯə/.
+        if rest.startswith(SARA_UEE + O_ANG):
+            tail = rest[2:]
+            if tail == SARA_A:
+                return VowelAnalysis("ɯə", VowelLength.SHORT)
+            return VowelAnalysis("ɯə", VowelLength.LONG)
+        # เ◌อ / เ◌อะ — /ɤ/. With final ย → เ◌ย (short /ɤ/).
+        if rest.startswith(O_ANG):
+            tail = rest[1:]
+            if tail == SARA_A:
+                return VowelAnalysis("ɤ", VowelLength.SHORT)
+            return VowelAnalysis("ɤ", VowelLength.LONG)
+        # เ◌ิ◌ — short /ɤ/ closed (M-203 เ◌อ + final → เ◌ิ + final)
+        if rest.startswith(SARA_I):
+            return VowelAnalysis("ɤ", VowelLength.SHORT)
+        # เ◌ย — short /ɤ/ + /j/ offglide (M-204 allomorph of เ◌อ + ย).
+        # Template must fire BEFORE the fallback long /eː/ branch below.
+        # ``_find_final`` has already consumed ย as the coda, so ``rest``
+        # is empty and the raw ย only survives through ``final_char``.
+        if rest == "" and final_char == YO_YAK:
+            return VowelAnalysis("ɤ", VowelLength.SHORT, offglide="j")
+        # เ◌็◌ — short /e/ closed (M-203 เ◌ะ + final → เ◌็ + final)
+        if rest.startswith(MAITAIKHU):
+            return VowelAnalysis("e", VowelLength.SHORT)
+        # เ◌ะ — short /e/, open.
+        if rest == SARA_A:
+            return VowelAnalysis("e", VowelLength.SHORT)
+        # เ◌ + final or bare เ◌ (long /eː/).
+        # If rest is empty → open long /e/; if rest contains consonant(s) → long closed.
+        return VowelAnalysis("e", VowelLength.LONG)
+
+    if pre == SARA_AE:
+        rest = s[onset_consumed:]
+        # แ◌ะ — short /ɛ/.
+        if rest == SARA_A:
+            return VowelAnalysis("ɛ", VowelLength.SHORT)
+        # แ◌็◌ — short /ɛ/ closed.
+        if rest.startswith(MAITAIKHU):
+            return VowelAnalysis("ɛ", VowelLength.SHORT)
+        # แ◌ / แ◌◌ — long /ɛː/.
+        return VowelAnalysis("ɛ", VowelLength.LONG)
+
+    if pre == SARA_O:
+        rest = s[onset_consumed:]
+        if rest == SARA_A:
+            return VowelAnalysis("o", VowelLength.SHORT)
+        # โ◌ / โ◌◌ — long /oː/.
+        return VowelAnalysis("o", VowelLength.LONG)
+
+    # No pre-base vowel. Examine post-onset portion.
+    rest = s[onset_consumed:]
+
+    # Post-base อ carrier: C + อ → long /ɔː/ open. C + อ + final collapses
+    # to long /ɔː/ closed (the final char was already extracted by the
+    # caller so we only need to check the remaining orthographic fragment).
+    if rest.startswith(O_ANG) and (len(rest) == 1):
+        return VowelAnalysis("ɔ", VowelLength.LONG)
+
+    # R-202 closed short /ɔ/ allomorph: C + ◌็ + อ + coda. Must match
+    # BEFORE the generic MAITAIKHU fallback below so ล็อค, น็อค, ช็อป
+    # read with a SHORT /ɔ/ nucleus rather than /o/.
+    if rest.startswith(MAITAIKHU + O_ANG):
+        return VowelAnalysis("ɔ", VowelLength.SHORT)
+
+    # Sara Am ◌ำ — /am/ short, LIVE (special; M-600).
+    if SARA_AM in rest:
+        return VowelAnalysis("a", VowelLength.SHORT, offglide="m")
+
+    # ◌ะ — short /a/ open.
+    if rest == SARA_A:
+        return VowelAnalysis("a", VowelLength.SHORT)
+
+    # ◌า — long /aː/ open (or closed with trailing consonant).
+    if rest.startswith(SARA_AA):
+        return VowelAnalysis("a", VowelLength.LONG)
+
+    # ◌ั◌ — short /a/ closed (M-203 ะ + final → ั + final).
+    if rest.startswith(MAI_HAN_AKAT):
+        # ◌ัว — /ua/ centring diphthong.
+        if rest.startswith(MAI_HAN_AKAT + WO_WAEN):
+            tail = rest[2:]
+            if tail == "":
+                return VowelAnalysis("uə", VowelLength.LONG)
+            # ◌ัว◌ closed.
+            return VowelAnalysis("uə", VowelLength.LONG)
+        return VowelAnalysis("a", VowelLength.SHORT)
+
+    # R-CD-004: closed /uːə/ written as C + ว + coda with the ◌ั dropped.
+    # After `_find_final` has extracted the trailing coda, the only thing
+    # left after the onset is the bare ว. Example: ``ชวน`` → onset=ช,
+    # final=น, rest=ว → nucleus /uə/ long. Open ว syllables without a
+    # coda (e.g. ``วัน``, ``วง``) never land here — those carry ว as the
+    # onset, so ``rest`` would not start with ว for them.
+    if rest == WO_WAEN:
+        return VowelAnalysis("uə", VowelLength.LONG)
+
+    # Simple above/below marks.
+    for mark, (quality, length) in _SIMPLE_MARKS.items():
+        if rest.startswith(mark):
+            return VowelAnalysis(quality, length)
+
+    # ◌็◌ — short-vowel marker; depends on pre-vowel (already handled) or
+    # bare use after onset is uncommon. Treat as short /o/.
+    if rest.startswith(MAITAIKHU):
+        return VowelAnalysis("o", VowelLength.SHORT)
+
+    # No explicit vowel letter at all — M-206 / M-308 inherent-vowel.
+    if rest == "":
+        # M-206: closed syllable with no written vowel → inherent short /o/.
+        # Open syllable → inherent short /a/.
+        if has_final:
+            return VowelAnalysis("o", VowelLength.SHORT, inserted_vowel=True)
+        return VowelAnalysis("a", VowelLength.SHORT, inserted_vowel=True)
+
+    # Closed with no written vowel.
+    # M-308: if coda is ร → long /ɔː/ with /n/ coda (caller still uses coda-collapse).
+    # We signal the vowel here; the coda resolver already returns /n/ for ร.
+    if len(rest) == 1 and rest in (RO_RUA,):
+        return VowelAnalysis("ɔ", VowelLength.LONG, inserted_vowel=True)
+
+    # Closed syllable, multiple consonants with no written vowel → short /o/.
+    if all(ch not in _SIMPLE_MARKS and ch != SARA_A and ch != SARA_AA for ch in rest):
+        # Heuristic: if the first trailing char is a "ร" coda → M-308.
+        if rest == RO_RUA:
+            return VowelAnalysis("ɔ", VowelLength.LONG, inserted_vowel=True)
+        return VowelAnalysis("o", VowelLength.SHORT, inserted_vowel=True)
+
+    raise ParseError(f"unrecognised vowel pattern: {syllable_chars!r}")
+
+
+__all__ = ["VowelAnalysis", "resolve_vowel"]

thaiphon/errors.py

@@ -0,0 +1,25 @@
+"""Exception hierarchy for thaiphon."""
+
+
+class ThaiphonError(Exception):
+    """Base for all thaiphon exceptions."""
+
+
+class ParseError(ThaiphonError):
+    """Raised when tokenization or orthography rejects input."""
+
+
+class NormalizationError(ThaiphonError):
+    """Raised on NFC or script-order normalization failure."""
+
+
+class DerivationError(ThaiphonError):
+    """Raised when a rule-table lookup has no entry for given inputs."""
+
+
+class UnsupportedSchemeError(ThaiphonError):
+    """Raised when a requested renderer scheme is not registered."""
+
+
+class AmbiguousAnalysisError(ThaiphonError):
+    """Raised in strict mode when multiple candidates tie after ranking."""

thaiphon/lexicons/__init__.py

@@ -0,0 +1 @@
+"""Lexicon modules for rule islands and irregular readings."""