python-voiceio 1.12.0__tar.gz → 1.13.0__tar.gz

{python_voiceio-1.12.0/python_voiceio.egg-info → python_voiceio-1.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 1.12.0
+Version: 1.13.0
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT
@@ -65,7 +65,7 @@ Dynamic: license-file
 **[Try it in your browser at voiceio.dev](https://voiceio.dev)**: no install, the model runs in the tab.
 
 - **Types anywhere.** Press your hotkey, speak, and the words stream into the focused app with a live underlined preview (IBus), on Wayland and X11: GNOME, KDE, Hyprland, sway, i3.
-- **Runs on your machine.** Whisper, or NVIDIA's Parakeet (about 2x faster, with every name you use as a hotword), decodes your speech locally. No account, no server, no telemetry; logs never contain your words.
+- **Runs on your machine.** Whisper, or NVIDIA's Parakeet (text lands ~0.7 s after you stop talking instead of ~4.4 s, with every name you use as a hotword), decodes your speech locally. No account, no server, no telemetry; logs never contain your words.
 - **Learns your words.** Keep your recordings (opt-in, on your disk) and voiceio fine-tunes its model on them while the machine is idle. It switches only when the new model wins on clips it never trained on. On the author's voice: 12.1% → 4.9% word errors after one night on a laptop CPU.
 
 ## Install

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/README.md

@@ -12,7 +12,7 @@
 **[Try it in your browser at voiceio.dev](https://voiceio.dev)**: no install, the model runs in the tab.
 
 - **Types anywhere.** Press your hotkey, speak, and the words stream into the focused app with a live underlined preview (IBus), on Wayland and X11: GNOME, KDE, Hyprland, sway, i3.
-- **Runs on your machine.** Whisper, or NVIDIA's Parakeet (about 2x faster, with every name you use as a hotword), decodes your speech locally. No account, no server, no telemetry; logs never contain your words.
+- **Runs on your machine.** Whisper, or NVIDIA's Parakeet (text lands ~0.7 s after you stop talking instead of ~4.4 s, with every name you use as a hotword), decodes your speech locally. No account, no server, no telemetry; logs never contain your words.
 - **Learns your words.** Keep your recordings (opt-in, on your disk) and voiceio fine-tunes its model on them while the machine is idle. It switches only when the new model wins on clips it never trained on. On the author's voice: 12.1% → 4.9% word errors after one night on a laptop CPU.
 
 ## Install

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "1.12.0"
+version = "1.13.0"
 description = "Voice dictation for Linux. Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"

{python_voiceio-1.12.0 → python_voiceio-1.13.0/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 1.12.0
+Version: 1.13.0
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT
@@ -65,7 +65,7 @@ Dynamic: license-file
 **[Try it in your browser at voiceio.dev](https://voiceio.dev)**: no install, the model runs in the tab.
 
 - **Types anywhere.** Press your hotkey, speak, and the words stream into the focused app with a live underlined preview (IBus), on Wayland and X11: GNOME, KDE, Hyprland, sway, i3.
-- **Runs on your machine.** Whisper, or NVIDIA's Parakeet (about 2x faster, with every name you use as a hotword), decodes your speech locally. No account, no server, no telemetry; logs never contain your words.
+- **Runs on your machine.** Whisper, or NVIDIA's Parakeet (text lands ~0.7 s after you stop talking instead of ~4.4 s, with every name you use as a hotword), decodes your speech locally. No account, no server, no telemetry; logs never contain your words.
 - **Learns your words.** Keep your recordings (opt-in, on your disk) and voiceio fine-tunes its model on them while the machine is idle. It switches only when the new model wins on clips it never trained on. On the author's voice: 12.1% → 4.9% word errors after one night on a laptop CPU.
 
 ## Install

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/python_voiceio.egg-info/SOURCES.txt

@@ -208,6 +208,7 @@ voiceio/tts/edge_engine.py
 voiceio/tts/espeak.py
 voiceio/tts/piper_engine.py
 voiceio/tts/player.py
+voiceio/tts/supertonic_engine.py
 voiceio/typers/__init__.py
 voiceio/typers/base.py
 voiceio/typers/chain.py

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/tests/test_sherpa.py

@@ -195,7 +195,8 @@ def test_default_is_parakeet_only_when_sherpa_has_the_fix(monkeypatch):
     assert catalog.default_model("en") == "small"
     monkeypatch.setattr(sherpa, "features", lambda: SherpaFeatures(True, True, False))
     assert catalog.default_model("en") == catalog.PARAKEET
-    assert catalog.default_model("es") == "small"     # Parakeet v2 is English only
+    assert catalog.default_model("es") == catalog.PARAKEET_V3
+    assert catalog.default_model("ja") == "small"      # outside Parakeet v3's languages
 
 
 def test_config_resolves_unset_or_auto_name_but_an_explicit_choice_wins(monkeypatch, tmp_path):
@@ -343,6 +344,10 @@ def test_doctor_reports_the_decoder(monkeypatch):
     assert "aren't used" in _learning_status(cfg)["Voice model"]
     cfg.model.name = "small"
     assert catalog.PARAKEET in _decoder_status(cfg)["Decoder"]
+    cfg.model.language = "es"
+    assert catalog.PARAKEET_V3 in _decoder_status(cfg)["Decoder"]
+    cfg.model.language = "ja"
+    assert _decoder_status(cfg) == {}
 
 
 def test_eval_results_are_found_for_sherpa_models(monkeypatch, tmp_path):

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/tests/test_tts.py

@@ -423,3 +423,79 @@ def test_piper_shutdown_releases_voice():
     engine._voice = MagicMock()
     engine.shutdown()
     assert engine._voice is None
+
+
+# ── supertonic tests ─────────────────────────────────────────────────
+
+class _FakeGenerated:
+    samples = [0.0, 0.5, -1.5]
+    sample_rate = 44100
+
+
+def _fake_sherpa(calls):
+    so = MagicMock()
+
+    class Tts:
+        def __init__(self, config):
+            calls["config"] = config
+
+        def generate(self, text, gen):
+            calls["text"], calls["gen"] = text, gen
+            return _FakeGenerated()
+
+    so.OfflineTts = Tts
+    so.GenerationConfig = lambda: type("G", (), {})()
+    return so
+
+
+def _supertonic_dir(path):
+    from voiceio.tts import supertonic_engine as st
+    for stem in st._STEMS:
+        (path / f"{stem}.int8.onnx").write_bytes(b"")
+    for f in st._FILES:
+        (path / f).write_bytes(b"")
+    return path
+
+
+def test_supertonic_probe_needs_supertonic_in_sherpa():
+    from voiceio.tts.supertonic_engine import SupertonicEngine
+    old = MagicMock(spec=[])   # a sherpa-onnx without OfflineTtsSupertonicModelConfig
+    with patch.dict("sys.modules", {"sherpa_onnx": old}):
+        assert not SupertonicEngine().probe().ok
+    with patch.dict("sys.modules", {"sherpa_onnx": MagicMock()}):
+        assert SupertonicEngine().probe().ok
+
+
+def test_supertonic_reads_in_its_language_and_returns_int16(tmp_path):
+    from voiceio.tts import supertonic_engine as st
+    calls = {}
+    model = _supertonic_dir(tmp_path)
+    with patch.dict("sys.modules", {"sherpa_onnx": _fake_sherpa(calls)}), \
+            patch("voiceio.core.decoders.fetch.download_archive", return_value=model) as dl:
+        engine = st.SupertonicEngine(language="es")
+        audio, rate = engine.synthesize("hola", voice="", speed=0)
+        engine.synthesize("otra vez", voice="2", speed=1.2)
+    dl.assert_called_once()                       # loaded once, then reused
+    assert dl.call_args.args[0] == st.MODEL
+    assert calls["gen"].extra == {"lang": "es"}
+    assert calls["gen"].sid == 2 and calls["gen"].speed == 1.2
+    assert rate == 44100 and audio.dtype == np.int16
+    assert audio.tolist()[2] == -32767            # clipped, not wrapped
+
+
+def test_supertonic_auto_language_reads_english():
+    from voiceio.tts.supertonic_engine import SupertonicEngine
+    assert SupertonicEngine(language="auto")._language == "en"
+    assert SupertonicEngine()._language == "en"
+
+
+def test_supertonic_completeness_check(tmp_path):
+    from voiceio.tts import supertonic_engine as st
+    assert not st._complete(tmp_path)
+    assert st._complete(_supertonic_dir(tmp_path))
+
+
+def test_chain_passes_language_to_supertonic():
+    from voiceio.tts import chain
+    engine = chain._create("supertonic", TTSConfig(engine="supertonic", language="de"))
+    assert engine.name == "supertonic" and engine._language == "de"

python_voiceio-1.13.0/voiceio/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.13.0"

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/voiceio/cli/models.py

@@ -180,4 +180,7 @@ def cmd_sherpa(args: argparse.Namespace) -> None:
         wheel = fetch.install_patched_sherpa()
     except OSError as e:
         raise SystemExit(str(e)) from e
-    print(f"installed {wheel}\nnext: voiceio models use parakeet-tdt-0.6b-v2")
+    from voiceio import config
+    from voiceio.core.decoders.catalog import PARAKEET, PARAKEET_V3
+    name = PARAKEET if config.load().model.language == "en" else PARAKEET_V3
+    print(f"installed {wheel}\nnext: voiceio models use {name}")

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/voiceio/config.py

@@ -248,11 +248,12 @@ class PostCorrectConfig:
 @dataclass
 class TTSConfig:
     enabled: bool = True
-    engine: str = "auto"         # "auto" | "piper" | "espeak" | "edge-tts"
+    engine: str = "auto"         # "auto" | "piper" | "supertonic" | "espeak" | "edge-tts"
     hotkey: str = "ctrl+alt+s"   # "s" for speak
     voice: str = ""              # empty = engine default
     speed: float = 1.0           # 0.5–2.0
     model: str = ""              # piper model name, empty = default
+    language: str = ""           # supertonic: language to read in (en, es, de…), empty = en
 
 
 @dataclass

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/voiceio/core/decoders/catalog.py

@@ -15,6 +15,11 @@ from voiceio.core.decoders.base import BiasMode
 
 WHISPER_DEFAULT = "small"
 PARAKEET = "parakeet-tdt-0.6b-v2"
+PARAKEET_V3 = "parakeet-tdt-0.6b-v3"
+# The 25 European languages Parakeet v3 was trained on. It detects which one
+# is spoken by itself, so `[model] language` only picks the model.
+PARAKEET_V3_LANGUAGES = frozenset(
+    "bg hr cs da nl en et fi fr de el hu it lv lt mt pl pt ro sk sl es sv ru uk".split())
 
 
 @dataclass(frozen=True)
@@ -43,11 +48,18 @@ _SHERPA_RELEASES = "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-
 # unlimited hotwords), and Qwen3-ASR (free-text context biasing).
 CATALOG: tuple[ModelInfo, ...] = (
     ModelInfo(PARAKEET, "sherpa-onnx", "600M", "CC-BY-4.0", BiasMode.UNBOUNDED, languages="en",
-              notes="default when sherpa-onnx has the NeMo TDT beam-search fix: ~2x faster "
-                    "than whisper-small, every proper noun of your vocabulary as a hotword",
+              notes="default when sherpa-onnx has the NeMo TDT beam-search fix: text ~0.7s after you stop "
+                    "talking vs ~4.4s with Whisper, every proper noun of your vocabulary as a hotword",
               url=f"{_SHERPA_RELEASES}/sherpa-onnx-nemo-parakeet-tdt-0.6b-v2-int8.tar.bz2",
               sha256="157c157bc51155e03e37d2466522a3a737dd9c72bb25f36eb18912964161e1ad",
               size_mb=482),
+    ModelInfo(PARAKEET_V3, "sherpa-onnx", "600M", "CC-BY-4.0", BiasMode.UNBOUNDED,
+              languages=",".join(sorted(PARAKEET_V3_LANGUAGES)),
+              notes="the default for the other 24 European languages it covers; v2 stays the "
+                    "English default (trained on English only, lower English WER)",
+              url=f"{_SHERPA_RELEASES}/sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8.tar.bz2",
+              sha256="5793d0fd397c5778d2cf2126994d58e9d56b1be7c04d13c7a15bb1b4eafb16bf",
+              size_mb=487),
     ModelInfo("small", "faster-whisper", "244M", "MIT", BiasMode.HOTWORDS | BiasMode.PROMPT,
               notes="~5x realtime on a laptop CPU; hotwords cap ~35 terms; "
                     "the model `voiceio learn` fine-tunes"),
@@ -97,10 +109,11 @@ def default_model(language: str = "en") -> str:
     Parakeet once the installed sherpa-onnx has the NeMo TDT
     modified_beam_search fix (without it, hotwords lose speech — see
     CLAUDE.md "Model choice"), so the default flips by itself when upstream
-    ships the fix. English only: other languages keep Whisper.
+    ships the fix. English gets v2; the other languages Parakeet v3 covers get
+    v3; the rest keep Whisper.
     """
-    if language == "en":
+    if language in PARAKEET_V3_LANGUAGES:
         from voiceio.core.decoders.sherpa import features
         if features().length_reward:
-            return PARAKEET
+            return PARAKEET if language == "en" else PARAKEET_V3
     return WHISPER_DEFAULT

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/voiceio/core/decoders/fetch.py

@@ -68,19 +68,29 @@ def download(name: str, *, progress: Callable[[int, int], None] | None = None) -
     m: ModelInfo | None = info(name)
     if m is None or not m.url:
         raise OSError(f"{name} is not a model voiceio downloads itself")
+    return download_archive(name, m.url, m.sha256, m.size_mb, is_complete,
+                            what="encoder/decoder/joiner/tokens.txt", progress=progress)
+
+
+def download_archive(name: str, url: str, sha256: str, size_mb: int,
+                     complete: Callable[[Path], bool], *, what: str,
+                     progress: Callable[[int, int], None] | None = None) -> Path:
+    """Fetch, verify and unpack a sherpa-onnx release tarball as
+    `models_dir()/name`. `complete` says whether a directory holds the whole
+    model (`what` names its files for the error)."""
     dest = model_path(name)
-    if is_complete(dest):
+    if complete(dest):
         return dest
     root = models_dir()
     root.mkdir(parents=True, exist_ok=True)
     part = root / f".{name}.{os.getpid()}.part"
     staging = root / f".{name}.{os.getpid()}.unpack"
-    log.info("Downloading %s (%d MB) from %s", name, m.size_mb, m.url)
+    log.info("Downloading %s (%d MB) from %s", name, size_mb, url)
     try:
         digest = hashlib.sha256()
-        req = urllib.request.Request(m.url, headers={"User-Agent": "voiceio"})
+        req = urllib.request.Request(url, headers={"User-Agent": "voiceio"})
         with urllib.request.urlopen(req, timeout=_TIMEOUT) as resp, open(part, "wb") as out:
-            total = int(resp.headers.get("Content-Length") or m.size_mb * 1_000_000)
+            total = int(resp.headers.get("Content-Length") or size_mb * 1_000_000)
             done = 0
             while block := resp.read(_BLOCK):
                 out.write(block)
@@ -88,12 +98,12 @@ def download(name: str, *, progress: Callable[[int, int], None] | None = None) -
                 done += len(block)
                 if progress is not None:
                     progress(done, total)
-        if digest.hexdigest() != m.sha256:
+        if digest.hexdigest() != sha256:
             raise OSError(f"{name}: checksum mismatch (got {digest.hexdigest()[:12]}…, "
-                          f"want {m.sha256[:12]}…) — download again")
+                          f"want {sha256[:12]}…) — download again")
         _unpack(part, staging)
-        if not is_complete(staging):
-            raise OSError(f"{name}: the archive has no encoder/decoder/joiner/tokens.txt")
+        if not complete(staging):
+            raise OSError(f"{name}: the archive has no {what}")
         shutil.rmtree(dest, ignore_errors=True)   # an incomplete earlier copy
         os.replace(staging, dest)
     except OSError:

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/voiceio/health.py

@@ -244,7 +244,7 @@ def _check_features() -> FeatureGroups:
 def _decoder_status(cfg) -> dict[str, str]:
     """For a sherpa-onnx model: whether it can be biased, and why not. For
     Whisper: whether Parakeet would do better here."""
-    from voiceio.core.decoders.catalog import PARAKEET, runtime_of
+    from voiceio.core.decoders.catalog import WHISPER_DEFAULT, default_model, runtime_of
     from voiceio.core.decoders.sherpa import features
     f = features()
     if runtime_of(cfg.model.name) == "sherpa-onnx":
@@ -256,9 +256,9 @@ def _decoder_status(cfg) -> dict[str, str]:
         how = "pre-tokenized" if f.pretokenized_hotwords else \
             "sherpa-tokenized, misses many names — fix: voiceio models sherpa"
         return {"Decoder": f"beam search, every proper noun as a hotword ({how})"}
-    if f.length_reward and cfg.model.language == "en":
-        return {"Decoder": f"Whisper; {PARAKEET} is ~2x faster here: "
-                           f"voiceio models use {PARAKEET}"}
+    if f.length_reward and (best := default_model(cfg.model.language)) != WHISPER_DEFAULT:
+        return {"Decoder": f"Whisper; {best} would put your text down several times "
+                           f"sooner: voiceio models use {best}"}
     return {}
 
 

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/voiceio/server/runtime.py

@@ -230,6 +230,7 @@ class ServerRuntime:
                 voice=self.cfg.tts_voice,
                 speed=self.cfg.tts_speed,
                 model=self.cfg.tts_model,
+                language=self.model_cfg.language,
             )
             try:
                 self._tts = tts_pkg.select(

{python_voiceio-1.12.0 → python_voiceio-1.13.0}/voiceio/tts/chain.py

@@ -13,10 +13,11 @@ _ENGINES = {
     "espeak": "voiceio.tts.espeak:EspeakEngine",
     "piper": "voiceio.tts.piper_engine:PiperEngine",
     "edge-tts": "voiceio.tts.edge_engine:EdgeEngine",
+    "supertonic": "voiceio.tts.supertonic_engine:SupertonicEngine",
 }
 
 # Preference order when engine = "auto"
-_AUTO_ORDER = ["piper", "edge-tts", "espeak"]
+_AUTO_ORDER = ["piper", "supertonic", "edge-tts", "espeak"]
 
 # Engines that send the text off this machine to be synthesized. Auto-selection
 # can silently land on one (edge-tts needs no install, so it probes OK wherever
@@ -35,6 +36,8 @@ def _create(name: str, cfg: TTSConfig):
     cls = getattr(module, cls_name)
     if name == "piper":
         return cls(model=cfg.model)
+    if name == "supertonic":
+        return cls(language=cfg.language)
     return cls()
 
 

python_voiceio-1.13.0/voiceio/tts/supertonic_engine.py

@@ -0,0 +1,91 @@
+"""Supertonic 3 TTS engine — neural, offline, 31 languages, via sherpa-onnx.
+
+Faster than real time on a laptop CPU (RTF ~0.5 at 2 threads) in ~300 MB,
+where Kokoro and Pocket TTS ran slower than real time on the same box. It
+renders a whole sentence before playing, so the first audio comes after
+~2 s: worth it for reading text aloud, not for snappy one-word replies, which
+is why Piper stays first in the auto chain. Weights are OpenRAIL-M.
+"""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import numpy as np
+
+from voiceio.backends import ProbeResult
+
+log = logging.getLogger(__name__)
+
+MODEL = "sherpa-onnx-supertonic-3-tts-int8-2026-05-11"
+_URL = f"https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/{MODEL}.tar.bz2"
+_SHA256 = "82fa96f91c4ef8abaae3a14a3f4153facf88bed821d1f7331cec2700f432c427"
+_SIZE_MB = 129
+_STEMS = ("duration_predictor", "text_encoder", "vector_estimator", "vocoder")
+_FILES = ("tts.json", "unicode_indexer.bin", "voice.bin")
+_HINT = "pip install 'python-voiceio[sherpa]' (then: voiceio models sherpa)"
+
+
+def _complete(path: Path) -> bool:
+    return all((path / f).is_file() for f in _FILES) and all(
+        any(path.glob(f"{stem}*.onnx")) for stem in _STEMS)
+
+
+def _onnx(path: Path, stem: str) -> str:
+    return str(sorted(path.glob(f"{stem}*.onnx"))[0])
+
+
+class SupertonicEngine:
+    name = "supertonic"
+
+    def __init__(self, language: str = "", threads: int = 2):
+        # "auto" can't name a language to read in; English is the safe reading.
+        self._language = language if language not in ("", "auto") else "en"
+        self._threads = threads
+        self._tts = None  # lazy: the first synthesize() loads (and maybe fetches)
+
+    def probe(self) -> ProbeResult:
+        try:
+            import sherpa_onnx
+        except ImportError as e:
+            return ProbeResult(ok=False, reason=f"sherpa-onnx missing: {e}", fix_hint=_HINT)
+        if not hasattr(sherpa_onnx, "OfflineTtsSupertonicModelConfig"):
+            return ProbeResult(ok=False, reason="this sherpa-onnx has no Supertonic support",
+                               fix_hint=_HINT)
+        return ProbeResult(ok=True)
+
+    def _ensure(self) -> None:
+        if self._tts is not None:
+            return
+        import sherpa_onnx as so
+
+        from voiceio.core.decoders import fetch
+        path = fetch.download_archive(
+            MODEL, _URL, _SHA256, _SIZE_MB, _complete,
+            what=", ".join((*_STEMS, *_FILES)))
+        model = so.OfflineTtsModelConfig(num_threads=self._threads, provider="cpu")
+        model.supertonic = so.OfflineTtsSupertonicModelConfig(
+            duration_predictor=_onnx(path, "duration_predictor"),
+            text_encoder=_onnx(path, "text_encoder"),
+            vector_estimator=_onnx(path, "vector_estimator"),
+            vocoder=_onnx(path, "vocoder"),
+            tts_json=str(path / "tts.json"),
+            unicode_indexer=str(path / "unicode_indexer.bin"),
+            voice_style=str(path / "voice.bin"))
+        log.info("TTS: loading Supertonic 3 (%s)…", self._language)
+        self._tts = so.OfflineTts(so.OfflineTtsConfig(model=model, max_num_sentences=1))
+
+    def synthesize(self, text: str, voice: str, speed: float) -> tuple[np.ndarray, int]:
+        import sherpa_onnx as so
+
+        self._ensure()
+        gen = so.GenerationConfig()
+        gen.sid = int(voice) if voice.isdigit() else 0
+        gen.speed = speed if speed > 0 else 1.0
+        gen.extra = {"lang": self._language}
+        out = self._tts.generate(text, gen)
+        samples = np.asarray(out.samples, dtype=np.float32)
+        return (np.clip(samples, -1.0, 1.0) * 32767).astype(np.int16), out.sample_rate
+
+    def shutdown(self) -> None:
+        self._tts = None

python_voiceio-1.12.0/voiceio/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.12.0"