scriptconv 0.0.4a7__tar.gz → 0.0.4a9__tar.gz

{scriptconv-0.0.4a7/scriptconv.egg-info → scriptconv-0.0.4a9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.4a7
+Version: 0.0.4a9
 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

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/scriptconv/diacritics.py

@@ -245,24 +245,27 @@ def _sense_diacritics_pt(text: str) -> str:
     return add_extra_diacritics(text)
 
 
-def diacritize(text: str, lang: str = "und", model=None,
-               phonikud_model=None, diacritizer_model=None, **_) -> str:
+def diacritize(text: str, lang: str = "und", diacritizer_model=None,
+               **kwargs) -> str:
     """Add pronunciation-disambiguating diacritics to *text* for *lang*.
 
-    Four backends, each restoring information ordinary orthography omits but
-    downstream G2P needs:
-
-    - Hebrew (``he``) — niqqud via phonikud. ``phonikud_model=`` is optional:
-      omitted, the small public phonikud ONNX model is auto-downloaded and
-      cached (``$SCRIPTCONV_CACHE``/``$XDG_CACHE_HOME``); pass a path or
-      zero-arg callable to override.
-    - Arabic (``ar``) — tashkeel via text2tashkeel (``[tashkeel]``,
-      ``model=``/``diacritizer_model=``).
+    ``diacritizer_model=`` is the one model knob for the diacritizer edge — the
+    model for whichever backend the language routes to (there is one such knob,
+    parallel to ``phonemizer_model=`` on the ``text -> ipa`` phonemizer edge):
+
+    - Hebrew (``he``) — niqqud via phonikud; ``diacritizer_model`` is the
+      phonikud ONNX path (or a zero-arg callable). Optional: when omitted the
+      small public phonikud model is auto-downloaded and cached
+      (``$SCRIPTCONV_CACHE``/``$XDG_CACHE_HOME``).
+    - Arabic (``ar``) — tashkeel via text2tashkeel (``[tashkeel]``);
+      ``diacritizer_model`` is the text2tashkeel model name (defaults to
+      ``rawi-ensemble``).
     - East Slavic, Bulgarian/Macedonian/Slovene, Latvian, Armenian, Georgian,
       and Turkic/Caucasian languages (``STRESS_LANGS``, 26 stressonnx tags) —
-      word stress via stressonnx (``[stress]``); stress is unwritten or
-      under-marked in these languages, and in East Slavic unstressed vowels
-      also reduce, so a missing mark can corrupt more than prosody.
+      word stress via stressonnx (``[stress]``); ``diacritizer_model`` is the
+      stressonnx model. Stress is unwritten or under-marked in these languages,
+      and in East Slavic unstressed vowels also reduce, so a missing mark can
+      corrupt more than prosody.
     - European Portuguese (``pt``/``pt-PT``, never ``pt-BR``) —
       heterophonic-homograph sense diacritics via bifonia (``[pt]``);
       ordinary Portuguese orthographic marks that any downstream G2P reads
@@ -272,13 +275,17 @@ def diacritize(text: str, lang: str = "und", model=None,
     ``ImportError`` naming its extra when the optional dependency is missing
     — scriptconv never installs anything on the caller's behalf.
     """
+    # one knob for the diacritizer edge; fold the pre-unification kwargs so
+    # older callers keep working (phonikud_model was the Hebrew-only name).
+    diacritizer_model = (diacritizer_model or kwargs.get("phonikud_model")
+                         or kwargs.get("model"))
     family = _diacritizer_family(lang)
     if family == "he":
-        return _phonikud(phonikud_model).add_diacritics(text)
+        return _phonikud(diacritizer_model).add_diacritics(text)
     if family == "ar":
-        return _tashkeel(model or diacritizer_model).diacritize(text)
+        return _tashkeel(diacritizer_model).diacritize(text)
     if family == "stress":
-        return _stress(text, lang, model)
+        return _stress(text, lang, diacritizer_model)
     if family == "pt":
         return _sense_diacritics_pt(text)
     return text
@@ -359,7 +366,8 @@ def register(graph) -> None:
     """
     graph.register(
         Edge("text", DIACRITIZED,
-             lambda text, lang="und", model=None, **c: diacritize(text, lang, model, **c),
+             lambda text, lang="und", diacritizer_model=None, **c:
+                 diacritize(text, lang, diacritizer_model=diacritizer_model, **c),
              lossless=False))
     graph.register(
         Edge(DIACRITIZED, "text",

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/scriptconv/phonemizers/en.py

@@ -16,9 +16,16 @@ class DeepPhonemizer(BasePhonemizer):
     def __init__(self, model="latin_ipa_forward.pt"):
         import os
 
-        import dp
-        from dp.phonemizer import Phonemizer
-        import torch
+        try:
+            import dp
+            from dp.phonemizer import Phonemizer
+            import torch
+        except ImportError as e:
+            raise ImportError(
+                "deep-phonemizer and torch are required for the DeepPhonemizer "
+                "phonemizer. Install them with 'pip install deep-phonemizer torch' "
+                "(or 'pip install scriptconv[en-phonemizers]')."
+            ) from e
         # needed for latest torch version
         torch.serialization.add_safe_globals([dp.preprocessing.text.Preprocessor])
         torch.serialization.add_safe_globals([dp.preprocessing.text.LanguageTokenizer])
@@ -90,10 +97,17 @@ class OpenPhonemizer(BasePhonemizer):
     """
 
     def __init__(self):
-        from openphonemizer import OpenPhonemizer
-        import torch
-        # needed for latest torch version
-        import dp
+        try:
+            from openphonemizer import OpenPhonemizer
+            import torch
+            # needed for latest torch version
+            import dp
+        except ImportError as e:
+            raise ImportError(
+                "openphonemizer and torch are required for the OpenPhonemizer "
+                "phonemizer. Install them with 'pip install openphonemizer torch' "
+                "(or 'pip install scriptconv[en-phonemizers]')."
+            ) from e
         torch.serialization.add_safe_globals([dp.preprocessing.text.Preprocessor])
         torch.serialization.add_safe_globals([dp.preprocessing.text.LanguageTokenizer])
         torch.serialization.add_safe_globals([dp.preprocessing.text.SequenceTokenizer])
@@ -142,10 +156,17 @@ class G2PEnPhonemizer(BasePhonemizer):
 
     def __init__(self, alphabet=Alphabet.IPA):
         assert alphabet in [Alphabet.IPA, Alphabet.ARPA]
-        import nltk
-        nltk.download('averaged_perceptron_tagger_eng')
-        nltk.download('cmudict')
-        from g2p_en import G2p
+        try:
+            import nltk
+            nltk.download('averaged_perceptron_tagger_eng')
+            nltk.download('cmudict')
+            from g2p_en import G2p
+        except ImportError as e:
+            raise ImportError(
+                "g2p_en is required for the G2PEn phonemizer. "
+                "Install it with 'pip install g2p_en' "
+                "(or 'pip install scriptconv[en-phonemizers]')."
+            ) from e
         self.g2p = G2p()
         super().__init__(alphabet)
 

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/scriptconv/phonemizers/ja.py

@@ -40,7 +40,14 @@ class CutletPhonemizer(BasePhonemizer):
         # If `use_foreign_spelling` is true, output will use the foreign spelling
         #         provided in a UniDic lemma when available. For example, "カツ" will
         #         become "cutlet" instead of "katsu".
-        import cutlet
+        try:
+            import cutlet
+        except ImportError as e:
+            raise ImportError(
+                "cutlet is required for the Cutlet phonemizer. "
+                "Install it with 'pip install cutlet' "
+                "(or 'pip install scriptconv[ja-phonemizers]')."
+            ) from e
         self.g2p = cutlet.Cutlet(alphabet)
         self.g2p.use_foreign_spelling = use_foreign_spelling
         super().__init__(alphabet)
@@ -73,7 +80,14 @@ class PyKakasiPhonemizer(BasePhonemizer):
     def __init__(self, alphabet=Alphabet.HEPBURN):
         assert alphabet in [Alphabet.HEPBURN, Alphabet.KANA, Alphabet.HIRA]
         # kana, hira, hepburn
-        import pykakasi
+        try:
+            import pykakasi
+        except ImportError as e:
+            raise ImportError(
+                "pykakasi is required for the PyKakasi phonemizer. "
+                "Install it with 'pip install pykakasi' "
+                "(or 'pip install scriptconv[ja-phonemizers]')."
+            ) from e
         self.g2p = pykakasi.kakasi()
         super().__init__(alphabet)
 

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/scriptconv/phonemizers/ko.py

@@ -10,7 +10,14 @@ class G2PKPhonemizer(BasePhonemizer):
     def __init__(self, descriptive=True, group_vowels=True, to_syl=True,
                  alphabet=Alphabet.IPA):
         assert alphabet in [Alphabet.IPA, Alphabet.HANGUL]
-        from g2pk import G2p
+        try:
+            from g2pk import G2p
+        except ImportError as e:
+            raise ImportError(
+                "g2pk is required for the G2PK phonemizer. "
+                "Install it with 'pip install g2pk' "
+                "(or 'pip install scriptconv[ko]')."
+            ) from e
         self.g2p = G2p()
         self.descriptive = descriptive
         self.group_vowels = group_vowels

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/scriptconv/phonemizers/mul.py

@@ -435,7 +435,14 @@ class GruutPhonemizer(BasePhonemizer):
         Yields lists of word phonemes for each sentence.
         """
         lang = self.get_lang(lang)
-        import gruut
+        try:
+            import gruut
+        except ImportError as e:
+            raise ImportError(
+                "gruut is required for the Gruut phonemizer. "
+                "Install it with 'pip install gruut' "
+                "(or 'pip install scriptconv[gruut]')."
+            ) from e
         for sentence in gruut.sentences(text, lang=lang):
             sent_phonemes = [w.phonemes for w in sentence if w.phonemes]
             if sentence and not sent_phonemes:
@@ -601,8 +608,15 @@ class GoruutPhonemizer(BasePhonemizer):
 
     def __init__(self, remote_url=None):
         super().__init__(Alphabet.IPA)
-        from pygoruut.pygoruut import Pygoruut
-        from pygoruut.pygoruut_languages import PygoruutLanguages
+        try:
+            from pygoruut.pygoruut import Pygoruut
+            from pygoruut.pygoruut_languages import PygoruutLanguages
+        except ImportError as e:
+            raise ImportError(
+                "pygoruut is required for the Goruut phonemizer. "
+                "Install it with 'pip install pygoruut' "
+                "(or 'pip install scriptconv[goruut]')."
+            ) from e
 
         self.pygoruut_langs = PygoruutLanguages()
         if remote_url is not None:
@@ -665,7 +679,14 @@ class EpitranPhonemizer(BasePhonemizer):
 
     def __init__(self):
         super().__init__(Alphabet.IPA)
-        import epitran
+        try:
+            import epitran
+        except ImportError as e:
+            raise ImportError(
+                "epitran is required for the Epitran phonemizer. "
+                "Install it with 'pip install epitran' "
+                "(or 'pip install scriptconv[epitran]')."
+            ) from e
         self.epitran = epitran
         self._epis: Dict[str, epitran.Epitran] = {}
 
@@ -735,35 +756,42 @@ class MisakiPhonemizer(BasePhonemizer):
         """
         lang = self.get_lang(lang)
 
-        if lang == "zh":
-            if self.g2p_zh is None:
-                from misaki.zh import ZHG2P
-                self.g2p_zh = ZHG2P(version=self.zh_version)
-            return self.g2p_zh
-        elif lang == "ko":
-            if self.g2p_ko is None:
-                from misaki.ko import KOG2P
-                self.g2p_ko = KOG2P()
-            return self.g2p_ko
-        elif lang == "vi":
-            if self.g2p_vi is None:
-                from misaki.vi import VIG2P
-                self.g2p_vi = VIG2P()
-            return self.g2p_vi
-        elif lang == "ja":
-            if self.g2p_ja is None:
-                from misaki.ja import JAG2P
-                self.g2p_ja = JAG2P()
-            return self.g2p_ja
-        else:
-            if self.g2p_en is None:
-                from misaki import en
-                self.g2p_en = en.G2P()
-            if lang == "en-GB":
-                self.g2p_en.british = True
-            elif lang == "en-US":
-                self.g2p_en.british = False
-            return self.g2p_en
+        try:
+            if lang == "zh":
+                if self.g2p_zh is None:
+                    from misaki.zh import ZHG2P
+                    self.g2p_zh = ZHG2P(version=self.zh_version)
+                return self.g2p_zh
+            elif lang == "ko":
+                if self.g2p_ko is None:
+                    from misaki.ko import KOG2P
+                    self.g2p_ko = KOG2P()
+                return self.g2p_ko
+            elif lang == "vi":
+                if self.g2p_vi is None:
+                    from misaki.vi import VIG2P
+                    self.g2p_vi = VIG2P()
+                return self.g2p_vi
+            elif lang == "ja":
+                if self.g2p_ja is None:
+                    from misaki.ja import JAG2P
+                    self.g2p_ja = JAG2P()
+                return self.g2p_ja
+            else:
+                if self.g2p_en is None:
+                    from misaki import en
+                    self.g2p_en = en.G2P()
+                if lang == "en-GB":
+                    self.g2p_en.british = True
+                elif lang == "en-US":
+                    self.g2p_en.british = False
+                return self.g2p_en
+        except ImportError as e:
+            raise ImportError(
+                "misaki is required for the Misaki phonemizer. "
+                "Install it with 'pip install misaki' "
+                "(or 'pip install scriptconv[misaki]')."
+            ) from e
 
     def phonemize_string(self, text: str, lang: str) -> str:
         pho = self._get_phonemizer(lang)
@@ -1386,7 +1414,14 @@ class TransphonePhonemizer(BasePhonemizer):
 
     def __init__(self):
         super().__init__(Alphabet.IPA)
-        from transphone import read_tokenizer
+        try:
+            from transphone import read_tokenizer
+        except ImportError as e:
+            raise ImportError(
+                "transphone is required for the Transphone phonemizer. "
+                "Install it with 'pip install transphone' "
+                "(or 'pip install scriptconv[transphone]')."
+            ) from e
         self.read_tokenizer = read_tokenizer
         self._models = {}
 

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/scriptconv/phonemizers/pt.py

@@ -7,7 +7,14 @@ from scriptconv.phonemizers.enums import Alphabet
 class TugaphonePhonemizer(BasePhonemizer):
 
     def __init__(self):
-        from tugaphone import TugaPhonemizer
+        try:
+            from tugaphone import TugaPhonemizer
+        except ImportError as e:
+            raise ImportError(
+                "tugaphone is required for the Tugaphone phonemizer. "
+                "Install it with 'pip install tugaphone' "
+                "(or 'pip install scriptconv[pt-phonemizers]')."
+            ) from e
         self.tuga = TugaPhonemizer()
         super().__init__(Alphabet.IPA)
 

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/scriptconv/phonemizers/registry.py

@@ -231,9 +231,13 @@ def register(graph) -> None:
     from scriptconv.graph import Edge
 
     def _text_to_ipa(text: str, lang: str = "und",
-                     override: Optional[Phonemizer] = None, **_):
-        return phonemizer_for_lang(lang, Alphabet.IPA,
-                                   override).phonemize_string(text, lang)
+                     override: Optional[Phonemizer] = None,
+                     phonemizer_model: Optional[str] = None, **_):
+        # phonemizer_model is the model knob for this (phonemizer) edge —
+        # forwarded to model-backed phonemizers (ByT5/Charsiu/…); parallel to
+        # diacritizer_model on the text -> text-diacritized edge.
+        return phonemizer_for_lang(lang, Alphabet.IPA, override,
+                                   phonemizer_model).phonemize_string(text, lang)
 
     graph.register(Edge("text", "ipa", _text_to_ipa, lossless=False))
     graph.register(Edge("text-diacritized", "ipa", _text_to_ipa, lossless=False))

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/scriptconv/phonemizers/vi.py

