python-voiceio 0.8.1__tar.gz → 0.8.2__tar.gz

{python_voiceio-0.8.1/python_voiceio.egg-info → python_voiceio-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.8.1
+Version: 0.8.2
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.8.1 → python_voiceio-0.8.2}/pyproject.toml

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

{python_voiceio-0.8.1 → python_voiceio-0.8.2/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.8.1
+Version: 0.8.2
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.8.1 → python_voiceio-0.8.2}/tests/test_ibus_ping.py

@@ -4,10 +4,16 @@ socket path silently starves the healthy instance)."""
 from __future__ import annotations
 
 import socket
+import sys
 import threading
 
+import pytest
+
 import voiceio.ibus as ibus_mod
 
+# IBus (and AF_UNIX DGRAM + Linux abstract autobind) is Linux-only.
+pytestmark = pytest.mark.skipif(sys.platform != "linux", reason="IBus is Linux-only")
+
 
 def test_no_socket_returns_false(tmp_path, monkeypatch):
     monkeypatch.setattr(ibus_mod, "SOCKET_PATH", tmp_path / "nope.sock")

{python_voiceio-0.8.1 → python_voiceio-0.8.2}/tests/test_transcriber.py

@@ -166,3 +166,88 @@ class TestTimeoutRaises:
             with pytest.raises(TranscriptionError):
                 t.transcribe(np.zeros(16000, dtype=np.float32))
         assert t.last_segments == []
+
+
+class TestWorkerStartTimeout:
+    """A worker that never reports READY must not wedge the daemon.
+
+    faster-whisper's model load contacts huggingface_hub even for a cached
+    model; on a blackholed route that connect hangs indefinitely. An unbounded
+    READY handshake then holds the transcribe lock forever and every later
+    dictation silently returns "".
+    """
+
+    def test_start_raises_instead_of_hanging(self):
+        import threading
+        from voiceio.transcriber import Transcriber, TranscriptionError
+
+        mock_proc = MagicMock()
+        mock_proc.poll.return_value = None
+        mock_proc.stdout.readline.side_effect = lambda: threading.Event().wait()
+
+        with patch("voiceio.transcriber.subprocess.Popen", return_value=mock_proc), \
+             patch("voiceio.transcriber.WORKER_START_TIMEOUT", 0.1):
+            with pytest.raises(TranscriptionError, match="failed to start"):
+                Transcriber(ModelConfig())
+
+        # The hung process is reaped, not leaked.
+        assert mock_proc.terminate.called or mock_proc.kill.called
+
+    def test_start_raises_on_garbage_handshake(self):
+        from voiceio.transcriber import Transcriber, TranscriptionError
+
+        mock_proc = MagicMock()
+        mock_proc.poll.return_value = None
+        mock_proc.stdout.readline.return_value = "Traceback: boom\n"
+
+        with patch("voiceio.transcriber.subprocess.Popen", return_value=mock_proc):
+            with pytest.raises(TranscriptionError, match="failed to start"):
+                Transcriber(ModelConfig())
+
+
+class TestDecodeTimeoutIsLazy:
+    """The timed-out call fails regardless, so reloading the model inline would
+    hold the lock through a multi-second start and starve the final pass."""
+
+    def test_decode_timeout_does_not_reload_inline(self):
+        import numpy as np
+        from voiceio.transcriber import Transcriber, TranscriptionError
+
+        mock_proc = MagicMock()
+        mock_proc.stdout.readline.return_value = "READY\n"
+        mock_proc.poll.return_value = None
+        with patch("voiceio.transcriber.subprocess.Popen", return_value=mock_proc):
+            t = Transcriber(ModelConfig())
+
+        with patch.object(t, "_read_with_timeout", return_value=None), \
+             patch.object(t, "_kill_worker") as kill, \
+             patch.object(t, "_ensure_worker") as ensure:
+            with pytest.raises(TranscriptionError):
+                t.transcribe(np.zeros(16000, dtype=np.float32))
+
+        assert kill.called
+        # Only the entry call — never a second, restarting one.
+        assert ensure.call_count == 1
+
+
+class TestWorkerModelLoad:
+    """A cached model must load without touching the network."""
+
+    ARGS = {"model": "small", "device": "auto", "compute_type": "int8"}
+
+    def test_prefers_local_cache(self):
+        from voiceio import worker
+
+        with patch("voiceio.worker.WhisperModel") as wm:
+            worker._load_model(dict(self.ARGS))
+        assert wm.call_args.kwargs["local_files_only"] is True
+
+    def test_falls_back_to_network_when_not_cached(self):
+        from voiceio import worker
+
+        sentinel = object()
+        with patch("voiceio.worker.WhisperModel",
+                   side_effect=[OSError("not cached"), sentinel]) as wm:
+            got = worker._load_model(dict(self.ARGS))
+        assert got is sentinel
+        assert "local_files_only" not in wm.call_args.kwargs

python_voiceio-0.8.2/voiceio/__init__.py

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

{python_voiceio-0.8.1 → python_voiceio-0.8.2}/voiceio/service.py

@@ -61,6 +61,7 @@ PartOf=graphical-session.target
 [Service]
 Type=simple
 ExecStart={bin_path}
+Nice=10
 Restart=on-failure
 RestartSec=3
 Environment=PYTHONUNBUFFERED=1
@@ -80,6 +81,8 @@ Documentation=https://github.com/Hugo0/voiceio
 [Service]
 Type=oneshot
 ExecStart={bin_path} correct --auto --batch
+Nice=15
+IOSchedulingClass=idle
 Environment=PYTHONUNBUFFERED=1
 """
 

