scriptconv 0.0.4a8__tar.gz → 0.0.4a10__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.4a8
+Version: 0.0.4a10
 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
@@ -350,7 +350,8 @@ phonemize("hello", "en", override=Phonemizer.GRUUT)
 
 Defaults resolve in-house engines first: an explicit per-language chain
 (Arabic → arbtok, Basque → euskaphone, Mirandese, Portuguese → tugaphone,
-Hebrew → phonikud, Galician → Cotovía for its own notation), then
+Hebrew → phonikud, Galician → Cotovía and Russian → vosk for their own
+notations), then
 orthography2ipa wherever it has a language spec, then espeak as the last
 resort. Arabic never falls back past arbtok — a missing engine raises rather
 than silently degrading. Every backend resolves lazily; a missing package

{scriptconv-0.0.4a8 → scriptconv-0.0.4a10}/README.md

@@ -223,7 +223,8 @@ phonemize("hello", "en", override=Phonemizer.GRUUT)
 
 Defaults resolve in-house engines first: an explicit per-language chain
 (Arabic → arbtok, Basque → euskaphone, Mirandese, Portuguese → tugaphone,
-Hebrew → phonikud, Galician → Cotovía for its own notation), then
+Hebrew → phonikud, Galician → Cotovía and Russian → vosk for their own
+notations), then
 orthography2ipa wherever it has a language spec, then espeak as the last
 resort. Arabic never falls back past arbtok — a missing engine raises rather
 than silently degrading. Every backend resolves lazily; a missing package

scriptconv-0.0.4a10/scriptconv/phonemizers/_thirdparty/vosk_g2p.py

