scriptconv 0.0.3a15__tar.gz → 0.0.3a17__tar.gz

{scriptconv-0.0.3a15 → scriptconv-0.0.3a17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.3a15
+Version: 0.0.3a17
 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.3a15 → scriptconv-0.0.3a17}/scriptconv/phonemizers/registry.py

@@ -112,6 +112,14 @@ def get_phonemizer(phonemizer: Phonemizer,
         params = inspect.signature(cls.__init__).parameters
         if "alphabet" in params:
             kwargs.setdefault("alphabet", alphabet)
+        if model is not None:
+            # backends name their variant/model selector differently
+            # (AhoTTS: engine=, arbtok: register=, ...) — forward to whichever
+            # parameter the constructor declares
+            for name in ("model", "engine", "register"):
+                if name in params:
+                    kwargs.setdefault(name, model)
+                    break
         inst = cls(**kwargs)
     if normalizer is not None:
         inst.normalizer = normalizer
@@ -133,30 +141,61 @@ _EMITS: Dict[Phonemizer, Tuple[Alphabet, ...]] = {
 }
 
 LANG_DEFAULTS: Dict[str, Tuple[Phonemizer, ...]] = {
-    # Arabic IPA always goes through arbtok (hard org rule)
+    # Arabic IPA always goes through arbtok (hard org rule — never falls
+    # through to orthography2ipa or espeak)
     "ar": (_P.ARBTOK,),
     "eu": (_P.EUSKAPHONE,),
     "mwl": (_P.MIRANDESE,),
     "pt": (_P.TUGAPHONE,),
     "he": (_P.PHONIKUD,),
-    "gl": (_P.COTOVIA, _P.ESPEAK),
+    "gl": (_P.COTOVIA, _P.ORTHOGRAPHY2IPA, _P.ESPEAK),
 }
 
+# Languages whose explicit entry is exhaustive: no generic fallback beyond it.
+_NO_GENERIC_FALLBACK = {"ar"}
+
+
+def _o2i_supports(lang: str) -> bool:
+    """True when orthography2ipa is installed and has a spec for *lang*."""
+    try:
+        from scriptconv.phonemizers.o2ipa import Orthography2IPAPhonemizer
+        Orthography2IPAPhonemizer.get_lang(lang)
+        return True
+    except (ImportError, ValueError):
+        return False
+
 
 def phonemizer_for_lang(lang: str, alphabet: Alphabet = Alphabet.IPA,
                         override: Optional[Phonemizer] = None,
                         model: Optional[str] = None, **kwargs):
     """Construct the default phonemizer for *lang* (or the override).
 
-    Candidates from :data:`LANG_DEFAULTS` are filtered by the alphabet they
-    can emit; espeak is the universal fallback.
+    Resolution order — in-house engines first:
+
+    1. ``override=`` when given;
+    2. the language's explicit :data:`LANG_DEFAULTS` chain, filtered by the
+       alphabet each candidate can emit;
+    3. :data:`~Phonemizer.ORTHOGRAPHY2IPA` when orthography2ipa supports the
+       language (the usual default);
+    4. espeak as the last resort.
+
+    Languages in the no-fallback set (Arabic) never leave their explicit
+    chain — a missing arbtok raises rather than silently degrading.
     """
     if override is not None:
         return get_phonemizer(override, alphabet, model, **kwargs)
     key = lang.replace("_", "-").split("-")[0].lower()
-    for candidate in LANG_DEFAULTS.get(key, ()):
+    explicit = LANG_DEFAULTS.get(key, ())
+    for candidate in explicit:
         if alphabet in _EMITS.get(candidate, (Alphabet.IPA,)):
             return get_phonemizer(candidate, alphabet, model, **kwargs)
+    if key in _NO_GENERIC_FALLBACK:
+        raise ValueError(
+            f"no eligible phonemizer for {lang!r} with alphabet "
+            f"{alphabet.value!r}: the explicit chain "
+            f"{[c.value for c in explicit]} is exhaustive for this language")
+    if alphabet == Alphabet.IPA and _o2i_supports(lang):
+        return get_phonemizer(_P.ORTHOGRAPHY2IPA, alphabet, model, **kwargs)
     return get_phonemizer(_P.ESPEAK, alphabet, model, **kwargs)
 
 

{scriptconv-0.0.3a15 → scriptconv-0.0.3a17}/scriptconv/version.py

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

{scriptconv-0.0.3a15 → scriptconv-0.0.3a17}/scriptconv.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.3a15
+Version: 0.0.3a17
 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.3a15 → scriptconv-0.0.3a17}/tests/test_phonemizers_base.py

