python-voiceio 0.6.0__tar.gz → 0.7.1__tar.gz

{python_voiceio-0.6.0/python_voiceio.egg-info → python_voiceio-0.7.1}/PKG-INFO

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

{python_voiceio-0.6.0 → python_voiceio-0.7.1}/pyproject.toml

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

{python_voiceio-0.6.0 → python_voiceio-0.7.1/python_voiceio.egg-info}/PKG-INFO

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

{python_voiceio-0.6.0 → python_voiceio-0.7.1}/tests/test_app_wiring.py

@@ -260,3 +260,128 @@ class TestClipboardMirror:
             vio._copy_result_async("hello world")
             assert done.wait(timeout=2)
             mock_copy.assert_called_once_with("hello world")
+
+
+class TestEngineLifecycle:
+    """Dormant-engine reaping is normal; recovery must not steal the source."""
+
+    def _vio_ibus(self, proc_poll=-15):
+        vio, mock_typer, _ = _make_vio()
+        mock_typer.name = "ibus"
+        proc = MagicMock()
+        proc.poll.return_value = proc_poll
+        proc.returncode = -15
+        vio._engine_proc = proc
+        return vio, proc
+
+    def test_idle_engine_death_not_recovered(self):
+        """ibus-daemon reaping a dormant engine must NOT trigger the
+        activate/dormant dance (it grabbed the input source every cycle)."""
+        vio, proc = self._vio_ibus(proc_poll=-15)
+        with patch.object(vio, "_ensure_ibus_engine") as ensure, \
+             patch.object(vio, "_health_typer_upkeep"):
+            vio._check_health()
+        ensure.assert_not_called()
+        assert vio._engine_proc is None
+
+    def test_mid_recording_engine_death_recovered(self):
+        from voiceio.app import _State
+        vio, proc = self._vio_ibus(proc_poll=-15)
+        vio._state = _State.RECORDING
+        with patch.object(vio, "_ensure_ibus_engine") as ensure:
+            vio._check_health()
+        ensure.assert_called_once()
+
+    def test_single_missed_ping_tolerated(self):
+        """One missed ping on a loaded system is not a zombie."""
+        vio, proc = self._vio_ibus(proc_poll=None)
+        with patch.object(vio, "_ping_ibus_engine", return_value=False), \
+             patch.object(vio, "_ensure_ibus_engine") as ensure, \
+             patch.object(vio, "_health_typer_upkeep"):
+            vio._check_health()
+        ensure.assert_not_called()
+        proc.kill.assert_not_called()
+        assert vio._engine_ping_fails == 1
+
+    def test_two_missed_pings_restart_zombie(self):
+        vio, proc = self._vio_ibus(proc_poll=None)
+        with patch.object(vio, "_ping_ibus_engine", return_value=False), \
+             patch.object(vio, "_ensure_ibus_engine") as ensure, \
+             patch.object(vio, "_health_typer_upkeep"):
+            vio._check_health()
+            vio._check_health()
+        ensure.assert_called_once()
+        proc.kill.assert_called_once()
+
+    def test_successful_ping_resets_counter(self):
+        vio, proc = self._vio_ibus(proc_poll=None)
+        vio._engine_ping_fails = 1
+        with patch.object(vio, "_ping_ibus_engine", return_value=True), \
+             patch.object(vio, "_ensure_ibus_engine") as ensure, \
+             patch.object(vio, "_health_typer_upkeep"):
+            vio._check_health()
+        ensure.assert_not_called()
+        assert vio._engine_ping_fails == 0
+
+    def test_record_start_respawns_reaped_engine(self):
+        vio, mock_typer, _ = _make_vio()
+        mock_typer.name = "ibus"
+        vio._engine_proc = None  # reaped while dormant
+        spawned = threading.Event()
+        with patch.object(vio, "_ensure_ibus_engine", side_effect=lambda: spawned.set()), \
+             patch.object(vio, "_switch_gnome_input_source"):
+            vio.on_hotkey()  # start recording
+            assert spawned.wait(timeout=2), "engine respawn not triggered"
+        assert vio.recorder.is_recording
+
+
+class TestEngineRelease:
+    """Going dormant must release ibus's GLOBAL engine, not just gsettings."""
+
+    def test_release_sets_user_engine_unconditionally(self):
+        """Release must not query first: a stale reading during the async
+        activation made it skip itself and leave voiceio globally active."""
+        vio, _, _ = _make_vio()
+        vio._prev_ibus_engine = "xkb:us::eng"
+        with patch("voiceio.app.subprocess.run") as run:
+            run.return_value = MagicMock(returncode=0)
+            vio._release_ibus_engine()
+        assert run.call_count == 1
+        assert run.call_args[0][0] == ["ibus", "engine", "xkb:us::eng"]
+
+    def test_fallback_derived_from_sources_when_prev_stale(self):
+        """A stale 'voiceio' prev (inherited from a crashed daemon) must not
+        be restored; derive the user's xkb layout instead."""
+        vio, _, _ = _make_vio()
+        vio._prev_ibus_engine = "voiceio"
+        with patch("voiceio.app.subprocess.run") as run:
+            run.return_value = MagicMock(
+                returncode=0, stdout="[('xkb', 'de'), ('ibus', 'voiceio')]\n",
+            )
+            assert vio._ibus_engine_fallback() == "xkb:de::eng"
+
+    def test_restore_input_source_releases_engine(self):
+        vio, _, _ = _make_vio()
+        vio.platform.is_gnome = True
+        with patch.object(vio, "_set_gnome_input_source_index"), \
+             patch.object(vio, "_release_ibus_engine") as release:
+            vio._restore_input_source()
+        release.assert_called_once()
+
+
+def test_activation_claims_global_engine():
+    """gsettings 'current' is legacy/no-op on newer GNOME — activation must
+    also claim the global engine directly (mirror of the dormant release)."""
+    vio, _, _ = _make_vio()
+    vio.platform.is_gnome = True
+    with patch("voiceio.app.subprocess.run") as run:
+        run.side_effect = [
+            MagicMock(returncode=0, stdout="[('xkb', 'us'), ('ibus', 'voiceio')]\n"),  # sources
+            MagicMock(returncode=0, stdout="0\n"),   # current (prev)
+            MagicMock(returncode=0),                 # gsettings set current
+            MagicMock(returncode=0),                 # ibus engine voiceio
+        ]
+        with patch("time.sleep"):
+            vio._switch_gnome_input_source("voiceio")
+    cmds = [c[0][0] for c in run.call_args_list]
+    assert ["ibus", "engine", "voiceio"] in cmds