@@ -5,7 +5,14 @@ from scriptconv.phonemizers.enums import Alphabet
 class VIPhonemePhonemizer(BasePhonemizer):
     """https://github.com/v-nhandt21/Viphoneme"""
     def __init__(self):
-        from viphoneme import vi2IPA
+        try:
+            from viphoneme import vi2IPA
+        except ImportError as e:
+            raise ImportError(
+                "viphoneme is required for the VIPhoneme phonemizer. "
+                "Install it with 'pip install viphoneme' "
+                "(or 'pip install scriptconv[vi]')."
+            ) from e
         self.g2p = vi2IPA
         super().__init__(Alphabet.IPA)
 

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/scriptconv/phonemizers/zh.py

@@ -44,7 +44,14 @@ class JiebaPhonemizer(BasePhonemizer):
         Returns:
             str: Tokenized text with words separated by spaces.
         """
-        import jieba
+        try:
+            import jieba
+        except ImportError as e:
+            raise ImportError(
+                "jieba is required for the Jieba phonemizer. "
+                "Install it with 'pip install jieba' "
+                "(or 'pip install scriptconv[zh-phonemizers]')."
+            ) from e
         lang = self.get_lang(lang)
         seg_list = jieba.cut(text, cut_all=False)
         # NFKC folds full-width digits (e.g. "３") to ASCII so num2str's

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/scriptconv/version.py

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

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9/scriptconv.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.4a7
+Version: 0.0.4a9
 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

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/scriptconv.egg-info/SOURCES.txt

@@ -86,6 +86,7 @@ tests/test_graph.py
 tests/test_notation.py
 tests/test_phonemizers_base.py
 tests/test_phonemizers_cjk_ar.py
+tests/test_phonemizers_friendly_import_errors.py
 tests/test_readings.py
 tests/test_readings_zh.py
 tests/test_scripts.py

{scriptconv-0.0.4a7 → scriptconv-0.0.4a9}/tests/test_diacritics_graph.py

@@ -101,3 +101,49 @@ class TestDiacriticsGraphExtension(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class TestEdgeModelKeys(unittest.TestCase):
+    """The two model-bearing edges each read their own context key: the
+    diacritizer edge (text -> text-diacritized) reads ``diacritizer_model``,
+    the phonemizer edge (text -> ipa) reads ``phonemizer_model``. Neither picks
+    up the other's key."""
+
+    def setUp(self):
+        self.graph = DEFAULT_GRAPH.extend(diacritics.register).extend(phonemizers.register)
+
+    def test_diacritizer_edge_reads_diacritizer_model(self):
+        seen = {}
+        backend = types.SimpleNamespace(diacritize=lambda t: t)
+
+        def _spy(m=None):
+            seen["m"] = m
+            return backend
+
+        with mock.patch.object(diacritics, "_tashkeel", _spy):
+            self.graph.convert("نص", "text", "text-diacritized", lang="ar",
+                               diacritizer_model="RAWI-X",
+                               phonemizer_model="IGNORED")
+        self.assertEqual(seen["m"], "RAWI-X")
+
+    def test_phonemizer_edge_reads_phonemizer_model(self):
+        from scriptconv.phonemizers import registry
+        cap = {}
+
+        class _P:
+            def phonemize_string(self, t, l):
+                return "IPA"
+
+        def _spy(lang, alphabet, override=None, model=None, **k):
+            cap["model"] = model
+            return _P()
+
+        with mock.patch.object(registry, "phonemizer_for_lang", _spy):
+            self.graph.convert("hello", "text", "ipa", lang="en",
+                               phonemizer_model="BYT5-CKPT",
+                               diacritizer_model="IGNORED")
+        self.assertEqual(cap["model"], "BYT5-CKPT")
+
+
+if __name__ == "__main__":
+    unittest.main()

