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

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

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

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

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

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

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

{python_voiceio-0.4.1 → python_voiceio-0.5.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.5.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.5.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.5.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

{python_voiceio-0.4.1 → python_voiceio-0.5.0}/tests/test_streaming.py

@@ -595,3 +595,57 @@ class TestWorkerLoop:
         session._worker_thread.join(timeout=5)
 
         assert transcriber.transcribe.call_count < 5
+
+
+# --- on_interim callback ---
+
+class TestOnInterim:
+    def _make_session(self, cb):
+        recorder = MagicMock()
+        recorder.sample_rate = 16000
+        transcriber = MagicMock()
+        session = StreamingSession(
+            transcriber=transcriber,
+            typer=MagicMock(spec=TyperBackend),
+            recorder=recorder,
+            on_interim=cb,
+        )
+        recorder.get_audio_so_far.return_value = np.zeros(16000 * 2, dtype=np.float32)
+        return session, transcriber
+
+    def test_fires_on_new_text(self):
+        calls = []
+        s, tr = self._make_session(calls.append)
+        tr.transcribe.return_value = "Hello world"
+        s._transcribe_and_apply()
+        assert calls == ["Hello world"]
+
+    def test_no_fire_when_text_unchanged(self):
+        calls = []
+        s, tr = self._make_session(calls.append)
+        tr.transcribe.return_value = "Hello world"
+        s._transcribe_and_apply()
+        s._transcribe_and_apply()
+        assert calls == ["Hello world"]
+
+    def test_no_fire_on_final(self):
+        calls = []
+        s, tr = self._make_session(calls.append)
+        tr.transcribe.return_value = "Hello world"
+        s._final_audio = np.zeros(16000 * 2, dtype=np.float32)
+        s._transcribe_and_apply(min_seconds=0.5, final=True)
+        assert calls == []
+        assert s.interim_text == "Hello world"
+
+    def test_callback_error_is_swallowed(self):
+        def boom(_text):
+            raise RuntimeError("clipboard exploded")
+        s, tr = self._make_session(boom)
+        tr.transcribe.return_value = "Hello world"
+        s._transcribe_and_apply()  # must not raise
+        assert s.interim_text == "Hello world"
+
+    def test_interim_text_property(self):
+        s, _ = self._make_session(None)
+        s._apply_correction("Hello world")
+        assert s.interim_text == "Hello world"

{python_voiceio-0.4.1 → python_voiceio-0.5.0}/tests/test_transcriber.py

@@ -104,12 +104,17 @@ class TestRestartBudgetReset:
         import time as _time
         t, mock_proc = self._make()
 
-        # Simulate having already hit the ceiling long ago.
+        # Simulate having already hit the ceiling long ago. Patch monotonic
+        # instead of subtracting from it: on a freshly-booted machine (CI),
+        # monotonic() is small and the subtraction would go negative,
+        # disabling the reset guard entirely.
         t._restarts = MAX_RESTARTS
-        t._last_crash_time = _time.monotonic() - (RESTART_RESET_SECS + 60)
+        t._last_crash_time = 1.0
         mock_proc.poll.return_value = 1  # worker died again
 
-        with patch("voiceio.transcriber.subprocess.Popen", return_value=mock_proc):
+        with patch("voiceio.transcriber.subprocess.Popen", return_value=mock_proc), \
+                patch("voiceio.transcriber.time") as mock_time:
+            mock_time.monotonic.return_value = 1.0 + RESTART_RESET_SECS + 60
             t._ensure_worker()  # must NOT raise — counter reset then incremented
 
         assert t._restarts == 1

{python_voiceio-0.4.1 → python_voiceio-0.5.0}/tests/test_wizard.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 
 from unittest.mock import patch
 
+import os
+
 import pytest
 
 import voiceio.config as config
@@ -72,8 +74,8 @@ def test_write_config_roundtrips_through_loader(cfg_paths):
     assert loaded.output.voice_input_prefix == "[voice]"
 
 
+@pytest.mark.skipif(os.name != "posix", reason="POSIX permissions only")
 def test_write_config_restricts_permissions(cfg_paths):
-    import os
     wizard._write_config(
         model="small", language="en", hotkey="ctrl+alt+v", method="auto",
         streaming=True, backend="evdev", quiet=True,

python_voiceio-0.5.0/voiceio/__init__.py

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

{python_voiceio-0.4.1 → python_voiceio-0.5.0}/voiceio/app.py

@@ -337,7 +337,31 @@ class VoiceIO:
                 log.exception("Cannot reopen audio stream, aborting recording")
                 return
 
-        if not self.recorder.has_signal():
+        if self.recorder.is_zombie():
+            # Full pre-buffer of digital zeros with a "healthy" stream is the
+            # post-suspend zombie signature (callbacks fire, capture node
+            # gone). Reopening fixes it; a failed reopen means no audio is
+            # possible, so abort rather than record silence.
+            log.warning("Zombie audio stream (all-zero pre-buffer) — reopening")
+            try:
+                self.recorder.reopen_stream()
+                time.sleep(0.4)  # let the new stream fill some pre-buffer
+            except Exception:
+                log.exception("Audio stream reopen failed, aborting recording")
+                from voiceio import feedback
+                feedback.notify(
+                    "VoiceIO: microphone unavailable",
+                    "Could not reopen the audio stream — check your input device.",
+                )
+                return
+            if not self.recorder.has_signal():
+                log.warning("Mic still silent after reopen — muted or wrong device?")
+                from voiceio import feedback
+                feedback.notify(
+                    "VoiceIO: microphone appears silent",
+                    "Check that your mic is unmuted and the right input device is selected.",
+                )
+        elif not self.recorder.has_signal():
             log.warning("Mic appears silent or muted (pre-buffer is all zeros)")
 
         self._state = _State.RECORDING
@@ -368,6 +392,7 @@ class VoiceIO:
                 llm=self._llm,
                 voice_input_prefix=self._voice_input_prefix,
                 on_typer_broken=self._on_typer_broken,
+                on_interim=self._on_interim_text,
             )
             self._session.start()
         log.info("Recording... press [%s] again to stop", self.cfg.hotkey.key)
@@ -492,12 +517,19 @@ class VoiceIO:
     ) -> None:
         """Run final transcription and commit in background thread."""
         t_final = time.monotonic()
