scriptconv 0.0.4a16__tar.gz → 0.0.4a18__tar.gz

{scriptconv-0.0.4a16/scriptconv.egg-info → scriptconv-0.0.4a18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.4a16
+Version: 0.0.4a18
 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.4a16 → scriptconv-0.0.4a18}/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.4a16 → scriptconv-0.0.4a18}/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.4a16 → scriptconv-0.0.4a18}/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.4a16 → scriptconv-0.0.4a18}/scriptconv/notation.py

@@ -41,7 +41,7 @@ __all__ = [
     "ipa_to_cotovia",
     "rfe_to_ipa",
     "ipa_to_rfe",
-    "mantoq_to_ipa",
+    "halabi_to_ipa",
     "looks_like_ipa",
 ]
 
@@ -58,7 +58,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}"
@@ -330,6 +330,7 @@ _XSAMPA_TO_IPA: dict[str, str] = {
     "R": "ʁ",
     "H\\": "ʜ",
     "?\\": "ʕ",
+    "h": "h",     # plain h = voiceless glottal fricative in canonical X-SAMPA
     "h\\": "ɦ",
     "?": "ʔ",
     "H": "ɥ",
@@ -1012,7 +1013,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
@@ -1023,10 +1024,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": "ɣ",
@@ -1034,21 +1044,21 @@ _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ː",
 }
 
-_MANTOQ_MULTI = ("_dbl_", "_+_", "_sil_", "_eos_", "_pad_",
+_HALABI_MULTI = ("_dbl_", "_+_", "_sil_", "_eos_", "_pad_",
                  "aaaa", "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)
@@ -1059,8 +1069,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
@@ -1068,9 +1078,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,
@@ -1079,7 +1089,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):
@@ -1089,7 +1099,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
@@ -1108,16 +1118,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
@@ -1190,7 +1200,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,
@@ -1320,8 +1330,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.4a18/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.4a16 → scriptconv-0.0.4a18}/scriptconv/phonemizers/ar.py

@@ -7,7 +7,7 @@ from scriptconv.phonemizers.base import BasePhonemizer
 # Module-level indirection for the mantoq backend: resolved lazily on first
 # construction, kept as module globals so tests and callers can patch them.
 mantoq = None  # the g2p callable
-from scriptconv.notation import mantoq_to_ipa  # noqa: E402  (patchable name)
+from scriptconv.notation import halabi_to_ipa  # noqa: E402  (patchable name)
 
 
 def _load_mantoq_g2p():
@@ -33,13 +33,13 @@ class MantoqPhonemizer(BasePhonemizer):
 
     Historical contract, preserved for models in the wild: the default
     ``alphabet=Alphabet.BUCKWALTER`` returns the raw mantoq inventory (its
-    long-standing, if imprecise, label — ``Alphabet.MANTOQ`` is the accurate
+    long-standing, if imprecise, label — ``Alphabet.HALABI`` is the accurate
     alias); ``Alphabet.IPA`` converts via
-    :func:`scriptconv.notation.mantoq_to_ipa`.
+    :func:`scriptconv.notation.halabi_to_ipa`.
     """
 
     def __init__(self, alphabet: Alphabet = Alphabet.BUCKWALTER):
-        if alphabet not in (Alphabet.IPA, Alphabet.BUCKWALTER, Alphabet.MANTOQ):
+        if alphabet not in (Alphabet.IPA, Alphabet.BUCKWALTER, Alphabet.HALABI):
             raise ValueError("unsupported alphabet")
         super().__init__(alphabet)
         global mantoq
@@ -55,13 +55,13 @@ class MantoqPhonemizer(BasePhonemizer):
 
         Tokens are joined and the ``_+_`` word separator becomes a space —
         the byte-exact historical behavior; IPA output converts the joined
-        string with :func:`mantoq_to_ipa`.
+        string with :func:`halabi_to_ipa`.
         """
         lang = self.get_lang(lang)
         normalized_text, phonemes = mantoq(text)
         phonemes = "".join(phonemes).replace("_+_", " ")
         if self.alphabet == Alphabet.IPA:
-            return mantoq_to_ipa(phonemes)
+            return halabi_to_ipa(phonemes)
         return phonemes
 
 

{scriptconv-0.0.4a16 → scriptconv-0.0.4a18}/scriptconv/phonemizers/enums.py

@@ -28,7 +28,7 @@ class Alphabet(str, Enum):
     COTOVIA = "cotovia" # gl
     HANZI = "hanzi" # zh
     BUCKWALTER = "buckwalter"
-    MANTOQ = "mantoq"  # ar — Halabi Arabic-Phonetiser inventory # ar
+    HALABI = "halabi"  # ar — Halabi Arabic-Phonetiser phoneme notation
     CANGJIE = "cangjie" # zh (Cangjie input method)
     VOSK = "vosk" # ru — vosk-tts phoneme inventory (a0, bj, sch ...)
     GRAPHEMES = "graphemes"  # plain text / grapheme input (user-side)
@@ -66,7 +66,7 @@ class Phonemizer(str, Enum):
     COTOVIA = "cotovia"  # galician  (no ipa!)
     AHOTTS = "ahotts"  # basque
     PHONIKUD = "phonikud"  # hebrew
-    MANTOQ = "mantoq"  # arabic
+    MANTOQ = "mantoq"  # arabic — the mantoq wrapper around Halabi's Arabic-Phonetiser
     VIPHONEME = "viphoneme" # vietnamese
     G2PK = "g2pk" # korean
     KOG2PK = "kog2p" # korean

{scriptconv-0.0.4a16 → scriptconv-0.0.4a18}/scriptconv/version.py

@@ -2,7 +2,7 @@
 VERSION_MAJOR = 0
 VERSION_MINOR = 0
 VERSION_BUILD = 4
-VERSION_ALPHA = 16
+VERSION_ALPHA = 18
 # END_VERSION_BLOCK
 
 VERSION_STR = f"{VERSION_MAJOR}.{VERSION_MINOR}.{VERSION_BUILD}"

{scriptconv-0.0.4a16 → scriptconv-0.0.4a18/scriptconv.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.4a16
+Version: 0.0.4a18
 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.4a16 → scriptconv-0.0.4a18}/tests/test_notation.py

@@ -1155,59 +1155,59 @@ def test_convert_routes_through_rfe():
 # Mantoq → IPA (Halabi Arabic-Phonetiser inventory; one-directional)
 # ---------------------------------------------------------------------------
 
-from scriptconv.notation import mantoq_to_ipa, UnknownSymbolError  # noqa: E402
+from scriptconv.notation import halabi_to_ipa, UnknownSymbolError  # noqa: E402
 
 def test_mantoq_basic_word():
-    assert mantoq_to_ipa("salaam") == "salaːm"
+    assert halabi_to_ipa("salaam") == "salaːm"
 
 
 def test_mantoq_theta_is_caret_not_shadda():
     # mantoq's "^" is θ — the same character is NOT a Buckwalter shadda here
-    assert mantoq_to_ipa("^") == "θ"
+    assert halabi_to_ipa("^") == "θ"
 
 
 def test_mantoq_gemination_marker():
-    assert mantoq_to_ipa("b_dbl_a") == "bːa"
+    assert halabi_to_ipa("b_dbl_a") == "bːa"
 
 
 def test_mantoq_dbl_after_vowel_is_inert():
     # upstream only emits _dbl_ after consonants (tokenization.py splits
     # doubled consonant phonemes); a vowel+_dbl_ input is left unchanged
-    assert mantoq_to_ipa("aa_dbl_") == "aː"
+    assert halabi_to_ipa("aa_dbl_") == "aː"
 
 
 def test_mantoq_special_tokens():
     # inventory special tokens: _sil_ -> pause (space), _eos_/_pad_ dropped —
     # and never shredded into letter phonemes
-    assert mantoq_to_ipa("m_sil_n") == "m n"
-    assert mantoq_to_ipa("m a_eos_") == "m a"
-    assert mantoq_to_ipa("_pad_b") == "b"
+    assert halabi_to_ipa("m_sil_n") == "m n"
+    assert halabi_to_ipa("m a_eos_") == "m a"
+    assert halabi_to_ipa("_pad_b") == "b"
 
 
 def test_mantoq_word_separator_and_glottal():