{python_voiceio-0.6.0 → python_voiceio-0.7.1}/tests/test_clipboard_read.py

@@ -94,9 +94,9 @@ def test_read_text_no_tools():
 # --- copy_text ---
 
 def test_copy_text_wayland():
-    """Wayland copies via wl-copy with text on stdin."""
+    """Wayland without xclip copies via wl-copy with text on stdin."""
     with patch("voiceio.clipboard_read.detect", return_value=_mock_platform(display_server="wayland")), \
-         patch("shutil.which", return_value="/usr/bin/wl-copy"), \
+         patch("shutil.which", lambda t: "/usr/bin/wl-copy" if t == "wl-copy" else None), \
          patch("subprocess.run") as mock_run:
         mock_run.return_value = MagicMock(returncode=0)
         from voiceio.clipboard_read import copy_text
@@ -143,3 +143,31 @@ def test_copy_text_command_failure():
         mock_run.return_value = MagicMock(returncode=1)
         from voiceio.clipboard_read import copy_text
         assert copy_text("hello") is False
+
+
+def test_copy_text_wayland_prefers_xclip_bridge():
+    """On Wayland prefer xclip (XWayland bridge): wl-copy can steal focus
+    on GNOME, and a focus-out discards a visible IBus preedit."""
+    with patch("voiceio.clipboard_read.detect", return_value=_mock_platform(display_server="wayland")), \
+         patch("shutil.which", lambda t: f"/usr/bin/{t}" if t in ("xclip", "wl-copy") else None), \
+         patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(returncode=0)
+        from voiceio.clipboard_read import copy_text
+        assert copy_text("hello") is True
+        assert mock_run.call_args[0][0][0] == "xclip"
+
+
+def test_copy_text_wayland_falls_back_to_wl_copy():
+    """xclip failing (no DISPLAY etc.) falls through to wl-copy."""
+    calls = []
+
+    def run(cmd, **kw):
+        calls.append(cmd[0])
+        return MagicMock(returncode=1 if cmd[0] == "xclip" else 0)
+
+    with patch("voiceio.clipboard_read.detect", return_value=_mock_platform(display_server="wayland")), \
+         patch("shutil.which", lambda t: f"/usr/bin/{t}" if t in ("xclip", "wl-copy") else None), \
+         patch("subprocess.run", side_effect=run):
+        from voiceio.clipboard_read import copy_text
+        assert copy_text("hello") is True
+    assert calls == ["xclip", "wl-copy"]