scriptconv-0.0.4a9/tests/test_phonemizers_friendly_import_errors.py

@@ -0,0 +1,129 @@
+"""Pins the friendly-ImportError convention for the lazy backend imports
+inside phonemizer wrappers.
+
+``get_phonemizer_class`` (see ``registry.py``) already raises a friendly,
+extra-naming ``ImportError`` when the wrapper *module itself* fails to
+import.  That does not cover the far more common case: the wrapper module
+imports fine (the backend package is only imported lazily, inside
+``__init__``/a method), and it is that inner, lazy import that fails when
+the backend is missing.  Every wrapper must catch that inner failure and
+re-raise a friendly ``ImportError`` naming the pip extra — never let a bare
+``ModuleNotFoundError``/``ImportError`` escape.
+
+This test forces each wrapper's lazy import to fail (by shadowing the
+backend module in ``sys.modules`` with ``None``, which makes the ``import``
+statement raise ``ImportError`` regardless of whether the package is
+actually installed) and asserts the resulting exception is an
+``ImportError`` whose message contains an install instruction. No optional
+backend needs to be installed to run this, and nothing is skipped.
+"""
+import sys
+import unittest
+from unittest.mock import patch
+
+from scriptconv.phonemizers import Phonemizer, get_phonemizer_class
+
+
+def _trigger_construct(cls):
+    cls()
+
+
+def _trigger_gruut(cls):
+    p = cls()
+    list(p._text_to_phonemes("hi", "en"))
+
+
+def _trigger_misaki_en(cls):
+    p = cls()
+    p._get_phonemizer("en-US")
+
+
+def _trigger_jieba(cls):
+    p = cls()
+    p.phonemize_string("你好", "zh")
+
+
+# member -> (module name to blank out in sys.modules, how to trigger the
+# lazy import that consumes it)
+CASES = {
+    Phonemizer.MISAKI: ("misaki", _trigger_misaki_en),
+    Phonemizer.MISAKI_EN: ("misaki", _trigger_misaki_en),
+    Phonemizer.GRUUT: ("gruut", _trigger_gruut),
+    Phonemizer.GORUUT: ("pygoruut", _trigger_construct),
+    Phonemizer.EPITRAN: ("epitran", _trigger_construct),
+    Phonemizer.TRANSPHONE: ("transphone", _trigger_construct),
+    Phonemizer.DEEPPHONEMIZER: ("dp", _trigger_construct),
+    Phonemizer.OPENPHONEMIZER: ("openphonemizer", _trigger_construct),
+    Phonemizer.G2PEN: ("nltk", _trigger_construct),
+    Phonemizer.TUGAPHONE: ("tugaphone", _trigger_construct),
+    Phonemizer.CUTLET: ("cutlet", _trigger_construct),
+    Phonemizer.PYKAKASI: ("pykakasi", _trigger_construct),
+    Phonemizer.VIPHONEME: ("viphoneme", _trigger_construct),
+    Phonemizer.G2PK: ("g2pk", _trigger_construct),
+    Phonemizer.JIEBA: ("jieba", _trigger_jieba),
+}
+
+
+class TestLazyBackendImportsAreFriendly(unittest.TestCase):
+    def test_all_documented_backends_covered(self):
+        # keeps this test list honest if a new Phonemizer member is added
+        # backed by one of the wrapper modules touched by this convention
+        self.assertEqual(len(CASES), 15)
+
+    def _assert_friendly(self, member):
+        module_name, trigger = CASES[member]
+        cls = get_phonemizer_class(member)
+        with patch.dict(sys.modules, {module_name: None}):
+            with self.assertRaises(ImportError, msg=member) as ctx:
+                trigger(cls)
+        msg = str(ctx.exception)
+        self.assertIn("pip install", msg, member)
+
+    def test_misaki(self):
+        self._assert_friendly(Phonemizer.MISAKI)
+
+    def test_misaki_en(self):
+        self._assert_friendly(Phonemizer.MISAKI_EN)
+
+    def test_gruut(self):
+        self._assert_friendly(Phonemizer.GRUUT)
+
+    def test_goruut(self):
+        self._assert_friendly(Phonemizer.GORUUT)
+
+    def test_epitran(self):
+        self._assert_friendly(Phonemizer.EPITRAN)
+
+    def test_transphone(self):
+        self._assert_friendly(Phonemizer.TRANSPHONE)
+
+    def test_deepphonemizer(self):
+        self._assert_friendly(Phonemizer.DEEPPHONEMIZER)
+
+    def test_openphonemizer(self):
+        self._assert_friendly(Phonemizer.OPENPHONEMIZER)
+
+    def test_g2pen(self):
+        self._assert_friendly(Phonemizer.G2PEN)
+
+    def test_tugaphone(self):
+        self._assert_friendly(Phonemizer.TUGAPHONE)
+
+    def test_cutlet(self):
+        self._assert_friendly(Phonemizer.CUTLET)
+
+    def test_pykakasi(self):
+        self._assert_friendly(Phonemizer.PYKAKASI)
+
+    def test_viphoneme(self):
+        self._assert_friendly(Phonemizer.VIPHONEME)
+
+    def test_g2pk(self):
+        self._assert_friendly(Phonemizer.G2PK)
+
+    def test_jieba(self):
+        self._assert_friendly(Phonemizer.JIEBA)
+
+
+if __name__ == "__main__":
+    unittest.main()