scriptconv 0.0.4a17__tar.gz → 0.0.4a19__tar.gz

{scriptconv-0.0.4a17/scriptconv.egg-info → scriptconv-0.0.4a19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.4a17
+Version: 0.0.4a19
 Summary: Zero-dependency script & phoneme-notation core — ISO-15924 detection & metadata, IPA↔ARPABET/X-SAMPA/Lexique/Kirshenbaum/Cotovía/RFE, Buckwalter↔Arabic, Hangul→jamo, kana
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/TigreGotico/scriptconv
@@ -172,7 +172,7 @@ Everything is also a command:
 python -m scriptconv detect "안녕하세요"           # Hang
 python -m scriptconv convert arpa ipa "K AE1 T"   # kæt
 python -m scriptconv strip tashkeel "مُحَمَّد"       # محمد
-python -m scriptconv route mantoq x-sampa         # the conversion path, hop by hop
+python -m scriptconv route halabi x-sampa         # the conversion path, hop by hop
 ```
 
 ## The mental model
@@ -185,8 +185,8 @@ scriptconv is organized around four ideas, layered from identity to sound.
 
 2. **Representations are nodes. Conversions are edges.** IPA, ARPABET,
    hiragana, pinyin, and Cangjie codes are each a node in one conversion
-   graph, and asking for `mantoq → x-sampa` finds the cheapest path
-   (`mantoq → ipa → x-sampa`), preferring lossless edges by construction.
+   graph, and asking for `halabi → x-sampa` finds the cheapest path
+   (`halabi → ipa → x-sampa`), preferring lossless edges by construction.
 
 3. **Conventions are decorations, not identities.** Arabic vowel marks,
    Hebrew points, Japanese word spacing, and pinyin tone spelling are
@@ -224,7 +224,7 @@ Cyrillic never splits. Details: [docs/scripts.md](docs/scripts.md).
 ### Same sounds, different symbols: the `notation` module
 
 Nine phoneme notations transcode through an IPA hub: ARPABET, X-SAMPA,
-Kirshenbaum, Lexique, Cotovía, RFE, Buckwalter to Arabic, and mantoq.
+Kirshenbaum, Lexique, Cotovía, RFE, Buckwalter to Arabic, and Halabi (the Nawar Halabi Arabic-Phonetiser notation, popularized by the mantoq package).
 
 ```python
 from scriptconv import convert, arpa_to_ipa, ipa_to_arpa
@@ -250,9 +250,9 @@ Two contracts make this trustworthy:
 
 Buckwalter is an independent implementation of the published transliteration
 scheme, including alef wasla and the dagger alef (رحمٰن transliterates as
-*rHm`n*). Mantoq
+*rHm`n*). The Halabi notation
 is the phonetic alphabet of the Halabi Arabic-Phonetiser. Text in it
-converts one way to IPA (`mantoq_to_ipa("mrHbaa")` → `'mrħbaː'`) and onward
+converts one way to IPA (`halabi_to_ipa("mrHbaa")` → `'mrħbaː'`) and onward
 through the graph. Details: [docs/notation.md](docs/notation.md).
 
 ### Rewriting the writing: `translit`, `readings`, `cangjie`
@@ -449,7 +449,7 @@ placeholder (`?`, the historical `ipa_to_arpa` default, tunable via
 | **ARPABET** | **Lossless with `stress=True`** (digits map to IPA `ˈ`/`ˌ` before the stressed vowel; residues: extended-ARPABET `AX` normalises to CMUdict's `AH0` spelling, and `AH0 R` fuses to the r-colored `AXR0`, stable from the IPA side). Default `stress=False` drops digits and merges `AH0` with `AX` | **Lossy** (ARPABET is an English-only inventory, so any IPA symbol outside it becomes the *unknown* placeholder) | `arpa_to_ipa`: passed through unchanged. `ipa_to_arpa`: diacritics and suprasegmentals are dropped. Other out-of-inventory symbols follow `errors=` (default `"replace"` → `?`) |
 | **X-SAMPA** | Exact for all canonical symbols | Exact except aliases (`f\`→ɸ, `&`→æ) normalise to their canonical spelling | Passed through unchanged |
 | **Buckwalter ↔ Arabic** | Exact (precomposed lam-alef ligatures decompose to two characters, visually identical) | Exact | Follows `errors=` (default: passed through) |
-| **Mantoq → IPA** | One-directional (gemination and word markers are consumed; there is no IPA to Mantoq) | Not applicable | Follows `errors=` (default: passed through) |
+| **Halabi → IPA** | One-directional (gemination and word markers are consumed; there is no IPA to Halabi) | Not applicable | Follows `errors=` (default: passed through) |
 | **Lexique ↔ IPA** | Exact except the `°`/`3` schwa pair (both map to `ə`; the reverse always produces `°`) | Exact | Passed through unchanged |
 | **Kirshenbaum ↔ IPA** | Exact | **Lossy** (restricted ASCII inventory; IPA outside it passes through) | Passed through unchanged |
 | **Cotovía ↔ IPA** | Exact except the three `L`/`Z`/`jj` symbols for `ʎ` normalise to `L` | **Lossy** (Galician/Spanish inventory; IPA outside it passes through) | Passed through unchanged |

{scriptconv-0.0.4a17 → scriptconv-0.0.4a19}/README.md

@@ -45,7 +45,7 @@ Everything is also a command:
 python -m scriptconv detect "안녕하세요"           # Hang
 python -m scriptconv convert arpa ipa "K AE1 T"   # kæt
 python -m scriptconv strip tashkeel "مُحَمَّد"       # محمد
-python -m scriptconv route mantoq x-sampa         # the conversion path, hop by hop
+python -m scriptconv route halabi x-sampa         # the conversion path, hop by hop
 ```
 
 ## The mental model
@@ -58,8 +58,8 @@ scriptconv is organized around four ideas, layered from identity to sound.
 
 2. **Representations are nodes. Conversions are edges.** IPA, ARPABET,
    hiragana, pinyin, and Cangjie codes are each a node in one conversion
-   graph, and asking for `mantoq → x-sampa` finds the cheapest path
-   (`mantoq → ipa → x-sampa`), preferring lossless edges by construction.
+   graph, and asking for `halabi → x-sampa` finds the cheapest path
+   (`halabi → ipa → x-sampa`), preferring lossless edges by construction.
 
 3. **Conventions are decorations, not identities.** Arabic vowel marks,
    Hebrew points, Japanese word spacing, and pinyin tone spelling are
@@ -97,7 +97,7 @@ Cyrillic never splits. Details: [docs/scripts.md](docs/scripts.md).
 ### Same sounds, different symbols: the `notation` module
 
 Nine phoneme notations transcode through an IPA hub: ARPABET, X-SAMPA,
-Kirshenbaum, Lexique, Cotovía, RFE, Buckwalter to Arabic, and mantoq.
+Kirshenbaum, Lexique, Cotovía, RFE, Buckwalter to Arabic, and Halabi (the Nawar Halabi Arabic-Phonetiser notation, popularized by the mantoq package).
 
 ```python
 from scriptconv import convert, arpa_to_ipa, ipa_to_arpa
@@ -123,9 +123,9 @@ Two contracts make this trustworthy:
 
 Buckwalter is an independent implementation of the published transliteration
 scheme, including alef wasla and the dagger alef (رحمٰن transliterates as
-*rHm`n*). Mantoq
+*rHm`n*). The Halabi notation
 is the phonetic alphabet of the Halabi Arabic-Phonetiser. Text in it
-converts one way to IPA (`mantoq_to_ipa("mrHbaa")` → `'mrħbaː'`) and onward
+converts one way to IPA (`halabi_to_ipa("mrHbaa")` → `'mrħbaː'`) and onward
 through the graph. Details: [docs/notation.md](docs/notation.md).
 
 ### Rewriting the writing: `translit`, `readings`, `cangjie`
@@ -322,7 +322,7 @@ placeholder (`?`, the historical `ipa_to_arpa` default, tunable via
 | **ARPABET** | **Lossless with `stress=True`** (digits map to IPA `ˈ`/`ˌ` before the stressed vowel; residues: extended-ARPABET `AX` normalises to CMUdict's `AH0` spelling, and `AH0 R` fuses to the r-colored `AXR0`, stable from the IPA side). Default `stress=False` drops digits and merges `AH0` with `AX` | **Lossy** (ARPABET is an English-only inventory, so any IPA symbol outside it becomes the *unknown* placeholder) | `arpa_to_ipa`: passed through unchanged. `ipa_to_arpa`: diacritics and suprasegmentals are dropped. Other out-of-inventory symbols follow `errors=` (default `"replace"` → `?`) |
 | **X-SAMPA** | Exact for all canonical symbols | Exact except aliases (`f\`→ɸ, `&`→æ) normalise to their canonical spelling | Passed through unchanged |
 | **Buckwalter ↔ Arabic** | Exact (precomposed lam-alef ligatures decompose to two characters, visually identical) | Exact | Follows `errors=` (default: passed through) |
-| **Mantoq → IPA** | One-directional (gemination and word markers are consumed; there is no IPA to Mantoq) | Not applicable | Follows `errors=` (default: passed through) |
+| **Halabi → IPA** | One-directional (gemination and word markers are consumed; there is no IPA to Halabi) | Not applicable | Follows `errors=` (default: passed through) |
 | **Lexique ↔ IPA** | Exact except the `°`/`3` schwa pair (both map to `ə`; the reverse always produces `°`) | Exact | Passed through unchanged |
 | **Kirshenbaum ↔ IPA** | Exact | **Lossy** (restricted ASCII inventory; IPA outside it passes through) | Passed through unchanged |
 | **Cotovía ↔ IPA** | Exact except the three `L`/`Z`/`jj` symbols for `ʎ` normalise to `L` | **Lossy** (Galician/Spanish inventory; IPA outside it passes through) | Passed through unchanged |

{scriptconv-0.0.4a17 → scriptconv-0.0.4a19}/pyproject.toml

@@ -76,6 +76,7 @@ scriptconv = ["py.typed"]
 "scriptconv.phonemizers._thirdparty" = ["ko_tables/*.csv", "ko_tables/*.tsv"]
 "scriptconv.phonemizers._vendored.kog2p" = ["rulebook.txt", "LICENSE.md"]
 "scriptconv.phonemizers._vendored.mantoq" = ["LICENSE.md"]
+"scriptconv.phonemizers._vendored.iqra_phonetiser" = ["LICENSE.md"]
 "scriptconv.phonemizers._vendored.africa_g2p" = [
     "LICENSE.md", "DATA_LICENSE.md",
     "languages/*.json", "data/*.json",

{scriptconv-0.0.4a17 → scriptconv-0.0.4a19}/scriptconv/__init__.py

@@ -69,7 +69,7 @@ from scriptconv.notation import (
     ipa_to_cotovia,
     rfe_to_ipa,
     ipa_to_rfe,
-    mantoq_to_ipa,
+    halabi_to_ipa,
     looks_like_ipa,
 )
 from scriptconv.translit import (
@@ -141,7 +141,7 @@ __all__ = [
     "ipa_to_cotovia",
     "rfe_to_ipa",
     "ipa_to_rfe",
-    "mantoq_to_ipa",
+    "halabi_to_ipa",
     "looks_like_ipa",
     # translit
     "decompose_hangul",

{scriptconv-0.0.4a17 → scriptconv-0.0.4a19}/scriptconv/graph.py

@@ -178,7 +178,7 @@ REPRESENTATIONS: Dict[str, Representation] = {r.id: r for r in (
     Representation("kirshenbaum", "notation", reference="Kirshenbaum ASCII-IPA"),
     Representation("cotovia", "notation", reference="Cotovía (Galician TTS)"),
     Representation("rfe", "notation", reference="Revista de Filología Española"),
-    Representation("mantoq", "notation", system="mantoq",
+    Representation("halabi", "notation", system="halabi",
                    reference="Halabi Arabic-Phonetiser phoneme inventory"),
     Representation("buckwalter", "notation", script="Latn",
                    reference="Buckwalter Arabic transliteration"),

{scriptconv-0.0.4a17 → scriptconv-0.0.4a19}/scriptconv/notation.py

@@ -41,7 +41,8 @@ __all__ = [
     "ipa_to_cotovia",
     "rfe_to_ipa",
     "ipa_to_rfe",
-    "mantoq_to_ipa",
+    "halabi_to_ipa",
+    "iqra_halabi_to_ipa",
     "looks_like_ipa",
 ]
 
@@ -58,7 +59,7 @@ class Notation(str, Enum):
     KIRSHENBAUM = "kirshenbaum"  # ASCII-IPA (espeak-ng native notation)
     COTOVIA = "cotovia"  # Universidade de Vigo Cotovía TTS notation (gl)
     RFE = "rfe"
-    MANTOQ = "mantoq"  # Revista de Filología Española phonetic alphabet
+    HALABI = "halabi"  # Halabi Arabic-Phonetiser phoneme notation (ar)
 
     def __repr__(self) -> str:
         return f"Notation.{self.name}"
@@ -1013,7 +1014,7 @@ def ipa_to_rfe(ipa: str, errors: str = "pass") -> str:
 
 
 # ---------------------------------------------------------------------------
-# Mantoq → IPA
+# Halabi → IPA
 #
 # Mantoq is the phonetic alphabet of Nawar Halabi's Arabic-Phonetiser (the
 # inventory emitted by the mantoq G2P pipeline): an ASCII phoneme notation
@@ -1024,10 +1025,19 @@ def ipa_to_rfe(ipa: str, errors: str = "pass") -> str:
 # the inventory's phonetic values — the phonetiser CODE is CC BY-NC and lives
 # elsewhere; a factual symbol table is not encumbered by it.  Published
 # models trained on mantoq sequences make this notation worth transcoding.
-# One-directional: IPA → mantoq is not defined.
+# One-directional: IPA → halabi is not defined.
+#
+# Naming and lineage: this notation originates in Nawar Halabi's
+# Arabic-Phonetiser (2016, CC BY-NC 4.0), written for his Arabic speech
+# corpus. The mantoq package wraps that phonetiser (with a diacritizer);
+# phoonnx and scriptconv vendor mantoq; the IqraEval shared task generates
+# its reference phonemes with the same rules (Interspeech 2025,
+# doi:10.21437/Interspeech.2025-2411 — "we employed the phonetizer
+# introduced by Nawar Halabi"). One engine, several package names — the
+# notation is named for its author, not for any wrapper.
 # ---------------------------------------------------------------------------
 
-_MANTOQ_CONSONANTS: dict[str, str] = {
+_HALABI_CONSONANTS: dict[str, str] = {
     "b": "b", "t": "t", "^": "θ", "j": "d͡ʒ", "H": "ħ", "x": "x",
     "d": "d", "*": "ð", "r": "r", "z": "z", "s": "s", "$": "ʃ",
     "S": "sˤ", "D": "dˤ", "T": "tˤ", "Z": "ðˤ", "E": "ʕ", "g": "ɣ",
@@ -1035,21 +1045,31 @@ _MANTOQ_CONSONANTS: dict[str, str] = {
     "h": "h", "w": "w", "y": "j", "v": "v",
 }
 
-_MANTOQ_VOWELS: dict[str, str] = {
+_HALABI_VOWELS: dict[str, str] = {
     "a": "a", "aa": "aː", "aaaa": "aːː",
     "i": "i", "ii": "iː",
     "u": "u", "uu": "uː",
+    # emphatic-context allophones from the RAW (pre-mantoq-simplification)
+    # Halabi phonetiser layer — mantoq's own g2p folds these to the plain
+    # forms above via ``simplify_phonemes``, but scriptconv's raw
+    # ``Phonemizer.HALABI``/``Phonemizer.IQRA`` edges call the phonetiser
+    # directly and preserve the distinction (see arbtok's
+    # scripts/benchmark_iqraeval.py, verified symbol-by-symbol against the
+    # IqraEval/Iqra_train corpus).
+    "A": "ɑ", "AA": "ɑː",
+    "I": "ɪ", "II": "ɪː",
+    "U": "ʊ", "UU": "ʊː",
 }
 
-_MANTOQ_MULTI = ("_dbl_", "_+_", "_sil_", "_eos_", "_pad_",
-                 "aaaa", "aa", "ii", "uu")
+_HALABI_MULTI = ("_dbl_", "_+_", "_sil_", "_eos_", "_pad_",
+                 "aaaa", "aa", "ii", "uu", "AA", "II", "UU")
 
 
-def _tokenize_mantoq(text: str) -> list[str]:
+def _tokenize_halabi(text: str) -> list[str]:
     tokens = []
     i = 0
     while i < len(text):
-        for sym in _MANTOQ_MULTI:
+        for sym in _HALABI_MULTI:
             if text.startswith(sym, i):
                 tokens.append(sym)
                 i += len(sym)
@@ -1060,8 +1080,8 @@ def _tokenize_mantoq(text: str) -> list[str]:
     return tokens
 
 
-def mantoq_to_ipa(mantoq: str | list[str], errors: str = "pass") -> str:
-    """Convert a Mantoq phoneme string to IPA.
+def halabi_to_ipa(halabi: str | list[str], errors: str = "pass") -> str:
+    """Convert a Halabi-notation phoneme string to IPA.
 
     ``_dbl_`` lengthens/geminates the preceding symbol (``ː``), ``_+_``
     becomes a space, ``<`` is the glottal stop.  Unknown characters follow
@@ -1069,9 +1089,9 @@ def mantoq_to_ipa(mantoq: str | list[str], errors: str = "pass") -> str:
 
     Examples
     --------
-    >>> mantoq_to_ipa("s a l aa m")
+    >>> halabi_to_ipa("s a l aa m")
     's a l aː m'
-    >>> mantoq_to_ipa("b_dbl_a")
+    >>> halabi_to_ipa("b_dbl_a")
     'bːa'
 
     The inventory's special tokens are honoured: ``_sil_`` becomes a space,
@@ -1080,7 +1100,7 @@ def mantoq_to_ipa(mantoq: str | list[str], errors: str = "pass") -> str:
     # a pre-tokenized sequence (as returned by the mantoq package's g2p)
     # is consumed directly — joining tokens into a string is ambiguous
     # ("a"+"aa" and "aa"+"a" both join to "aaa")
-    tokens = _tokenize_mantoq(mantoq) if isinstance(mantoq, str) else mantoq
+    tokens = _tokenize_halabi(halabi) if isinstance(halabi, str) else halabi
     out: list[str] = []
     last_tok = None
     for pos, tok in enumerate(tokens):
@@ -1090,7 +1110,7 @@ def mantoq_to_ipa(mantoq: str | list[str], errors: str = "pass") -> str:
             # phon[0] == phon[1]`); geminate it with a length mark.  A
             # vowel+_dbl_ sequence does not occur in genuine mantoq output
             # and is left unchanged.
-            if out and last_tok in _MANTOQ_CONSONANTS \
+            if out and last_tok in _HALABI_CONSONANTS \
                     and not out[-1].endswith("ː"):
                 out[-1] += "ː"
             continue
@@ -1109,16 +1129,16 @@ def mantoq_to_ipa(mantoq: str | list[str], errors: str = "pass") -> str:
             out.append("ʔ")
             last_tok = tok
             continue
-        if tok in _MANTOQ_VOWELS:
-            out.append(_MANTOQ_VOWELS[tok])
-        elif tok in _MANTOQ_CONSONANTS:
-            out.append(_MANTOQ_CONSONANTS[tok])
+        if tok in _HALABI_VOWELS:
+            out.append(_HALABI_VOWELS[tok])
+        elif tok in _HALABI_CONSONANTS:
+            out.append(_HALABI_CONSONANTS[tok])
         elif tok.isspace() or tok in ".,;:!?()[]{}\"'":
             out.append(tok)
             last_tok = None
             continue
         else:
-            res = _unknown(tok, pos, "mantoq", errors)
+            res = _unknown(tok, pos, "halabi", errors)
             if res:
                 out.append(res)
             last_tok = None
@@ -1127,6 +1147,67 @@ def mantoq_to_ipa(mantoq: str | list[str], errors: str = "pass") -> str:
     return "".join(out)
 
 
+# ---------------------------------------------------------------------------
+# IqraEval phoneme_ref -> IPA
+#
+# The IqraEval shared task (Interspeech 2025, doi:10.21437/Interspeech.2025-2411
+# — "we employed the phonetizer introduced by Nawar Halabi") scores against a
+# space-separated ``phoneme_ref`` column that is the raw Halabi phonetiser
+# output with the stress/vowel-realization digits, the ``+`` word separator
+# and the ``sil`` pause token stripped — but, unlike mantoq's own
+# ``simplify_phonemes``, keeping the emphatic-allophone uppercase vowels
+# (``A``/``AA``/``I``/``II``/``U``/``UU``) and gemination as a literal doubled
+# consonant letter (``bb``, ``nn``, …) rather than a ``_dbl_`` marker. Table
+# verified symbol-by-symbol against a 5,050-row IqraEval/Iqra_train sample by
+# TigreGotico/arbtok's ``scripts/benchmark_iqraeval.py``; reproduced here
+# (same license posture as ``halabi_to_ipa`` above: a factual symbol table,
+# not the CC BY-NC phonetiser code).
+# ---------------------------------------------------------------------------
+
+_IQRA_CONSONANTS: dict[str, str] = {
+    "b": "b", "t": "t", "^": "θ", "j": "dʒ", "H": "ħ", "x": "x", "d": "d",
+    "*": "ð", "r": "r", "z": "z", "s": "s", "$": "ʃ", "S": "sˤ", "D": "dˤ",
+    "T": "tˤ", "Z": "ðˤ", "E": "ʕ", "g": "ɣ", "f": "f", "q": "q", "k": "k",
+    "l": "l", "m": "m", "n": "n", "h": "h", "w": "w", "y": "j", "<": "ʔ",
+}
+_IQRA_VOWELS: dict[str, str] = {
+    "a": "a", "aa": "aː", "A": "ɑ", "AA": "ɑː",
+    "i": "i", "ii": "iː", "I": "ɪ", "II": "ɪː",
+    "u": "u", "uu": "uː", "U": "ʊ", "UU": "ʊː",
+}
+_IQRA_NOTATION: dict[str, str] = dict(_IQRA_VOWELS)
+for _sym, _ipa in _IQRA_CONSONANTS.items():
+    _IQRA_NOTATION[_sym] = _ipa
+    _IQRA_NOTATION[_sym * 2] = _ipa + "ː"  # gemination: doubled token, shadda
+
+
+def iqra_halabi_to_ipa(tokens: str, errors: str = "pass") -> str:
+    """Convert IqraEval-flavored (already digit/separator/sil-stripped)
+    space-separated Halabi tokens to IPA.
+
+    Unlike :func:`halabi_to_ipa` (which targets mantoq's own simplified,
+    lowercase-only inventory), this keeps the emphatic-allophone uppercase
+    vowels distinct and reads gemination off a literal doubled consonant
+    letter — the ``phoneme_ref`` convention.  Unknown tokens follow the
+    ``errors`` policy (``"pass"`` by default: passed through verbatim).
+
+    Examples
+    --------
+    >>> iqra_halabi_to_ipa("f ii h i x A y r aa t u n")
+    'fiːhixɑjraːtun'
+    """
+    out = []
+    for pos, tok in enumerate(tokens.split()):
+        ipa = _IQRA_NOTATION.get(tok)
+        if ipa is not None:
+            out.append(ipa)
+        else:
+            res = _unknown(tok, pos, "halabi", errors, replacement=f"{{{{{tok}}}}}")
+            if res:
+                out.append(res)
+    return "".join(out)
+
+
 # ---------------------------------------------------------------------------
 # convert — facade routing through IPA where no direct map exists
 # ---------------------------------------------------------------------------
@@ -1191,7 +1272,7 @@ def convert(text: str, src: str | Notation, dst: str | Notation,
 # ---------------------------------------------------------------------------
 
 _TO_IPA: dict[Notation, "callable"] = {
-    Notation.MANTOQ: mantoq_to_ipa,
+    Notation.HALABI: halabi_to_ipa,
     Notation.ARPA: arpa_to_ipa,
     Notation.XSAMPA: xsampa_to_ipa,
     Notation.LEXIQUE: lexique_to_ipa,
@@ -1321,8 +1402,8 @@ NOTATION_INFO: dict[Notation, NotationInfo] = {
         token_separated=False,
         reference="RFE phonetic alphabet (Revista de Filología Española, 1915)",
     ),
-    Notation.MANTOQ: NotationInfo(
-        Notation.MANTOQ, lossless_to_ipa=False, lossless_from_ipa=False,
+    Notation.HALABI: NotationInfo(
+        Notation.HALABI, lossless_to_ipa=False, lossless_from_ipa=False,
         token_separated=False,
         reference="Phonetic alphabet of Nawar Halabi's Arabic-Phonetiser "
                   "(mantoq G2P inventory); one-directional to IPA",

scriptconv-0.0.4a19/scriptconv/phonemizers/_thirdparty/bw2ipa.py

@@ -0,0 +1,2 @@
+"""Compatibility shim — the Halabi-notation → IPA converter lives in scriptconv.notation."""
+from scriptconv.notation import halabi_to_ipa  # noqa: F401

scriptconv-0.0.4a19/scriptconv/phonemizers/_vendored/iqra_phonetiser/LICENSE.md

@@ -0,0 +1,28 @@
+# Third-party license notice — iqra_phonetiser
+
+This directory vendors the phonetisation core of `phonetise_Arabic.py` from
+[Iqra-Eval/MSA_phonetiser](https://github.com/Iqra-Eval/MSA_phonetiser) — the
+IqraEval shared task's own published data-prep code (used, per its
+`run_phonetiser.py`, to generate the `phoneme_ref` column of
+`IqraEval/Iqra_train`, the corpus `Phonemizer.IQRA` targets).
+
+That file is itself a fork of Nawar Halabi's Arabic-Phonetiser
+(https://github.com/nawarhalabi/Arabic-Phonetiser), licensed under the
+**Creative Commons Attribution-NonCommercial 4.0 International License**
+(https://creativecommons.org/licenses/by-nc/4.0/) — NOT the Apache-2.0 license
+of the rest of this repository. `phonetise-Buckwalter.py` in the IqraEval fork
+is byte-identical to the original upstream file (`cmp` verified);
+`phonetise_Arabic.py` carries small, deliberate patches on top of it (see
+`phonetiser.py`'s module docstring for the diff against both the original
+upstream and against mantoq's own vendored copy). The IqraEval fork carries no
+separate LICENSE file of its own, so the inherited CC BY-NC 4.0 terms govern
+it as a derivative work.
+
+Kept in its own quarantine, separate from `../mantoq/` — the two are
+independent copies of the same phonetiser family at different patch levels,
+each with the specific behavior a different scriptconv edge needs preserved:
+`../mantoq/` for `Phonemizer.MANTOQ`'s long-standing, model-compatible
+contract; this one for `Phonemizer.HALABI`/`Phonemizer.IQRA`'s fidelity to
+`phoneme_ref`. Nothing here imports at package import time; using it is an
+explicit per-request opt-in (constructing `HalabiPhonemizer` or
+`IqraPhonemizer`) that accepts this directory's license.

scriptconv-0.0.4a19/scriptconv/phonemizers/_vendored/iqra_phonetiser/__init__.py

@@ -0,0 +1,7 @@
+"""Quarantined vendored copy — see ``LICENSE.md`` in this directory.
+
+Nothing imports at package import time; callers reach in explicitly via
+``scriptconv.phonemizers._vendored.iqra_phonetiser.phonetiser`` (what
+:class:`scriptconv.phonemizers.ar.IqraPhonemizer` does), matching the same
+opt-in pattern as ``_vendored/mantoq``.
+"""