+        # Snappy clipboard: make the best-so-far text pasteable the moment
+        # the user stops, instead of after the (possibly long) final decode.
+        if (self.cfg.output.copy_to_clipboard == "live"
+                and self._typer.name != "clipboard" and session.interim_text):
+            from voiceio import clipboard_read
+            clipboard_read.copy_text(session.interim_text)
         extra = self._retention_extra(audio)
         final_text = session.stop(audio)
         if self._generation != gen:
             log.debug("Finalize cancelled (gen %d, current %d)", gen, self._generation)
             return
         if final_text:
+            self._copy_result_async(final_text)
             self._play_feedback(final_text)
             stored = self._strip_voice_prefix(final_text)
             self._prompt_builder.add_transcript(stored)
@@ -565,6 +597,7 @@ class VoiceIO:
                 # Superseded by a newer recording — do not touch the typer.
                 if text and self._generation == gen:
                     self._type_with_fallback(text)
+                    self._copy_result_async(text)
                     self._play_feedback(text)
                     stored = self._strip_voice_prefix(text)
                     self._prompt_builder.add_transcript(stored)
@@ -660,6 +693,35 @@ class VoiceIO:
             from voiceio.feedback import play_record_stop
             play_record_stop()
 
+    def _on_interim_text(self, text: str) -> None:
+        """Streaming update: mirror the best-so-far text to the clipboard.
+
+        Runs on the streaming worker thread (a copy is a few ms). Skipped for
+        the clipboard typer, which pastes FROM the clipboard — overwriting it
+        here could race a pending Ctrl+V and paste the full text twice.
+        """
+        if self.cfg.output.copy_to_clipboard != "live":
+            return
+        if self._typer.name == "clipboard":
+            return
+        from voiceio import clipboard_read
+        clipboard_read.copy_text(text)
+
+    def _copy_result_async(self, text: str) -> None:
+        """Mirror the final text to the clipboard, off the commit hot path."""
+        if self.cfg.output.copy_to_clipboard not in ("final", "live"):
+            return
+
+        def _copy() -> None:
+            # Give a just-sent paste keystroke time to consume the clipboard
+            # before we overwrite it with the full text.
+            if self._typer.name == "clipboard":
+                time.sleep(0.3)
+            from voiceio import clipboard_read
+            clipboard_read.copy_text(text)
+
+        threading.Thread(target=_copy, daemon=True).start()
+
     def _play_feedback(self, text: str) -> None:
         if self.cfg.feedback.sound_enabled:
             from voiceio.feedback import play_commit_sound

{python_voiceio-0.4.1 → python_voiceio-0.5.0}/voiceio/clipboard_read.py

@@ -1,4 +1,4 @@
-"""Read text from the system clipboard or primary selection."""
+"""Read/write text from/to the system clipboard or primary selection."""
 from __future__ import annotations
 
 import logging
@@ -67,3 +67,49 @@ def read_text() -> str | None:
 
     log.debug("No clipboard tool found")
     return None