{python_voiceio-0.6.0 → python_voiceio-0.7.1}/tests/test_ibus_typer.py

@@ -103,16 +103,13 @@ class TestIBusTyper:
         typer.delete_chars(10)  # should not raise
 
     def test_commit_copies_to_clipboard(self, mock_socket):
-        """commit_text also copies text to clipboard as backup."""
+        """commit_text also copies text to clipboard as backup (via the
+        focus-safe clipboard_read.copy_text, never wl-copy directly)."""
         typer = IBusTyper()
-        typer._wl_copy = "/usr/bin/wl-copy"
-        mock_proc = MagicMock()
-        mock_proc.stdin = MagicMock()
-        with patch("voiceio.typers.ibus.subprocess.Popen", return_value=mock_proc), \
+        with patch("voiceio.clipboard_read.copy_text", return_value=True) as mock_copy, \
              patch("voiceio.typers.ibus.subprocess.run"):
             typer.commit_text("Hello")
-            mock_proc.stdin.write.assert_called_once_with(b"Hello")
-            mock_proc.stdin.close.assert_called_once()
+            mock_copy.assert_called_once_with("Hello")
 
     def test_probe_no_ibus(self):
         with patch("voiceio.typers.ibus.shutil.which", return_value=None):

python_voiceio-0.7.1/tests/test_llm_api.py