@@ -96,12 +96,34 @@ class TestLangDefaults(unittest.TestCase):
         self.assertEqual(LANG_DEFAULTS["ar"], (Phonemizer.ARBTOK,))
 
     def test_cotovia_only_for_cotovia_alphabet(self):
+        # requesting IPA must never yield Cotovía (it emits its own notation);
+        # the in-house chain falls through to orthography2ipa (or espeak)
         gl_ipa = phonemizer_for_lang("gl", alphabet=Alphabet.IPA)
-        self.assertEqual(type(gl_ipa).__name__, "EspeakPhonemizer")
-
-    def test_fallback_is_espeak(self):
-        de = phonemizer_for_lang("de-DE")
-        self.assertEqual(type(de).__name__, "EspeakPhonemizer")
+        self.assertIn(type(gl_ipa).__name__,
+                      ("Orthography2IPAPhonemizer", "EspeakPhonemizer"))
+        self.assertNotEqual(type(gl_ipa).__name__, "CotoviaPhonemizer")
+        gl_ctv = phonemizer_for_lang("gl", alphabet=Alphabet.COTOVIA)
+        self.assertEqual(type(gl_ctv).__name__, "CotoviaPhonemizer")
+
+    def test_fallback_prefers_o2i_then_espeak(self):
+        # in-house first: orthography2ipa is the usual default when it has a
+        # spec for the language; espeak only as last resort
+        from unittest import mock
+        import scriptconv.phonemizers.registry as reg
+        with mock.patch.object(reg, "_o2i_supports", return_value=True):
+            with mock.patch.object(reg, "get_phonemizer") as gp:
+                reg.phonemizer_for_lang("de-DE")
+                self.assertEqual(gp.call_args[0][0], Phonemizer.ORTHOGRAPHY2IPA)
+        with mock.patch.object(reg, "_o2i_supports", return_value=False):
+            de = reg.phonemizer_for_lang("de-DE")
+            self.assertEqual(type(de).__name__, "EspeakPhonemizer")
+
+    def test_arabic_never_falls_through(self):
+        # hard org rule: Arabic IPA only via arbtok — with arbtok ineligible
+        # (wrong alphabet), the resolver raises instead of degrading to
+        # o2i/espeak
+        with self.assertRaises((ValueError, ImportError)):
+            phonemizer_for_lang("ar", alphabet=Alphabet.ARPA)
 
     def test_override_wins(self):
         g = phonemizer_for_lang("de", override=Phonemizer.GRAPHEMES)
@@ -174,3 +196,28 @@ class TestPhonikudModelResolver(unittest.TestCase):
         with self.assertRaises(ValueError):
             g.add_diacritics("שלום", "he")
         self.assertEqual(calls, [1])
+
+
+class TestModelForwarding(unittest.TestCase):
+    def test_model_forwards_to_variant_param(self):
+        from unittest import mock
+        import scriptconv.phonemizers.registry as reg
+
+        seen = {}
+
+        class FakeEngineBackend(BasePhonemizer):
+            def __init__(self, engine=None, alphabet=Alphabet.IPA):
+                seen["engine"] = engine
+                super().__init__(alphabet)
+
+            def phonemize_string(self, text, lang):
+                return text
+
+        with mock.patch.object(reg, "get_phonemizer_class",
+                               return_value=FakeEngineBackend):
+            reg.get_phonemizer(Phonemizer.AHOTTS, model="classic")
+        self.assertEqual(seen["engine"], "classic")
+
+    def test_model_none_forwards_nothing(self):
+        g = get_phonemizer(Phonemizer.GRAPHEMES, model=None)
+        self.assertIsInstance(g, GraphemePhonemizer)