@@ -0,0 +1,135 @@
+"""
+Russian grapheme-to-phoneme rules and pronunciation-dictionary loader for the
+Vosk-TTS voices.
+
+Vendored from ``vosk_tts/g2p.py`` — https://github.com/alphacep/vosk-tts
+(Apache-2.0) — so the Vosk Russian front-end is available without the
+``vosk-tts`` package at runtime.
+
+``convert`` is a faithful port of ``vosk_tts/g2p.py``: it turns an (optionally
+stress-marked) Russian word into the Vosk phoneme inventory — palatalised
+consonants get a trailing ``j`` (``bj``, ``tj`` …), vowels carry a stress digit
+(``a0`` unstressed, ``a1`` stressed). A ``+`` immediately before a vowel marks
+it as stressed; without any ``+`` every vowel is emitted unstressed.
+
+The shipped ``dictionary`` file (word → phonemes) overrides the rules for known
+words; ``load_dictionary`` reads both the historical ``word phon…`` layout and
+the newer ``word prob phon…`` layout (keeping the highest-probability variant).
+The rules alone already produce usable Russian, so the dictionary is optional.
+"""
+import os
+from typing import Dict, List, Optional
+
+# Cyrillic letters that soften the preceding consonant.
+softletters = set(u"яёюиье")
+# Contexts after which я/ю/е/ё gains a leading glide /j/.
+startsyl = set(u"#ъьаяоёуюэеиы-")
+# Markers dropped from the final phoneme stream.
+others = set(["#", "+", "-", u"ь", u"ъ"])
+
+softhard_cons = {
+    u"б": u"b", u"в": u"v", u"г": u"g", u"Г": u"g", u"д": u"d",
+    u"з": u"z", u"к": u"k", u"л": u"l", u"м": u"m", u"н": u"n",
+    u"п": u"p", u"р": u"r", u"с": u"s", u"т": u"t", u"ф": u"f",
+    u"х": u"h",
+}
+
+other_cons = {
+    u"ж": u"zh", u"ц": u"c", u"ч": u"ch", u"ш": u"sh",
+    u"щ": u"sch", u"й": u"j",
+}
+
+vowels = {
+    u"а": u"a", u"я": u"a", u"у": u"u", u"ю": u"u", u"о": u"o",
+    u"ё": u"o", u"э": u"e", u"е": u"e", u"и": u"i", u"ы": u"y",
+}
+
+
+def pallatize(phones: List[tuple]) -> None:
+    """In-place: map consonants to their (palatalised) phoneme, looking one
+    character ahead to decide whether a soft vowel follows."""
+    for i, phone in enumerate(phones[:-1]):
+        if phone[0] in softhard_cons:
+            if phones[i + 1][0] in softletters:
+                phones[i] = (softhard_cons[phone[0]] + "j", 0)
+            else:
+                phones[i] = (softhard_cons[phone[0]], 0)
+        if phone[0] in other_cons:
+            phones[i] = (other_cons[phone[0]], 0)
+
+
+def convert_vowels(phones: List[tuple]) -> List[str]:
+    """Emit vowels with their stress digit, inserting a glide /j/ before
+    iotated vowels at syllable starts."""
+    new_phones: List[str] = []
+    prev = ""
+    for phone in phones:
+        if prev in startsyl:
+            if phone[0] in set(u"яюеё"):
+                new_phones.append("j")
+        if phone[0] in vowels:
+            new_phones.append(vowels[phone[0]] + str(phone[1]))
+        else:
+            new_phones.append(phone[0])
+        prev = phone[0]
+    return new_phones
+
+
+def convert(stressword: str) -> str:
+    """Convert a (possibly ``+``-stress-marked) Russian word to a
+    space-separated Vosk phoneme string."""
+    phones = ("#" + stressword + "#")
+
+    # Assign stress marks: a '+' sets the stress flag for the next character.
+    stress_phones = []
+    stress = 0
+    for phone in phones:
+        if phone == "+":
+            stress = 1
+        else:
+            stress_phones.append((phone, stress))
+            stress = 0
+
+    pallatize(stress_phones)
+    phones = convert_vowels(stress_phones)
+    phones = [x for x in phones if x not in others]
+    return " ".join(phones)
+
+
+def load_dictionary(path: Optional[str]) -> Dict[str, List[str]]:
+    """
+    Load a Vosk pronunciation dictionary into a ``word -> [phoneme, …]`` map.
+
+    Handles both file layouts:
+      - ``word phon1 phon2 …``            (older voices, e.g. 0.1)
+      - ``word prob phon1 phon2 …``       (newer voices; highest prob wins)
+
+    Returns an empty dict when ``path`` is falsy or missing — the rule-based
+    :func:`convert` fallback covers any out-of-dictionary word.
+    """
+    dic: Dict[str, List[str]] = {}
+    if not path or not os.path.isfile(path):
+        return dic
+    probs: Dict[str, float] = {}
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            parts = line.split()
+            if len(parts) < 2:
+                continue
+            word, rest = parts[0], parts[1:]
+            # The second column is a probability only when it parses as a float;
+            # a real phoneme (a0, sch, …) never does.
+            try:
+                prob = float(rest[0])
+                phones = rest[1:]
+            except ValueError:
+                prob = None
+                phones = rest
+            if not phones:
+                continue
+            if prob is None:
+                dic.setdefault(word, phones)
+            elif probs.get(word, -1.0) < prob:
+                dic[word] = phones
+                probs[word] = prob
+    return dic

{scriptconv-0.0.4a8 → scriptconv-0.0.4a10}/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.4a8 → scriptconv-0.0.4a10}/scriptconv/phonemizers/enums.py

@@ -30,6 +30,7 @@ class Alphabet(str, Enum):
     BUCKWALTER = "buckwalter"
     MANTOQ = "mantoq"  # ar — Halabi Arabic-Phonetiser inventory # ar
     CANGJIE = "cangjie" # zh (Cangjie input method)
+    VOSK = "vosk" # ru — vosk-tts phoneme inventory (a0, bj, sch ...)
     GRAPHEMES = "graphemes"  # plain text / grapheme input (user-side)
 
 
@@ -73,6 +74,7 @@ class Phonemizer(str, Enum):
     PYPINYIN = "pypinyin" # chinese
     XPINYIN = "xpinyin" # chinese
     JIEBA = "jieba" # chinese  (not a real phonemizer!)
