scriptconv 0.0.4a9__tar.gz → 0.0.4a10__tar.gz

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.4a9
+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.4a9 → scriptconv-0.0.4a10}/scriptconv.egg-info/SOURCES.txt

@@ -37,12 +37,14 @@ scriptconv/phonemizers/mwl.py
 scriptconv/phonemizers/o2ipa.py
 scriptconv/phonemizers/pt.py
 scriptconv/phonemizers/registry.py
+scriptconv/phonemizers/ru.py
 scriptconv/phonemizers/shami.py
 scriptconv/phonemizers/vi.py
 scriptconv/phonemizers/zh.py
 scriptconv/phonemizers/_thirdparty/__init__.py
 scriptconv/phonemizers/_thirdparty/bw2ipa.py
 scriptconv/phonemizers/_thirdparty/hangul2ipa.py
+scriptconv/phonemizers/_thirdparty/vosk_g2p.py
 scriptconv/phonemizers/_thirdparty/zh_num.py
 scriptconv/phonemizers/_thirdparty/ko_tables/aspiration.csv
 scriptconv/phonemizers/_thirdparty/ko_tables/assimilation.csv
@@ -87,6 +89,7 @@ tests/test_notation.py
 tests/test_phonemizers_base.py
 tests/test_phonemizers_cjk_ar.py
 tests/test_phonemizers_friendly_import_errors.py
+tests/test_phonemizers_ru.py
 tests/test_readings.py
 tests/test_readings_zh.py
 tests/test_scripts.py

{scriptconv-0.0.4a9 → scriptconv-0.0.4a10}/tests/test_phonemizers_base.py

@@ -21,9 +21,11 @@ class TestEnums(unittest.TestCase):
         self.assertEqual(Phonemizer.ARBTOK.value, "arbtok")
         self.assertEqual(Phonemizer.MIRANDESE.value, "mwl_phonemizer")
         self.assertEqual(Phonemizer.KOG2PK.value, "kog2p")
+        self.assertEqual(Phonemizer.VOSK.value, "vosk")
         self.assertEqual(Alphabet.XSAMPA.value, "x-sampa")
-        self.assertEqual(len(list(Phonemizer)), 41)
-        self.assertEqual(len(list(Alphabet)), 21)  # incl. MANTOQ
+        self.assertEqual(Alphabet.VOSK.value, "vosk")
+        self.assertEqual(len(list(Phonemizer)), 42)
+        self.assertEqual(len(list(Alphabet)), 22)  # incl. MANTOQ, VOSK
 
 
 class TestRegistryCompleteness(unittest.TestCase):

scriptconv-0.0.4a10/tests/test_phonemizers_ru.py