+
+
+def _copy_via(cmd: list[str], text: str) -> bool:
+    """Pipe text into a copy command. Returns True on success."""
+    try:
+        result = subprocess.run(
+            cmd, input=text.encode(), capture_output=True, timeout=_TIMEOUT,
+        )
+        return result.returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+        return False
+
+
+def copy_text(text: str) -> bool:
+    """Copy text to the system CLIPBOARD selection.
+
+    Best-effort: returns False (never raises) when no tool is available
+    or the copy fails.
+    """
+    if not text:
+        return False
+    p = detect()
+
+    if p.is_windows:
+        try:
+            import pyperclip
+            pyperclip.copy(text)
+            return True
+        except Exception:
+            log.debug("pyperclip not available for clipboard write")
+            return False
+
+    if p.is_mac:
+        return _copy_via(["pbcopy"], text)
+
+    if p.is_wayland:
+        if shutil.which("wl-copy"):
+            return _copy_via(["wl-copy", "--"], text)
+    else:
+        if shutil.which("xclip"):
+            return _copy_via(["xclip", "-selection", "clipboard"], text)
+        if shutil.which("xsel"):
+            return _copy_via(["xsel", "-i", "--clipboard"], text)
+
+    log.debug("No clipboard tool found for copy")
+    return False

{python_voiceio-0.4.1 → python_voiceio-0.5.0}/voiceio/config.py

@@ -79,6 +79,12 @@ class OutputConfig:
     punctuation_cleanup: bool = True
     number_conversion: bool = True
     voice_input_prefix: str = ""           # e.g. "[voice]" — empty disables
+    # Mirror transcribed text to the system clipboard so it can be pasted:
+    #   "off"   — never
+    #   "final" — the corrected final text, once ready
+    #   "live"  — also the best-so-far text at each streaming update and the
+    #             instant recording stops (pasteable while the final decode runs)
+    copy_to_clipboard: str = "final"
 
 
 @dataclass

{python_voiceio-0.4.1 → python_voiceio-0.5.0}/voiceio/recorder.py

@@ -162,6 +162,17 @@ class AudioRecorder:
                 return False, f"no audio callback for {stale:.1f}s"
         return True, ""
 
+    def is_zombie(self) -> bool:
+        """Stream firing callbacks but delivering only digital zeros.
+
+        The post-suspend PortAudio failure mode: the heartbeat stays healthy
+        while the capture node is gone. Distinct from a merely-empty ring
+        (fresh stream) or a muted mic (noise floor > 0 on real hardware).
+        """
+        if self._ring._filled < self._ring._max:
+            return False  # ring not yet full — can't judge
+        return not self.has_signal()
+
     def has_signal(self) -> bool:
         """Check if the pre-buffer ring contains non-silence audio.
 

{python_voiceio-0.4.1 → python_voiceio-0.5.0}/voiceio/streaming.py

@@ -84,6 +84,7 @@ class StreamingSession:
         voice_input_prefix: str = "",
         on_typer_broken: Callable[[], None] | None = None,
         is_current: Callable[[], bool] | None = None,
+        on_interim: Callable[[str], None] | None = None,
     ):
         self._transcriber = transcriber
         self._typer = typer
@@ -104,6 +105,7 @@ class StreamingSession:
         self._llm = llm
         self._voice_input_prefix = voice_input_prefix
         self._on_typer_broken = on_typer_broken
+        self._on_interim = on_interim
         self._typer_fail_count = 0
         self._typer_broken_signalled = False
         self._typed_text = ""
@@ -116,6 +118,11 @@ class StreamingSession:
         self.final_latency: dict = {}
         self.final_segments: list[dict] = []
 
+    @property
+    def interim_text(self) -> str:
+        """Best-so-far text (post-pipeline). Safe to read while finalizing."""
+        return self._typed_text
+
     def set_is_current(self, is_current: Callable[[], bool]) -> None:
         """Install the output-ownership gate (see __init__).
 
@@ -280,7 +287,13 @@ class StreamingSession:
                 return
 
             if text:
+                prev = self._typed_text
                 self._apply_correction(text, final=final)
+                if not final and self._on_interim and self._typed_text != prev:
+                    try:
+                        self._on_interim(self._typed_text)
+                    except Exception:
+                        log.debug("on_interim callback failed", exc_info=True)
 
     def _commit_interim_on_final(self) -> None:
         """Commit whatever interim text we have when the final pass yields none.

{python_voiceio-0.4.1 → python_voiceio-0.5.0}/voiceio/wizard.py

@@ -680,7 +680,7 @@ def _write_config(
             "model": autocorrect_model or "moonshotai/kimi-k2-0905",
         })
 
-    CONFIG_PATH.write_text(_dump_toml(cfg))
+    CONFIG_PATH.write_text(_dump_toml(cfg), encoding="utf-8")
     _secure_config_permissions()
     if not quiet:
         print(f"\n  {GREEN}✓{RESET} Config saved to {DIM}{CONFIG_PATH}{RESET}")

python_voiceio-0.4.1/voiceio/__init__.py

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