-    assert mantoq_to_ipa("m_+_<a") == "m ʔa"
+    assert halabi_to_ipa("m_+_<a") == "m ʔa"
 
 
 def test_mantoq_emphatics_and_superlong():
-    assert mantoq_to_ipa("SaaaaD") == "sˤaːːdˤ"
+    assert halabi_to_ipa("SaaaaD") == "sˤaːːdˤ"
 
 
 def test_mantoq_via_convert_facade():
-    assert convert("salaam", "mantoq", "ipa") == "salaːm"
-    assert can_convert("mantoq", "ipa") is True
-    assert can_convert("ipa", "mantoq") is False
+    assert convert("salaam", "halabi", "ipa") == "salaːm"
+    assert can_convert("halabi", "ipa") is True
+    assert can_convert("ipa", "halabi") is False
 
 
-def test_mantoq_chains_to_xsampa_via_graph():
-    # mantoq -> ipa -> x-sampa multi-hop through the conversion graph
-    out = convert("salaam", "mantoq", "x-sampa")
+def test_halabi_chains_to_xsampa_via_graph():
+    # halabi -> ipa -> x-sampa multi-hop through the conversion graph
+    out = convert("salaam", "halabi", "x-sampa")
     assert "a:" in out
 
 
-def test_mantoq_errors_strict():
+def test_halabi_errors_strict():
     import pytest as _pytest
     with _pytest.raises(UnknownSymbolError):
-        mantoq_to_ipa("Q", errors="strict")
+        halabi_to_ipa("Q", errors="strict")
 
 
 def test_buckwalter_wasla_and_dagger_alef():

{scriptconv-0.0.4a16 → scriptconv-0.0.4a18}/tests/test_phonemizers_base.py

@@ -25,7 +25,7 @@ class TestEnums(unittest.TestCase):
         self.assertEqual(Alphabet.XSAMPA.value, "x-sampa")
         self.assertEqual(Alphabet.VOSK.value, "vosk")
         self.assertEqual(len(list(Phonemizer)), 43)
-        self.assertEqual(len(list(Alphabet)), 23)  # incl. MANTOQ, VOSK, AFRICA_G2P
+        self.assertEqual(len(list(Alphabet)), 23)  # incl. HALABI, VOSK, AFRICA_G2P
 
 
 class TestRegistryCompleteness(unittest.TestCase):

{scriptconv-0.0.4a16 → scriptconv-0.0.4a18}/tests/test_phonemizers_cjk_ar.py

@@ -190,18 +190,18 @@ if __name__ == "__main__":
 class TestMantoqTokensToIpa(unittest.TestCase):
     def test_pretokenized_sequence_accepted(self):
         # the mantoq package's g2p returns a token LIST; joining is ambiguous
-        # so mantoq_to_ipa consumes sequences directly
-        from scriptconv.notation import mantoq_to_ipa
+        # so halabi_to_ipa consumes sequences directly
+        from scriptconv.notation import halabi_to_ipa
         tokens = ["m", "a", "r", "H", "a", "b", "a", "n", "aa",
                   "_+_", "b", "i", "l", "E", "aa", "l", "a", "m", "i"]
-        out = mantoq_to_ipa(tokens)
+        out = halabi_to_ipa(tokens)
         self.assertIn("ħ", out)
         self.assertIn(" ", out)
         self.assertNotIn("_", out)
 
     def test_pretokenized_dbl_geminate(self):
-        from scriptconv.notation import mantoq_to_ipa
-        self.assertEqual(mantoq_to_ipa(["b", "_dbl_", "a"]), "bːa")
+        from scriptconv.notation import halabi_to_ipa
+        self.assertEqual(halabi_to_ipa(["b", "_dbl_", "a"]), "bːa")
 
 
 class TestUnsupportedAlphabetIsAClearError(unittest.TestCase):

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

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