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

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

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

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

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

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

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

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

@@ -27,7 +27,10 @@ def _make_vio(mock_transcriber=None):
         mock_detect.return_value = MagicMock(display_server="wayland", desktop="gnome")
 
         from voiceio.app import VoiceIO
-        vio = VoiceIO(Config())
+        cfg = Config()
+        # Tests must never touch the real system clipboard
+        cfg.output.copy_to_clipboard = "off"
+        vio = VoiceIO(cfg)
         mock_stream = MagicMock()
         mock_stream.active = True
         mock_stream.closed = False
@@ -209,3 +212,51 @@ class TestStateMachine:
         vio._request_stop()
         assert vio._state == _State.IDLE
         assert not vio.recorder.is_recording
+
+
+class TestClipboardMirror:
+    """copy_to_clipboard: interim/final text mirrored to the clipboard."""
+
+    def test_interim_copy_skipped_for_clipboard_typer(self):
+        vio, mock_typer, _ = _make_vio()
+        mock_typer.name = "clipboard"
+        vio.cfg.output.copy_to_clipboard = "live"
+        with patch("voiceio.clipboard_read.copy_text") as mock_copy:
+            vio._on_interim_text("hello")
+            mock_copy.assert_not_called()
+
+    def test_interim_copy_fires_for_other_typers(self):
+        vio, mock_typer, _ = _make_vio()
+        mock_typer.name = "ibus"
+        vio.cfg.output.copy_to_clipboard = "live"
+        with patch("voiceio.clipboard_read.copy_text") as mock_copy:
+            vio._on_interim_text("hello")
+            mock_copy.assert_called_once_with("hello")
+
+    def test_interim_copy_off_unless_live(self):
+        vio, mock_typer, _ = _make_vio()
+        mock_typer.name = "ibus"
+        vio.cfg.output.copy_to_clipboard = "final"
+        with patch("voiceio.clipboard_read.copy_text") as mock_copy:
+            vio._on_interim_text("hello")
+            mock_copy.assert_not_called()
+
+    def test_final_copy_respects_off(self):
+        vio, mock_typer, _ = _make_vio()
+        mock_typer.name = "ibus"
+        vio.cfg.output.copy_to_clipboard = "off"
+        with patch("voiceio.clipboard_read.copy_text") as mock_copy:
+            vio._copy_result_async("hello")
+            time.sleep(0.1)
+            mock_copy.assert_not_called()
+
+    def test_final_copy_runs_async(self):
+        vio, mock_typer, _ = _make_vio()
+        mock_typer.name = "ibus"
+        vio.cfg.output.copy_to_clipboard = "final"
+        done = threading.Event()
+        with patch("voiceio.clipboard_read.copy_text",
+                   side_effect=lambda t: done.set()) as mock_copy:
+            vio._copy_result_async("hello world")
+            assert done.wait(timeout=2)
+            mock_copy.assert_called_once_with("hello world")

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

@@ -89,3 +89,57 @@ def test_read_text_no_tools():
         from voiceio.clipboard_read import read_text
         result = read_text()
         assert result is None