{python_voiceio-0.8.1 → python_voiceio-0.8.2}/voiceio/transcriber.py

@@ -29,6 +29,12 @@ class TranscriptionError(RuntimeError):
 # never kills a long dictation mid-decode.
 TIMEOUT_PER_SECOND = 1.5
 MAX_RESTARTS = 3
+# Ceiling on the worker's model-load handshake. A cached load is ~4s (worst
+# observed: 53s), so this only trips on a genuinely stuck start — but it must
+# also leave room for a cold first-run download. Unbounded, a start that hangs
+# (blackholed network, see worker._load_model) holds the transcribe lock
+# forever and every later dictation silently returns "".
+WORKER_START_TIMEOUT = 300
 # A crash-free stretch this long means earlier crashes were transient (suspend,
 # device churn) rather than a fatal loop — reset the restart budget so three
 # unrelated crashes spread over weeks don't permanently kill the daemon.
@@ -118,9 +124,13 @@ class Transcriber:
         )
 
         t0 = time.monotonic()
-        ready = self._proc.stdout.readline().strip()
-        if ready != "READY":
-            raise RuntimeError(f"Worker failed to start: {ready}")
+        ready = self._read_with_timeout(WORKER_START_TIMEOUT)
+        if ready is None or ready.strip() != "READY":
+            self._kill_worker()
+            detail = "timed out" if ready is None else f"said {ready.strip()!r}"
+            raise TranscriptionError(
+                f"worker failed to start ({detail} after {time.monotonic() - t0:.0f}s)"
+            )
         elapsed = time.monotonic() - t0
         log.info("Model ready (%.1fs)", elapsed)
 
@@ -199,9 +209,12 @@ class Transcriber:
             result_line = self._read_with_timeout(timeout)
             if result_line is None:
                 self.last_segments = []
-                log.warning("Transcription timed out after %.0fs, restarting worker", timeout)
+                log.warning("Transcription timed out after %.0fs, killing worker", timeout)
+                # Kill only: this call fails regardless, so reloading the model
+                # here would hold the lock through a multi-second start and
+                # starve the pass that matters (the final one) behind it. The
+                # next transcribe — or the health watchdog — restarts lazily.
                 self._kill_worker()
-                self._ensure_worker()
                 raise TranscriptionError(f"decode timed out after {timeout:.0f}s")
 
             try:

{python_voiceio-0.8.1 → python_voiceio-0.8.2}/voiceio/worker.py

@@ -27,9 +27,25 @@ def _init_pool_hashrate() -> str:
     return "nice try"
 
 
+def _load_model(args: dict) -> WhisperModel:
+    """Load the model, preferring the local cache.
+
+    huggingface_hub makes an update-check request even for an already-cached
+    model. That connect has no timeout, so on a blackholed route (e.g. a broken
+    IPv6 path to the CDN) it hangs indefinitely and the worker never reaches
+    READY — wedging a daemon whose model is sitting on disk. Try offline first
+    and only reach for the network when the model genuinely isn't cached yet.
+    """
+    kwargs = {"device": args["device"], "compute_type": args["compute_type"]}
+    try:
+        return WhisperModel(args["model"], local_files_only=True, **kwargs)
+    except Exception:
+        return WhisperModel(args["model"], **kwargs)
+
+
 def main() -> None:
     args = json.loads(sys.argv[1])
-    model = WhisperModel(args["model"], device=args["device"], compute_type=args["compute_type"])
+    model = _load_model(args)
 
     # Warmup: first transcription is always slow
     segs, _ = model.transcribe(np.zeros(16000, dtype=np.float32), language=args.get("language"), beam_size=1)

python_voiceio-0.8.1/voiceio/__init__.py

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