@@ -0,0 +1,218 @@
+"""Tests for the Russian (vosk-tts) phonemizer and its vendored G2P rules."""
+import os
+import tempfile
+import unittest
+
+from scriptconv.phonemizers import (
+    Alphabet,
+    Phonemizer,
+    PHONEMIZER_REGISTRY,
+    get_phonemizer,
+    phonemize,
+    phonemizer_for_lang,
+)
+from scriptconv.phonemizers._thirdparty.vosk_g2p import convert, load_dictionary
+from scriptconv.phonemizers.ru import VoskPhonemizer
+
+
+class TestVoskRules(unittest.TestCase):
+    """The vendored rules, exercised directly (no dictionary involved)."""
+
+    def test_palatalization_before_soft_vowel(self):
+        # рь/ви soften: r -> rj, v -> vj; unstressed vowels get the 0 digit
+        self.assertEqual(convert("привет"), "p rj i0 vj e0 t")
+
+    def test_hard_consonant_before_hard_vowel(self):
+        self.assertEqual(convert("как"), "k a0 k")
+
+    def test_plus_marks_the_next_vowel_as_stressed(self):
+        self.assertEqual(convert("прив+ет"), "p rj i0 vj e1 t")
+        # without the marker every vowel is unstressed
+        self.assertEqual(convert("привет"), "p rj i0 vj e0 t")
+
+    def test_stress_marker_only_affects_its_own_vowel(self):
+        self.assertEqual(convert("м+олоко"), "m o1 l o0 k o0")
+        self.assertEqual(convert("молок+о"), "m o0 l o0 k o1")
+
+    def test_multi_character_phonemes(self):
+        # щ -> sch, ш -> sh, ж -> zh, ч -> ch, ц -> c
+        self.assertEqual(convert("щука"), "sch u0 k a0")
+        self.assertEqual(convert("шар"), "sh a0 r")
+        self.assertEqual(convert("жук"), "zh u0 k")
+        self.assertEqual(convert("час"), "ch a0 s")
+        self.assertEqual(convert("цирк"), "c i0 r k")
+
+    def test_iotated_vowel_gains_a_glide_at_syllable_start(self):
+        self.assertEqual(convert("яма"), "j a0 m a0")
+        self.assertEqual(convert("ёж"), "j o0 zh")
+        # ... but not after a consonant, where it palatalizes instead
+        self.assertEqual(convert("тётя"), "tj o0 tj a0")
+
+    def test_soft_and_hard_signs_are_dropped_from_the_stream(self):
+        out = convert("съешь")
+        self.assertEqual(out, "s j e0 sh")
+        self.assertNotIn("ь", out)
+        self.assertNotIn("ъ", out)
+
+    def test_empty_word_yields_empty_string(self):
+        self.assertEqual(convert(""), "")
+
+    def test_non_cyrillic_passes_through_verbatim(self):
+        self.assertEqual(convert("abc"), "a b c")
+
+
+class TestLoadDictionary(unittest.TestCase):
+    def _write(self, content: str) -> str:
+        fd, path = tempfile.mkstemp(suffix=".dict")
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(content)
+        self.addCleanup(os.remove, path)
+        return path
+
+    def test_missing_path_yields_empty_map(self):
+        self.assertEqual(load_dictionary(None), {})
+        self.assertEqual(load_dictionary("/nonexistent/vosk/dictionary"), {})
+
+    def test_legacy_layout_word_then_phonemes(self):
+        path = self._write("привет p rj i0 vj e1 t\nкак k a1 k\n")
+        dic = load_dictionary(path)
+        self.assertEqual(dic["привет"], ["p", "rj", "i0", "vj", "e1", "t"])
+        self.assertEqual(dic["как"], ["k", "a1", "k"])
+
+    def test_probability_layout_keeps_highest_variant(self):
+        path = self._write("что 0.2 ch t o1\nчто 0.8 sh t o1\n")
+        self.assertEqual(load_dictionary(path)["что"], ["sh", "t", "o1"])
+
+    def test_legacy_layout_keeps_first_variant(self):
+        path = self._write("что ch t o1\nчто sh t o1\n")
+        self.assertEqual(load_dictionary(path)["что"], ["ch", "t", "o1"])
+
+    def test_blank_and_short_lines_ignored(self):
+        path = self._write("\n\nдом d o1 m\nбезфонем\n   \n")
+        dic = load_dictionary(path)
+        self.assertEqual(list(dic), ["дом"])
+
+
+class TestVoskPhonemizer(unittest.TestCase):
+    def setUp(self):
+        self.p = VoskPhonemizer()
+
+    def test_sentence_string(self):
+        self.assertEqual(self.p.phonemize_string("Привет, как дела?", "ru"),
+                         "p rj i0 vj e0 t ,   k a0 k   dj e0 l a0 ?")
+
+    def test_case_is_folded(self):
+        self.assertEqual(self.p.phonemize_string("ПРИВЕТ", "ru"),
+                         self.p.phonemize_string("привет", "ru"))
+
+    def test_punctuation_and_space_survive_as_tokens(self):
+        toks = self.p.phonemize_to_list("да, нет!", "ru")
+        self.assertIn(",", toks)
+        self.assertIn(" ", toks)
+        self.assertEqual(toks[-1], "!")
+
+    def test_multi_char_tokens_stay_whole(self):
+        # the base class would split "sch" into s/c/h — this backend must not
+        self.assertIn("sch", self.p.phonemize_to_list("щука", "ru"))
+
+    def test_em_dash_becomes_a_hyphen_pause(self):
+        toks = self.p.phonemize_to_list("Москва — столица", "ru")
+        self.assertIn("-", toks)
+        self.assertNotIn("—", toks)
+
+    def test_phonemize_returns_one_list_per_sentence(self):
+        chunks = self.p.phonemize("Привет. Как дела?", "ru")
+        self.assertEqual(len(chunks), 2)
+        self.assertTrue(all(isinstance(c, list) for c in chunks))
+        self.assertEqual(chunks[0][:3], ["p", "rj", "i0"])
+
+    def test_empty_text_yields_no_chunks(self):
+        self.assertEqual(self.p.phonemize("", "ru"), [])
+        self.assertEqual(self.p.phonemize_to_list("", "ru"), [])
+        self.assertEqual(self.p.phonemize_string("", "ru"), "")
+
+    def test_punctuation_only_input(self):
+        self.assertEqual(self.p.phonemize_to_list("...", "ru"), [".", ".", "."])
+
+    def test_non_cyrillic_input_is_not_dropped(self):
+        # OOV latin text has no vosk rule; it must survive rather than vanish
+        self.assertEqual(self.p.phonemize_string("hello world", "ru"),
+                         "h e l l o   w o r l d")
+
+    def test_digits_survive_unnormalized(self):
+        # scriptconv performs no normalization of its own
+        self.assertIn("3", self.p.phonemize_to_list("3 кота", "ru"))
+
+    def test_normalizer_hook_runs_before_g2p(self):
+        p = VoskPhonemizer()
+        p.normalizer = lambda t, l: t.replace("3", "три")
+        self.assertEqual(p.phonemize("3", "ru"), [["t", "rj", "i0"]])
+
+    def test_rejects_unsupported_language(self):
+        with self.assertRaises(ValueError):
+            self.p.phonemize_string("hello", "en-US")
+        with self.assertRaises(ValueError):
+            self.p.phonemize("привет", "zh-CN")
+
+    def test_rejects_non_vosk_alphabet(self):
+        with self.assertRaises(ValueError):
+            VoskPhonemizer(alphabet=Alphabet.IPA)
+
+    def test_dictionary_overrides_the_rules(self):
+        fd, path = tempfile.mkstemp(suffix=".dict")
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write("привет 1.0 p rj i0 vj e1 t\n")
+        self.addCleanup(os.remove, path)
+        p = VoskPhonemizer(model=path)
+        # e1 (stressed) comes from the dictionary; the rules alone give e0
+        self.assertEqual(p.phonemize_string("привет", "ru"),
+                         "p rj i0 vj e1 t")
+        # an out-of-dictionary word still falls back to the rules
+        self.assertEqual(p.phonemize_string("щука", "ru"), "sch u0 k a0")
+
+    def test_missing_dictionary_falls_back_to_rules(self):
+        p = VoskPhonemizer(model="/nonexistent/vosk/dictionary")
+        self.assertEqual(p.dictionary, {})
+        self.assertEqual(p.phonemize_string("привет", "ru"), "p rj i0 vj e0 t")
+
+    def test_dictionary_is_lazy(self):
+        p = VoskPhonemizer(model="/nonexistent/vosk/dictionary")
+        self.assertIsNone(p._dictionary)
+        p.dictionary
+        self.assertIsNotNone(p._dictionary)
+
+
+class TestVoskRegistration(unittest.TestCase):
+    def test_registered(self):
+        self.assertIn(Phonemizer.VOSK, PHONEMIZER_REGISTRY)
+
+    def test_get_phonemizer_builds_it(self):
+        p = get_phonemizer(Phonemizer.VOSK, Alphabet.VOSK)
+        self.assertIsInstance(p, VoskPhonemizer)
+
+    def test_model_threads_through_the_phonemizer_model_knob(self):
+        fd, path = tempfile.mkstemp(suffix=".dict")
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write("дом 1.0 d o1 m\n")
+        self.addCleanup(os.remove, path)
+        p = get_phonemizer(Phonemizer.VOSK, Alphabet.VOSK, model=path)
+        self.assertEqual(p.phonemize_string("дом", "ru"), "d o1 m")
+
+    def test_russian_default_for_vosk_alphabet(self):
+        p = phonemizer_for_lang("ru", alphabet=Alphabet.VOSK)
+        self.assertIsInstance(p, VoskPhonemizer)
+        self.assertIsInstance(phonemizer_for_lang("ru-RU", alphabet=Alphabet.VOSK),
+                              VoskPhonemizer)
+
+    def test_vosk_never_selected_for_ipa(self):
+        # it emits its own inventory — requesting IPA must fall through
+        p = phonemizer_for_lang("ru", alphabet=Alphabet.IPA)
+        self.assertNotIsInstance(p, VoskPhonemizer)
+
+    def test_module_level_phonemize_facade(self):
+        self.assertEqual(phonemize("Привет", "ru", alphabet=Alphabet.VOSK),
+                         "p rj i0 vj e0 t")
+
+
+if __name__ == "__main__":
+    unittest.main()