+
+
+# --- copy_text ---
+
+def test_copy_text_wayland():
+    """Wayland 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("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
+        args = mock_run.call_args[0][0]
+        assert "wl-copy" in args
+        assert mock_run.call_args.kwargs["input"] == b"hello"
+
+
+def test_copy_text_x11_xclip():
+    """X11 copies to the CLIPBOARD selection via xclip."""
+    with patch("voiceio.clipboard_read.detect", return_value=_mock_platform(display_server="x11")), \
+         patch("shutil.which", lambda t: "/usr/bin/xclip" if t == "xclip" 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
+        args = mock_run.call_args[0][0]
+        assert args[:1] == ["xclip"]
+        assert "clipboard" in args
+
+
+def test_copy_text_no_tools():
+    """Returns False (no raise) when no clipboard tools available."""
+    with patch("voiceio.clipboard_read.detect", return_value=_mock_platform(display_server="x11")), \
+         patch("shutil.which", return_value=None):
+        from voiceio.clipboard_read import copy_text
+        assert copy_text("hello") is False
+
+
+def test_copy_text_empty():
+    """Empty text is never copied."""
+    with patch("subprocess.run") as mock_run:
+        from voiceio.clipboard_read import copy_text
+        assert copy_text("") is False
+        mock_run.assert_not_called()
+
+
+def test_copy_text_command_failure():
+    """Nonzero exit from the copy tool reports False."""
+    with patch("voiceio.clipboard_read.detect", return_value=_mock_platform(display_server="wayland")), \
+         patch("shutil.which", return_value="/usr/bin/wl-copy"), \
+         patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(returncode=1)
+        from voiceio.clipboard_read import copy_text
+        assert copy_text("hello") is False

{python_voiceio-0.4.1 → python_voiceio-0.6.0}/tests/test_config.py

@@ -61,3 +61,16 @@ def test_migrate_x11_to_pynput():
     raw = {"hotkey": {"backend": "x11"}}
     result = _migrate_v1(raw)
     assert result["hotkey"]["backend"] == "pynput"
+
+
+def test_copy_to_clipboard_default_and_override(tmp_path):
+    cfg = load(path=tmp_path / "nonexistent.toml")
+    assert cfg.output.copy_to_clipboard == "final"
+
+    config_file = tmp_path / "config.toml"
+    config_file.write_text(textwrap.dedent("""\
+        [output]
+        copy_to_clipboard = "live"
+    """))
+    cfg = load(path=config_file)
+    assert cfg.output.copy_to_clipboard == "live"

{python_voiceio-0.4.1 → python_voiceio-0.6.0}/tests/test_postcorrect.py

@@ -161,3 +161,119 @@ def test_pipeline_runs_postcorrect_only_on_final():
         )
         assert text == "Crisp chat is the best tool"
         assert not abort
+
+
+# ── wall-clock deadline ──────────────────────────────────────────────────
+
+
+def test_deadline_exceeded_keeps_original():
+    """A chat call slower than timeout_secs is abandoned at the deadline."""
+    import time as _time
+    cfg = _cfg()
+    cfg.postcorrect.timeout_secs = 0.2
+
+    def slow_chat(*a, **kw):
+        _time.sleep(2.0)
+        return "Crisp chat is the tool"
+
+    pc = PostCorrector(cfg)
+    with patch("voiceio.llm_api.chat", side_effect=slow_chat):
+        t0 = _time.monotonic()
+        assert pc.correct("Chris chat is the tool") == "Chris chat is the tool"
+        elapsed = _time.monotonic() - t0
+    assert elapsed < 1.0  # returned at the deadline, not after the full call
+    assert pc.last_secs is not None
+
+
+def test_within_deadline_applies_correction():
+    cfg = _cfg()
+    cfg.postcorrect.timeout_secs = 5.0
+    pc = PostCorrector(cfg)
+    with patch("voiceio.llm_api.chat", return_value="Crisp chat is the tool"):
+        assert pc.correct("Chris chat is the tool") == "Crisp chat is the tool"
+
+
+# ── before/after pair persistence ────────────────────────────────────────
+
+
+def _read_pairs(path):
+    import json
+    return [json.loads(line) for line in path.read_text().splitlines()]
+
+
+def test_applied_correction_recorded(tmp_path, monkeypatch):
+    import voiceio.postcorrect as pcmod
+    from voiceio import config as cfgmod
+    pairs = tmp_path / "pairs.jsonl"
+    monkeypatch.setattr(cfgmod, "POSTCORRECT_PAIRS_PATH", pairs)
+    pc = PostCorrector(_cfg())
+    with patch("voiceio.llm_api.chat", return_value="Crisp chat is the tool"):
+        pc.correct("Chris chat is the tool")
+    entries = _read_pairs(pairs)
+    assert len(entries) == 1
+    assert entries[0]["outcome"] == "applied"
+    assert entries[0]["before"] == "Chris chat is the tool"
+    assert entries[0]["after"] == "Crisp chat is the tool"
+    assert entries[0]["secs"] is not None
+
+
+def test_rejected_rewrite_recorded(tmp_path, monkeypatch):
+    from voiceio import config as cfgmod
+    pairs = tmp_path / "pairs.jsonl"
+    monkeypatch.setattr(cfgmod, "POSTCORRECT_PAIRS_PATH", pairs)
+    pc = PostCorrector(_cfg())
+    with patch("voiceio.llm_api.chat", return_value="Completely different rewritten sentence with many other words entirely"):
+        out = pc.correct("Chris chat is the tool")
+    assert out == "Chris chat is the tool"
+    entries = _read_pairs(pairs)
+    assert len(entries) == 1
+    assert entries[0]["outcome"].startswith("rejected")
+
+
+def test_no_recording_when_disabled(tmp_path, monkeypatch):
+    from voiceio import config as cfgmod
+    pairs = tmp_path / "pairs.jsonl"
+    monkeypatch.setattr(cfgmod, "POSTCORRECT_PAIRS_PATH", pairs)
+    cfg = _cfg()
+    cfg.data.capture_intermediates = False
+    pc = PostCorrector(cfg)
+    with patch("voiceio.llm_api.chat", return_value="Crisp chat is the tool"):
+        pc.correct("Chris chat is the tool")
+    assert not pairs.exists()
+
+
+def test_hung_request_blocks_next_call_not_thread_pileup(tmp_path, monkeypatch):
+    """A worker abandoned at the deadline makes the NEXT call skip the LLM."""
+    import threading as _threading
+    import time as _time
+    from voiceio import config as cfgmod
+    monkeypatch.setattr(cfgmod, "POSTCORRECT_PAIRS_PATH", tmp_path / "pairs.jsonl")
+    cfg = _cfg()
+    cfg.postcorrect.timeout_secs = 0.1
+    pc = PostCorrector(cfg)
+    release = _threading.Event()
+
+    def hung_chat(*a, **kw):
+        release.wait(5)
+        return "x"
+
+    with patch("voiceio.llm_api.chat", side_effect=hung_chat) as mock_chat:
+        assert pc.correct("Chris chat is the tool") == "Chris chat is the tool"
+        assert mock_chat.call_count == 1
+        # Second call while the first worker is still hung: no new thread
+        assert pc.correct("Chris chat is the tool") == "Chris chat is the tool"
+        assert mock_chat.call_count == 1
+    release.set()
+    entries = _read_pairs(tmp_path / "pairs.jsonl")
+    assert [e["outcome"] for e in entries] == ["timeout", "skipped_busy"]
+
+
+def test_recorded_context_is_effective_context(tmp_path, monkeypatch):
+    from voiceio import config as cfgmod
+    monkeypatch.setattr(cfgmod, "POSTCORRECT_PAIRS_PATH", tmp_path / "pairs.jsonl")
+    pc = PostCorrector(_cfg())
+    pc.set_context(title="Stale Window")
+    with patch("voiceio.llm_api.chat", return_value="Crisp chat is the tool"):
+        pc.correct("Chris chat is the tool", context="Fresh Window")
+    entries = _read_pairs(tmp_path / "pairs.jsonl")
+    assert entries[0]["context"] == "Fresh Window"

{python_voiceio-0.4.1 → python_voiceio-0.6.0}/tests/test_retention.py

@@ -97,3 +97,72 @@ class TestHistoryExtra:
         entry = json.loads(p.read_text())
         assert entry["text"] == "hello"
         assert entry["ts"] != 0
+
+
+# ── intermediate data capture + disk floor ──────────────────────────────
+
+
+class TestAppendJsonl:
+    def test_appends_lines(self, tmp_path):
+        from voiceio import retention
+        p = tmp_path / "pairs.jsonl"
+        retention.append_jsonl(p, {"a": 1})
+        retention.append_jsonl(p, {"b": 2})
+        import json
+        lines = [json.loads(line) for line in p.read_text().splitlines()]
+        assert lines == [{"a": 1}, {"b": 2}]
+
+    def test_never_raises_on_bad_entry(self, tmp_path):
+        from voiceio import retention
+        retention.append_jsonl(tmp_path / "x.jsonl", {"bad": object()})  # not JSON-able
+
+
+class TestSaveTrace:
+    def test_writes_when_enabled(self, tmp_path, monkeypatch):
+        from voiceio import retention
+        from voiceio.config import DataConfig
+        monkeypatch.setattr(retention, "TRACES_PATH", tmp_path / "trace.jsonl")
+        retention.save_trace(DataConfig(), {"ts": 1, "passes": []})
+        assert (tmp_path / "trace.jsonl").exists()
+
+    def test_skips_when_disabled(self, tmp_path, monkeypatch):
+        from voiceio import retention
+        from voiceio.config import DataConfig
+        monkeypatch.setattr(retention, "TRACES_PATH", tmp_path / "trace.jsonl")
+        retention.save_trace(DataConfig(capture_intermediates=False), {"ts": 1})
+        assert not (tmp_path / "trace.jsonl").exists()
+
+
+class TestDiskFloor:
+    def test_save_audio_skips_below_floor(self, monkeypatch):
+        import numpy as np
+        from voiceio import retention
+        from voiceio.config import DataConfig
+        monkeypatch.setattr(retention, "_free_gb", lambda p: 1.0)
+        name = retention.save_audio(
+            np.zeros(1600, dtype=np.float32), 0.0, DataConfig(min_free_gb=5.0),
+        )
+        assert name is None
+
+    def test_save_audio_ok_above_floor(self, tmp_path, monkeypatch):
+        import numpy as np
+        from voiceio import retention
+        from voiceio.config import DataConfig
+        monkeypatch.setattr(retention, "RECORDINGS_DIR", tmp_path)
+        monkeypatch.setattr(retention, "_free_gb", lambda p: 100.0)
+        name = retention.save_audio(
+            np.zeros(1600, dtype=np.float32), 0.0, DataConfig(min_free_gb=5.0),
+        )
+        assert name is not None and (tmp_path / name).exists()
+
+    def test_prune_shrinks_budget_below_floor(self, tmp_path, monkeypatch):
+        from voiceio import retention
+        from voiceio.config import DataConfig
+        monkeypatch.setattr(retention, "RECORDINGS_DIR", tmp_path)
+        monkeypatch.setattr(retention, "_free_gb", lambda p: 1.0)
+        for i in range(4):
+            (tmp_path / f"r{i}.wav").write_bytes(b"x" * 1000)
+        retention.prune(DataConfig(max_audio_mb=1024, min_free_gb=5.0))
+        # Budget halved from 4000 bytes total → keep <= 2000 bytes
+        remaining = sum(p.stat().st_size for p in tmp_path.glob("*.wav"))
+        assert remaining <= 2000

{python_voiceio-0.4.1 → python_voiceio-0.6.0}/tests/test_robustness.py

@@ -722,3 +722,56 @@ class TestBootRaceAndReProbe:
              patch("voiceio.app.time.sleep"):
             vio._deferred_typer_upgrade()
             mock_upgrade.assert_called_once_with(reason="streaming-failure")
+
+
+class TestZombieStreamRecovery:
+    """A 'healthy' stream delivering all zeros (post-suspend zombie) must be
+    reopened at recording start, not just logged (2026-07-06 field failure)."""
+
+    def test_zombie_stream_triggers_reopen(self):
+        from unittest.mock import MagicMock, patch
+        from voiceio import app as app_mod
+
+        app = MagicMock()
+        app.recorder.stream_health.return_value = (True, "")
+        app.recorder.is_zombie.return_value = True
+        app.recorder.has_signal.return_value = True  # healthy after reopen
+        app._streaming = False
+        app.cfg.data.capture_context = False
+        with patch.object(app_mod.time, "sleep"):
+            app_mod.VoiceIO._do_start(app)
+        app.recorder.reopen_stream.assert_called_once()
+        app.recorder.start.assert_called_once()
+
+    def test_zombie_reopen_failure_aborts_recording(self):
+        from unittest.mock import MagicMock, patch
+        from voiceio import app as app_mod
+
+        app = MagicMock()
+        app.recorder.stream_health.return_value = (True, "")
+        app.recorder.is_zombie.return_value = True
+        app.recorder.reopen_stream.side_effect = OSError("no device")
+        with patch.object(app_mod.time, "sleep"):
+            app_mod.VoiceIO._do_start(app)
+        app.recorder.start.assert_not_called()
+
+    def test_empty_ring_is_not_zombie(self):
+        """A fresh/headless stream (ring not yet full) must not trigger the
+        reopen path — that broke CI machines with no audio device."""
+        from voiceio.config import AudioConfig
+        from voiceio.recorder import AudioRecorder
+
+        rec = AudioRecorder(AudioConfig())
+        assert rec.is_zombie() is False
+
+    def test_full_ring_of_zeros_is_zombie(self):
+        import numpy as np
+        from voiceio.config import AudioConfig
+        from voiceio.recorder import AudioRecorder
+
+        rec = AudioRecorder(AudioConfig())
+        rec._ring.append(np.zeros(rec._ring._max, dtype=np.float32))
+        assert rec.is_zombie() is True
+        # any real signal → not a zombie
+        rec._ring.append(np.full(rec._ring._max, 0.1, dtype=np.float32))
+        assert rec.is_zombie() is False