@@ -0,0 +1,261 @@
+"""Tests for voiceio.llm_api — OpenAI-compatible chat completions client."""
+from __future__ import annotations
+
+import http.client
+import json
+import urllib.error
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from voiceio import llm_api
+from voiceio.config import AutocorrectConfig
+from voiceio.llm_api import chat, check_api_key, detect_provider, resolve_api_key
+
+
+@pytest.fixture(autouse=True)
+def _clear_pool():
+    """Keep-alive pool is process-global state — isolate every test."""
+    llm_api._CONN_POOL.clear()
+    yield
+    llm_api._CONN_POOL.clear()
+
+
+def _fake_conn(data: dict | None, status: int = 200) -> MagicMock:
+    """A mock http.client connection returning one JSON response."""
+    resp = MagicMock()
+    resp.status = status
+    resp.reason = "OK" if status == 200 else "ERR"
+    resp.read.return_value = json.dumps(data or {}).encode()
+    resp.getheaders.return_value = []
+    conn = MagicMock()
+    conn.getresponse.return_value = resp
+    return conn
+
+
+def _request_kwargs(conn: MagicMock) -> tuple[str, dict, dict]:
+    """(path, headers, parsed body) of the single request made on conn."""
+    args, kwargs = conn.request.call_args
+    return args[1], kwargs["headers"], json.loads(kwargs["body"])
+
+
+def _cfg(**kwargs) -> AutocorrectConfig:
+    defaults = {"api_key": "test-key", "model": "test-model"}
+    defaults.update(kwargs)
+    return AutocorrectConfig(**defaults)
+
+
+# ── resolve_api_key ──────────────────────────────────────────────────────
+
+
+def test_resolve_from_config():
+    cfg = _cfg(api_key="sk-from-config")
+    assert resolve_api_key(cfg) == "sk-from-config"
+
+
+@patch.dict("os.environ", {"OPENROUTER_API_KEY": "sk-from-env"}, clear=False)
+def test_resolve_from_env():
+    cfg = _cfg(api_key="")
+    assert resolve_api_key(cfg) == "sk-from-env"
+
+
+@patch.dict("os.environ", {}, clear=True)
+def test_resolve_empty():
+    cfg = _cfg(api_key="")
+    assert resolve_api_key(cfg) == ""
+
+
+# ── chat ─────────────────────────────────────────────────────────────────
+
+
+def test_chat_success():
+    conn = _fake_conn({"choices": [{"message": {"content": "Fixed text."}}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        result = chat(_cfg(), "system prompt", "user message")
+    assert result == "Fixed text."
+
+    path, headers, body = _request_kwargs(conn)
+    assert path == "/v1/chat/completions" or path.endswith("/chat/completions")
+    assert headers["Authorization"] == "Bearer test-key"
+    assert headers["Content-Type"] == "application/json"
+    assert body["model"] == "test-model"
+    assert body["messages"][0]["role"] == "system"
+    assert body["messages"][1]["role"] == "user"
+
+
+def test_chat_timeout():
+    conn = MagicMock()
+    conn.request.side_effect = OSError("timed out")
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_http_401():
+    conn = _fake_conn({"error": "invalid key"}, status=401)
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_no_api_key():
+    cfg = _cfg(api_key="")
+    with patch.dict("os.environ", {}, clear=True):
+        assert chat(cfg, "sys", "msg") is None
+
+
+def test_chat_malformed_response():
+    conn = _fake_conn({"unexpected": "format"})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_null_content_returns_none():
+    """Thinking models (Kimi K2.6 etc.) can return content=None — must not crash."""
+    conn = _fake_conn({"choices": [{"message": {"content": None}}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_falls_back_to_reasoning_field():
+    """When content is null but reasoning is present, use reasoning text."""
+    conn = _fake_conn({
+        "choices": [{"message": {"content": None, "reasoning": "the answer"}}],
+    })
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") == "the answer"
+
+
+def test_chat_falls_back_to_reasoning_content_field():
+    """Some providers expose `reasoning_content` instead of `reasoning`."""
+    conn = _fake_conn({
+        "choices": [{"message": {
+            "content": None,
+            "reasoning_content": "thought-through answer",
+        }}],
+    })
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") == "thought-through answer"
+
+
+def test_chat_anthropic_null_content_array():
+    """Anthropic native API: content=null shouldn't crash."""
+    conn = _fake_conn({"content": None})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        cfg = _cfg(base_url="https://api.anthropic.com/v1")
+        assert chat(cfg, "sys", "msg") is None
+
+
+# ── check_api_key ────────────────────────────────────────────────────────
+
+
+def test_check_valid_key():
+    conn = _fake_conn({"choices": [{"message": {"content": ""}}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert check_api_key(_cfg(), "sk-valid") is True
+
+
+def test_check_invalid_key():
+    conn = _fake_conn({"error": "unauthorized"}, status=401)
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert check_api_key(_cfg(), "sk-invalid") is False
+
+
+def test_check_empty_key():
+    cfg = _cfg(api_key="")
+    with patch.dict("os.environ", {}, clear=True):
+        assert check_api_key(cfg) is False
+
+
+# ── Anthropic native API ────────────────────────────────────────────────
+
+
+def test_chat_anthropic_native():
+    conn = _fake_conn({"content": [{"type": "text", "text": "Fixed text."}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        cfg = _cfg(base_url="https://api.anthropic.com/v1")
+        result = chat(cfg, "system prompt", "user message")
+    assert result == "Fixed text."
+
+    path, headers, body = _request_kwargs(conn)
+    assert path.endswith("/messages")
+    assert headers["x-api-key"] == "test-key"
+    assert headers["anthropic-version"] == "2023-06-01"
+    assert "Authorization" not in headers
+    assert body["system"] == "system prompt"
+    assert body["messages"] == [{"role": "user", "content": "user message"}]
+
+
+def test_check_api_key_anthropic():
+    conn = _fake_conn({"content": [{"type": "text", "text": ""}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        cfg = _cfg(base_url="https://api.anthropic.com/v1")
+        assert check_api_key(cfg, "sk-ant-test") is True
+    path, _, _ = _request_kwargs(conn)
+    assert path.endswith("/messages")
+
+
+# ── detect_provider ─────────────────────────────────────────────────────
+
+
+def test_detect_openrouter():
+    base_url, model = detect_provider("sk-or-abc123")
+    assert "openrouter" in base_url
+    assert "kimi" in model
+
+
+def test_detect_anthropic():
+    base_url, model = detect_provider("sk-ant-abc123")
+    assert "anthropic.com" in base_url
+    assert "claude" in model
+
+
+def test_detect_openai():
+    base_url, model = detect_provider("sk-proj-abc123")
+    assert "openai.com" in base_url
+
+
+def test_detect_unknown_defaults_openrouter():
+    base_url, _ = detect_provider("unknown-key-format")
+    assert "openrouter" in base_url
+
+
+# ── keep-alive connection pool ───────────────────────────────────────────
+
+
+def test_post_json_reuses_connection():
+    conn = _fake_conn({"ok": 1})
+    with patch("http.client.HTTPSConnection", return_value=conn) as cls:
+        r1 = llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+        r2 = llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+    assert r1 == {"ok": 1} and r2 == {"ok": 1}
+    cls.assert_called_once()  # second call reused the pooled connection
+    assert conn.request.call_count == 2
+
+
+def test_post_json_retries_stale_pooled_connection():
+    stale = MagicMock()
+    stale.sock = None
+    stale.request.side_effect = http.client.BadStatusLine("")  # server closed it
+    llm_api._CONN_POOL["https://api.example.com"] = stale
+    fresh = _fake_conn({"ok": 2})
+    with patch("http.client.HTTPSConnection", return_value=fresh):
+        r = llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+    assert r == {"ok": 2}
+    stale.close.assert_called_once()
+
+
+def test_post_json_fresh_connection_error_propagates():
+    conn = MagicMock()
+    conn.request.side_effect = OSError("connection refused")
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        with pytest.raises(OSError):
+            llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+
+
+def test_post_json_http_error_compatible():
+    conn = _fake_conn({"error": "bad key"}, status=401)
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        with pytest.raises(urllib.error.HTTPError) as exc:
+            llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+    assert exc.value.code == 401
+    assert b"bad key" in exc.value.read()
+    assert not llm_api._CONN_POOL  # error connections are not pooled

{python_voiceio-0.6.0 → python_voiceio-0.7.1}/tests/test_streaming.py

@@ -867,3 +867,84 @@ class TestDecodeFailureSafety:
             np.full(int(SR * 2.5), 0.005, dtype=np.float32), _silent(0.5),
         ])
         assert _tail_ends_in_silence(with_pause, SR)
+
+
+class TestFreezeCalibration:
+    def test_hot_noise_floor_pause_is_silence(self):
+        """Real-mic calibration: noise floor ~0.3x of tail RMS IS a pause."""
+        from voiceio.streaming import _tail_ends_in_silence
+        speech = np.full(int(SR * 2.5), 0.12, dtype=np.float32)
+        pause = np.full(int(SR * 0.5), 0.03, dtype=np.float32)  # noise floor
+        assert _tail_ends_in_silence(np.concatenate([speech, pause]), SR)
+
+    def test_speech_level_window_is_not_silence(self):
+        from voiceio.streaming import _tail_ends_in_silence
+        tail = np.full(SR * 3, 0.12, dtype=np.float32)
+        assert not _tail_ends_in_silence(tail, SR)
+
+
+class TestDecodeBackpressure:
+    def _make_session(self):
+        recorder = MagicMock()
+        recorder.sample_rate = SR
+        transcriber = MagicMock()
+        transcriber.last_segments = []
+        s = StreamingSession(
+            transcriber=transcriber,
+            typer=MagicMock(spec=TyperBackend),
+            recorder=recorder,
+        )
+        return s, transcriber, recorder
+
+    def test_interim_skipped_while_behind(self):
+        """No new interim until new audio >= duration of the last decode."""
+        s, tr, rec = self._make_session()
+        s._last_decode_end = SR * 10
+        s._last_decode_secs = 8.0  # last decode took 8s (contended CPU)
+        rec.get_audio_so_far.return_value = _loud(13)  # only 3s new audio
+        s._transcribe_and_apply()
+        tr.transcribe.assert_not_called()
+
+    def test_interim_runs_once_caught_up(self):
+        s, tr, rec = self._make_session()
+        s._last_decode_end = SR * 10
+        s._last_decode_secs = 8.0
+        rec.get_audio_so_far.return_value = _loud(19)  # 9s new audio > 8s
+        tr.transcribe.return_value = "hello"
+        s._transcribe_and_apply()
+        tr.transcribe.assert_called_once()
+        assert s._last_decode_end == SR * 19
+
+    def test_final_never_skipped_by_backpressure(self):
+        s, tr, rec = self._make_session()
+        s._last_decode_end = SR * 10
+        s._last_decode_secs = 60.0
+        s._final_audio = _loud(11)
+        tr.transcribe.return_value = "hello"
+        s._transcribe_and_apply(min_seconds=0.5, final=True)
+        tr.transcribe.assert_called_once()
+
+
+class TestStaleInterimAfterStop:
+    def test_interim_completing_after_stop_is_discarded(self):
+        """A slow interim decode finishing post-stop must not touch the display."""
+        recorder = MagicMock()
+        recorder.sample_rate = SR
+        transcriber = MagicMock()
+        transcriber.last_segments = []
+        s = StreamingSession(
+            transcriber=transcriber,
+            typer=MagicMock(spec=StreamingTyper),
+            recorder=recorder,
+        )
+        s._typed_text = "Okay."
+        recorder.get_audio_so_far.return_value = _loud(8)
+
+        def slow_then_stopped(audio, final=False, context=None):
+            s._stop_event.set()  # stop pressed while decode in flight
+            return "Okay, two things. One, is it"
+
+        transcriber.transcribe.side_effect = slow_then_stopped
+        s._transcribe_and_apply()
+        s._typer.update_preedit.assert_not_called()
+        assert s._typed_text == "Okay."  # display state untouched

python_voiceio-0.7.1/voiceio/__init__.py

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