+    VOSK = "vosk"  # russian  (no ipa!)
     SHAMI = "shami"  # Levantine Arabic / English code-switching (ShamiVITS)
     ARBTOK = "arbtok"  # arabic (dialect-aware, undiacritized text; o2i lattice)
     EUSKAPHONE = "euskaphone"  # basque (dialect-aware; o2i lattice)

{scriptconv-0.0.4a8 → scriptconv-0.0.4a10}/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.4a8 → scriptconv-0.0.4a10}/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.4a8 → scriptconv-0.0.4a10}/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.4a8 → scriptconv-0.0.4a10}/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.4a8 → scriptconv-0.0.4a10}/scriptconv/phonemizers/registry.py

@@ -71,6 +71,7 @@ PHONEMIZER_REGISTRY: Dict[Phonemizer, Tuple[str, str, Optional[str]]] = {
     _P.MANTOQ: (f"{_BASE}.ar", "MantoqPhonemizer", "ar-phonemizers"),
     _P.ARBTOK: (f"{_BASE}.ar", "ArbtokPhonemizer", "ar-phonemizers"),
     _P.SHAMI: (f"{_BASE}.shami", "ShamiPhonemizer", "shami"),
+    _P.VOSK: (f"{_BASE}.ru", "VoskPhonemizer", "phonemizers"),
 }
 
 
@@ -135,6 +136,7 @@ _EMITS: Dict[Phonemizer, Tuple[Alphabet, ...]] = {
     _P.TUGAPHONE: (Alphabet.IPA,),
     _P.PHONIKUD: (Alphabet.IPA,),
     _P.COTOVIA: (Alphabet.COTOVIA,),
+    _P.VOSK: (Alphabet.VOSK,),
     _P.ESPEAK: (Alphabet.IPA,),
 }
 
@@ -147,6 +149,9 @@ LANG_DEFAULTS: Dict[str, Tuple[Phonemizer, ...]] = {
     "pt": (_P.TUGAPHONE,),
     "he": (_P.PHONIKUD,),
     "gl": (_P.COTOVIA, _P.ORTHOGRAPHY2IPA, _P.ESPEAK),
+    # vosk emits its own inventory, so it is the Russian default only
+    # when that notation is requested (same shape as Cotovía above)
+    "ru": (_P.VOSK, _P.ORTHOGRAPHY2IPA, _P.ESPEAK),
 }
 
 # Languages whose explicit entry is exhaustive: no generic fallback beyond it.

scriptconv-0.0.4a10/scriptconv/phonemizers/ru.py

