scriptconv 0.0.4a10__tar.gz → 0.0.4a12__tar.gz

{scriptconv-0.0.4a10/scriptconv.egg-info → scriptconv-0.0.4a12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.4a10
+Version: 0.0.4a12
 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.4a10 → scriptconv-0.0.4a12}/scriptconv/phonemizers/base.py

@@ -45,6 +45,25 @@ def _primary_subtag(lang: str) -> str:
     return lang.lower().replace("_", "-").split("-")[0]
 
 
+def _check_alphabet(phonemizer, alphabet: Alphabet,
+                    supported: List[Alphabet]) -> None:
+    """Reject an output alphabet a wrapper cannot emit, with a usable message.
+
+    Wrappers used to guard this with a bare ``assert``, which surfaced as an
+    ``AssertionError`` carrying an empty message — the caller learned nothing
+    about which alphabet it asked for or which ones exist. That matters because
+    :func:`~scriptconv.phonemizers.registry.get_phonemizer` injects its own
+    ``alphabet=`` default into every constructor that declares the parameter,
+    so an unsupported default is hit by ordinary registry use, not just by
+    callers passing an odd value.
+    """
+    if alphabet not in supported:
+        raise ValueError(
+            f"{type(phonemizer).__name__} cannot emit "
+            f"{Alphabet(alphabet).value!r}; supported alphabets are "
+            f"{[Alphabet(a).value for a in supported]}")
+
+
 class BasePhonemizer(metaclass=abc.ABCMeta):
     def __init__(self, alphabet: Alphabet = Alphabet.UNICODE,
                  normalizer: Optional[Callable[[str, str], str]] = None):

{scriptconv-0.0.4a10 → scriptconv-0.0.4a12}/scriptconv/phonemizers/ja.py

@@ -1,10 +1,10 @@
-from scriptconv.phonemizers.base import BasePhonemizer
+from scriptconv.phonemizers.base import BasePhonemizer, _check_alphabet
 from scriptconv.phonemizers.enums import Alphabet
 
 class OpenJTaklPhonemizer(BasePhonemizer):
 
-    def __init__(self, alphabet=Alphabet.IPA):
-        assert alphabet in [Alphabet.HEPBURN, Alphabet.KANA]
+    def __init__(self, alphabet=Alphabet.HEPBURN):
+        _check_alphabet(self, alphabet, [Alphabet.HEPBURN, Alphabet.KANA])
         import pyopenjtalk
         self.g2p = pyopenjtalk.g2p
         super().__init__(alphabet)
@@ -36,7 +36,8 @@ class OpenJTaklPhonemizer(BasePhonemizer):
 class CutletPhonemizer(BasePhonemizer):
 
     def __init__(self, alphabet=Alphabet.HEPBURN, use_foreign_spelling = False):
-        assert alphabet in [Alphabet.HEPBURN, Alphabet.KUNREI, Alphabet.NIHON]
+        _check_alphabet(self, alphabet,
+                        [Alphabet.HEPBURN, Alphabet.KUNREI, Alphabet.NIHON])
         # 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".
@@ -78,7 +79,8 @@ class CutletPhonemizer(BasePhonemizer):
 class PyKakasiPhonemizer(BasePhonemizer):
 
     def __init__(self, alphabet=Alphabet.HEPBURN):
-        assert alphabet in [Alphabet.HEPBURN, Alphabet.KANA, Alphabet.HIRA]
+        _check_alphabet(self, alphabet,
+                        [Alphabet.HEPBURN, Alphabet.KANA, Alphabet.HIRA])
         # kana, hira, hepburn
         try:
             import pykakasi

{scriptconv-0.0.4a10 → scriptconv-0.0.4a12}/scriptconv/phonemizers/ko.py

@@ -1,6 +1,6 @@
 
 
-from scriptconv.phonemizers.base import BasePhonemizer
+from scriptconv.phonemizers.base import BasePhonemizer, _check_alphabet
 from scriptconv.phonemizers._thirdparty.hangul2ipa import hangul2ipa
 from scriptconv.phonemizers.enums import Alphabet
 
@@ -9,7 +9,7 @@ class G2PKPhonemizer(BasePhonemizer):
 
     def __init__(self, descriptive=True, group_vowels=True, to_syl=True,
                  alphabet=Alphabet.IPA):
-        assert alphabet in [Alphabet.IPA, Alphabet.HANGUL]
+        _check_alphabet(self, alphabet, [Alphabet.IPA, Alphabet.HANGUL])
         try:
             from g2pk import G2p
         except ImportError as e:

{scriptconv-0.0.4a10 → scriptconv-0.0.4a12}/scriptconv/phonemizers/ru.py

@@ -5,7 +5,7 @@ Currently one backend: the Vosk-TTS front-end, wrapping the vendored
 Russian voices can be driven from text without the ``vosk-tts`` package.
 """
 import re
-from typing import List, Optional
+from typing import Iterator, List, Optional
 
 from quebra_frases import sentence_tokenize
 
@@ -86,25 +86,28 @@ class VoskPhonemizer(BasePhonemizer):
                 tokens.extend(convert(word).split())
         return tokens
 
-    def phonemize(self, text: str, lang: str) -> PhonemizedChunks:
-        """Sentence-level lists of Vosk phoneme tokens.
+    def phonemize_lazy(self, text: str, lang: str) -> Iterator[List[str]]:
+        """Sentence-level lists of Vosk phoneme tokens, one sentence at a time.
 
         Punctuation is preserved (it drives pausing); each sentence becomes one
         synthesis chunk.  Multi-character tokens (``sch``, ``bj``, ``a1``) stay
-        whole, so :meth:`BasePhonemizer.phonemize`'s per-character split is
-        deliberately bypassed.
+        whole, so :meth:`BasePhonemizer.phonemize_lazy`'s per-character split of
+        the phoneme *string* is deliberately bypassed — splitting ``s h`` into
+        characters would later fold back into ``sh`` (ш), a different phoneme.
         """
         self.get_lang(lang)
         if not text:
-            return []
+            return
         if self.normalizer is not None:
             text = self.normalizer(text, lang)
-        results: PhonemizedChunks = []
         for sentence in sentence_tokenize(text):
             tokens = self._g2p_tokens(sentence)
             if tokens:
-                results.append(tokens)
-        return results
+                yield tokens
+
+    def phonemize(self, text: str, lang: str) -> PhonemizedChunks:
+        """Sentence-level lists of Vosk phoneme tokens."""
+        return list(self.phonemize_lazy(text, lang))
 
     def phonemize_to_list(self, text: str, lang: str) -> List[str]:
         self.get_lang(lang)

{scriptconv-0.0.4a10 → scriptconv-0.0.4a12}/scriptconv/phonemizers/zh.py

@@ -3,7 +3,7 @@ import unicodedata
 from typing import List
 
 
-from scriptconv.phonemizers.base import BasePhonemizer
+from scriptconv.phonemizers.base import BasePhonemizer, _check_alphabet
 from scriptconv.phonemizers._thirdparty.zh_num import num2str
 from scriptconv.phonemizers.enums import Alphabet
 
@@ -74,7 +74,7 @@ class BaseChinesePinyinPhonemizer(BasePhonemizer):
             ipa (bool): Whether to convert pinyin to IPA.
             jieba (bool): Whether to segment text using Jieba before phonemization.
         """
-        assert alphabet in [Alphabet.PINYIN, Alphabet.IPA]
+        _check_alphabet(self, alphabet, [Alphabet.PINYIN, Alphabet.IPA])
         super().__init__(alphabet)
         self.jieba = jieba
         self.retone = retone

{scriptconv-0.0.4a10 → scriptconv-0.0.4a12}/scriptconv/version.py

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

{scriptconv-0.0.4a10 → scriptconv-0.0.4a12/scriptconv.egg-info}/PKG-INFO

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

@@ -1,6 +1,7 @@
 import unittest
 
 from scriptconv.phonemizers import Phonemizer, get_phonemizer_class
+from scriptconv.phonemizers.registry import get_phonemizer
 
 
 class TestVendoredKorean(unittest.TestCase):
@@ -174,3 +175,35 @@ class TestMantoqTokensToIpa(unittest.TestCase):
     def test_pretokenized_dbl_geminate(self):
         from scriptconv.notation import mantoq_to_ipa
         self.assertEqual(mantoq_to_ipa(["b", "_dbl_", "a"]), "bːa")
+
+
+class TestUnsupportedAlphabetIsAClearError(unittest.TestCase):
+    """A wrapper asked for an alphabet it cannot emit must say so.
+
+    ``get_phonemizer`` injects its own ``alphabet=`` default (IPA) into every
+    constructor declaring the parameter, so the Japanese wrappers — which emit
+    romanizations, never IPA — were hit by ordinary registry use and raised a
+    bare ``AssertionError`` with an empty message.
+    """
+
+    def test_registry_default_raises_valueerror_naming_the_alphabets(self):
+        from scriptconv.phonemizers.enums import Alphabet
+        for member in (Phonemizer.OPENJTALK, Phonemizer.CUTLET,
+                       Phonemizer.PYKAKASI):
+            with self.subTest(phonemizer=member.value):
+                try:
+                    get_phonemizer(member)
+                except ImportError:
+                    self.skipTest(f"{member.value} backend not installed")
+                except ValueError as e:
+                    self.assertIn("ipa", str(e))
+                    self.assertIn(Alphabet.HEPBURN.value, str(e))
+                else:
+                    self.fail("expected ValueError for an unemittable alphabet")
+
+    def test_openjtalk_default_alphabet_is_one_it_can_emit(self):
+        cls = get_phonemizer_class(Phonemizer.OPENJTALK)
+        import inspect
+        from scriptconv.phonemizers.enums import Alphabet
+        default = inspect.signature(cls.__init__).parameters["alphabet"].default
+        self.assertIn(default, (Alphabet.HEPBURN, Alphabet.KANA))

{scriptconv-0.0.4a10 → scriptconv-0.0.4a12}/tests/test_phonemizers_ru.py

@@ -209,6 +209,21 @@ class TestVoskRegistration(unittest.TestCase):
         p = phonemizer_for_lang("ru", alphabet=Alphabet.IPA)
         self.assertNotIsInstance(p, VoskPhonemizer)
 
+    def test_phonemize_lazy_keeps_tokens_whole(self):
+        # the lazy path is what consumers stream through: it must yield the same
+        # whole phoneme tokens as phonemize(), never a per-character split
+        # ("s", "h" would otherwise fold back into "sh" — a different phoneme)
+        p = VoskPhonemizer()
+        text = "Сходить в кино. Счастье рядом!"
+        self.assertEqual(list(p.phonemize_lazy(text, "ru")), p.phonemize(text, "ru"))
+        flat = [t for chunk in p.phonemize_lazy(text, "ru") for t in chunk]
+        self.assertIn("s", flat)
+        self.assertIn("h", flat)
+        self.assertTrue(all(len(t) <= 3 for t in flat))
+        # every emitted token is a real phoneme/pause, not a bare character of one
+        self.assertNotIn("0", flat)
+        self.assertNotIn("1", flat)
+
     def test_module_level_phonemize_facade(self):
         self.assertEqual(phonemize("Привет", "ru", alphabet=Alphabet.VOSK),
                          "p rj i0 vj e0 t")