@@ -0,0 +1,114 @@
+"""Russian phonemizers.
+
+Currently one backend: the Vosk-TTS front-end, wrapping the vendored
+:mod:`scriptconv.phonemizers._thirdparty.vosk_g2p` rules so the alphacep
+Russian voices can be driven from text without the ``vosk-tts`` package.
+"""
+import re
+from typing import List, Optional
+
+from quebra_frases import sentence_tokenize
+
+from scriptconv.phonemizers.base import BasePhonemizer, PhonemizedChunks
+from scriptconv.phonemizers.enums import Alphabet
+from scriptconv.phonemizers._thirdparty.vosk_g2p import convert, load_dictionary
+
+__all__ = ["VoskPhonemizer"]
+
+
+class VoskPhonemizer(BasePhonemizer):
+    """
+    Russian phonemizer for the Vosk-TTS voices (alphacep).
+
+    It reproduces ``vosk_tts``'s grapheme-to-phoneme exactly: each word is
+    looked up in the voice's pronunciation ``dictionary`` (word -> phonemes),
+    falling back to the rule-based
+    :func:`~scriptconv.phonemizers._thirdparty.vosk_g2p.convert` for
+    out-of-dictionary words.  Spaces and punctuation are kept as their own
+    tokens (Vosk feeds them to the model as short/long pauses); the BOS ``^`` /
+    EOS ``$`` markers and the inter-phoneme blanks belong to the consumer's
+    tokenizer, so they are *not* emitted here.
+
+    The output is the Vosk phoneme inventory (``a0``, ``bj``, ``sch`` …), not
+    IPA, so the only supported alphabet is :attr:`Alphabet.VOSK` — like
+    Cotovía, this backend is eligible only when its own notation is requested.
+
+    The dictionary is optional: without it the rules alone still produce usable
+    Russian (only the curated stress and exception entries are lost).
+    scriptconv never downloads anything — the caller resolves the file and
+    passes its path as ``model`` (the registry's ``phonemizer_model`` knob).
+
+    Args:
+        alphabet (Alphabet): must be :attr:`Alphabet.VOSK`.
+        model (Optional[str]): path to the voice's ``dictionary`` file.  When
+            absent or missing, only the rule-based fallback is used.
+    """
+
+    # Matches the per-character split used by vosk_tts: spaces and punctuation
+    # are captured so they survive as standalone pause tokens.
+    _SPLIT = re.compile(r'([,.?!;:"() ])')
+
+    def __init__(self, alphabet: Alphabet = Alphabet.VOSK,
+                 model: Optional[str] = None):
+        if alphabet != Alphabet.VOSK:
+            raise ValueError(
+                "VoskPhonemizer emits the vosk-tts phoneme inventory, not "
+                f"{Alphabet(alphabet).value!r} — use Alphabet.VOSK")
+        self._dict_path = model
+        self._dictionary: Optional[dict] = None  # lazy: dictionaries are large
+        super().__init__(alphabet)
+
+    @property
+    def dictionary(self) -> dict:
+        """The loaded ``word -> [phoneme, …]`` map (empty without a path)."""
+        if self._dictionary is None:
+            self._dictionary = load_dictionary(self._dict_path)
+        return self._dictionary
+
+    @classmethod
+    def get_lang(cls, target_lang: str) -> str:
+        return cls.match_lang(target_lang, ["ru-RU"])
+
+    def _g2p_tokens(self, text: str) -> List[str]:
+        """Word/punctuation stream -> Vosk phoneme tokens (no BOS/EOS/blanks)."""
+        tokens: List[str] = []
+        # the em dash is a pause, and vosk only knows the ASCII hyphen
+        text = text.replace("—", "-")
+        for word in self._SPLIT.split(text.lower()):
+            if word == "":
+                continue
+            if self._SPLIT.match(word) or word == "-":
+                # space or punctuation: kept verbatim as a pause token
+                tokens.append(word)
+            elif word in self.dictionary:
+                tokens.extend(self.dictionary[word])
+            else:
+                tokens.extend(convert(word).split())
+        return tokens
+
+    def phonemize(self, text: str, lang: str) -> PhonemizedChunks:
+        """Sentence-level lists of Vosk phoneme tokens.
+
+        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.
+        """
+        self.get_lang(lang)
+        if not text:
+            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
+
+    def phonemize_to_list(self, text: str, lang: str) -> List[str]:
+        self.get_lang(lang)
+        return self._g2p_tokens(text.lower())
+
+    def phonemize_string(self, text: str, lang: str) -> str:
+        return " ".join(self.phonemize_to_list(text, lang))

{scriptconv-0.0.4a8 → scriptconv-0.0.4a10}/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.4a8 → scriptconv-0.0.4a10}/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.4a8 → scriptconv-0.0.4a10}/scriptconv/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.4a8
+Version: 0.0.4a10
 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
@@ -350,7 +350,8 @@ phonemize("hello", "en", override=Phonemizer.GRUUT)
 
 Defaults resolve in-house engines first: an explicit per-language chain
 (Arabic → arbtok, Basque → euskaphone, Mirandese, Portuguese → tugaphone,
-Hebrew → phonikud, Galician → Cotovía for its own notation), then
+Hebrew → phonikud, Galician → Cotovía and Russian → vosk for their own
+notations), then
 orthography2ipa wherever it has a language spec, then espeak as the last
 resort. Arabic never falls back past arbtok — a missing engine raises rather
 than silently degrading. Every backend resolves lazily; a missing package