python-voiceio 0.3.2__tar.gz → 0.3.3__tar.gz

{python_voiceio-0.3.2/python_voiceio.egg-info → python_voiceio-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.3.2
+Version: 0.3.3
 Summary: Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.3.2 → python_voiceio-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "0.3.2"
+version = "0.3.3"
 description = "Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"

{python_voiceio-0.3.2 → python_voiceio-0.3.3/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.3.2
+Version: 0.3.3
 Summary: Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.3.2 → python_voiceio-0.3.3}/tests/test_app_wiring.py

@@ -28,7 +28,12 @@ def _make_vio(mock_transcriber=None):
 
         from voiceio.app import VoiceIO
         vio = VoiceIO(Config())
-        vio.recorder._stream = MagicMock()  # skip real audio
+        mock_stream = MagicMock()
+        mock_stream.active = True
+        mock_stream.closed = False
+        mock_stream.stopped = False
+        vio.recorder._stream = mock_stream  # skip real audio
+        vio.recorder._last_callback_time = time.monotonic()  # healthy heartbeat
         return vio, mock_typer, mock_transcriber
 
 

python_voiceio-0.3.3/voiceio/__init__.py

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

{python_voiceio-0.3.2 → python_voiceio-0.3.3}/voiceio/app.py

@@ -8,6 +8,7 @@ import signal
 import subprocess
 import threading
 import time
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -22,6 +23,9 @@ from voiceio.transcriber import Transcriber
 from voiceio.typers import chain as typer_chain
 from voiceio.vad import load_vad
 from voiceio.vocabulary import load_vocabulary
+
+if TYPE_CHECKING:
+    from voiceio.typers.base import TyperBackend
 log = logging.getLogger("voiceio")
 _DEBOUNCE_SECS = 0.3
 
@@ -117,6 +121,10 @@ class VoiceIO:
         self._engine_proc: subprocess.Popen | None = None
         self._shutdown = threading.Event()
 
+        # Audio stream recovery backoff
+        self._stream_fail_count = 0
+        self._next_stream_retry: float = 0
+
     def request_shutdown(self) -> None:
         """Request graceful shutdown from an external signal handler."""
         self._shutdown.set()
@@ -169,6 +177,19 @@ class VoiceIO:
 
     def _do_start(self) -> None:
         """Transition to RECORDING."""
+        # Pre-flight: ensure audio stream is healthy before recording
+        ok, reason = self.recorder.stream_health()
+        if not ok:
+            log.warning("Audio stream unhealthy before recording: %s — reopening", reason)
+            try:
+                self.recorder.reopen_stream()
+            except Exception:
+                log.exception("Cannot reopen audio stream, aborting recording")
+                return
+
+        if not self.recorder.has_signal():
+            log.warning("Mic appears silent or muted (pre-buffer is all zeros)")
+
         self._state = _State.RECORDING
         self._activate_ibus()
         self._corrections.load()  # hot-reload corrections on each recording
@@ -452,6 +473,30 @@ class VoiceIO:
         self._set_gnome_input_source_index(0)
         log.info("VoiceIO IBus engine ready (dormant until recording)")
 
+    def _wait_for_ibus(self, chain: list[str]) -> TyperBackend | None:
+        """Wait for IBus daemon to become available and switch to IBus typer.
+
+        At session startup, voiceio may start before ibus-daemon is ready.
+        This polls briefly so we can use IBus instead of a broken fallback.
+        """
+        from voiceio.typers.ibus import _ibus_daemon_running
+
+        log.info("IBus preferred but not available yet, waiting for ibus-daemon...")
+        for i in range(30):  # up to ~15 seconds
+            time.sleep(0.5)
+            if _ibus_daemon_running():
+                log.info("IBus daemon ready after %.1fs, re-probing typers", (i + 1) * 0.5)
+                try:
+                    typer = typer_chain.select(self.platform, self.cfg.output.method)
+                    if typer.name == "ibus":
+                        self._ensure_ibus_engine()
+                        return typer
+                except RuntimeError:
+                    pass
+                break
+        log.warning("IBus daemon did not start in time, using fallback typer: %s", self._typer.name)
+        return None
+
     @staticmethod
     def _kill_stale_engine(socket_path) -> None:
         socket_path.unlink(missing_ok=True)
@@ -566,6 +611,39 @@ class VoiceIO:
                         self._state = _State.ERROR
                         tray.set_error(True)
 
+        # Check audio stream (covers ALSA underrun, PulseAudio/PipeWire
+        # restart, device disconnect, stale callback heartbeat)
+        ok, reason = self.recorder.stream_health()
+        if not ok:
+            now = time.monotonic()
+            if now < self._next_stream_retry:
+                return  # backoff: skip this cycle
+            log.warning("Audio stream unhealthy: %s — reopening (attempt %d)",
+                        reason, self._stream_fail_count + 1)
+            try:
+                self.recorder.reopen_stream()
+                self._stream_fail_count = 0
+                self._next_stream_retry = 0
+                tray.set_error(False)
+                log.info("Audio stream recovered")
+            except Exception:
+                self._stream_fail_count += 1
+                # Backoff: 10s, 20s, 40s, 80s, max 5min
+                delay = min(10 * (2 ** (self._stream_fail_count - 1)), 300)
+                self._next_stream_retry = now + delay
+                tray.set_error(True)
+                log.error("Audio stream recovery failed (retry in %ds)", delay)
+        elif self._stream_fail_count > 0:
+            # Stream recovered externally (e.g. device plugged back in)
+            self._stream_fail_count = 0
+            self._next_stream_retry = 0
+            tray.set_error(False)
+
+        # Check tray subprocess (restart if died / lost D-Bus registration)
+        if self.cfg.tray.enabled and not tray.is_alive():
+            log.warning("Tray subprocess died, restarting")
+            tray.restart(self.on_hotkey)
+
         # Check IBus engine (restart if died)
         if self._typer.name == "ibus" and self._engine_proc is not None:
             if self._engine_proc.poll() is not None:
@@ -598,6 +676,13 @@ class VoiceIO:
 
         if self._typer.name == "ibus":
             self._ensure_ibus_engine()
+        else:
+            # IBus daemon may not be ready at startup (race with graphical
+            # session). If IBus is in the preferred chain but wasn't selected,
+            # wait briefly and re-probe.
+            chain = typer_chain._get_chain(self.platform)
+            if "ibus" in chain and self._typer.name != "ibus":
+                self._typer = self._wait_for_ibus(chain) or self._typer
 
         self.recorder.open_stream()
 

{python_voiceio-0.3.2 → python_voiceio-0.3.3}/voiceio/ibus/engine.py

@@ -147,6 +147,16 @@ def _socket_listener(mainloop: GLib.MainLoop) -> None:
                     pass
             continue
 
+        if msg == "focus?":
+            # Quick focus query — no need to go through GLib
+            if addr and _engine is not None:
+                reply = b"focused" if _engine._focused else b"unfocused"
+                try:
+                    sock.sendto(reply, addr)
+                except OSError:
+                    pass
+            continue
+
         # Dispatch to engine on GLib main thread
         GLib.idle_add(_handle_command, msg)
 

{python_voiceio-0.3.2 → python_voiceio-0.3.3}/voiceio/recorder.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import logging
 import threading
+import time
 from typing import TYPE_CHECKING, Callable
 
 import numpy as np
@@ -107,6 +108,9 @@ class AudioRecorder:
         self._heard_speech = False
         self._on_auto_stop: Callable[[], None] | None = None
 
+        # Heartbeat: updated by _callback, checked by health watchdog
+        self._last_callback_time: float = 0.0
+
     def open_stream(self) -> None:
         """Start the always-on audio stream (feeds ring buffer)."""
         if self._stream is not None:
@@ -121,6 +125,54 @@ class AudioRecorder:
         self._stream.start()
         log.debug("Audio stream opened (prebuffer=%.1fs)", self.prebuffer_secs)
 
+    # Maximum seconds between callbacks before we consider the stream dead.
+    # PortAudio typically fires every ~50-100ms; 5s covers long system sleeps.
+    _HEARTBEAT_TIMEOUT = 5.0
+
+    def stream_health(self) -> tuple[bool, str]:
+        """Check audio stream health.  Returns (ok, reason).
+
+        Failure modes detected:
+        1. Stream object gone or closed     — device removed, close_stream() bug
+        2. stream.active is False           — ALSA underrun, PulseAudio restart
+        3. stream.stopped is True           — PortAudio callback abort/error
+        4. Callback heartbeat stale         — stream "active" but no callbacks
+           (device silently disconnected, PipeWire graph change, driver bug)
+        """
+        if self._stream is None:
+            return False, "stream is None"
+        if self._stream.closed:
+            return False, "stream closed"
+        if not self._stream.active:
+            return False, "stream not active"
+        if self._stream.stopped:
+            return False, "stream stopped"
+        if self._last_callback_time > 0:
+            stale = time.monotonic() - self._last_callback_time
+            if stale > self._HEARTBEAT_TIMEOUT:
+                return False, f"no audio callback for {stale:.1f}s"
+        return True, ""
+
+    def has_signal(self) -> bool:
+        """Check if the pre-buffer ring contains non-silence audio.
+
+        Returns False if the ring is all zeros (mic muted, wrong device,
+        or stream not delivering real data).
+        """
+        buf = self._ring.get()
+        if len(buf) == 0:
+            return False
+        # Check if peak amplitude is above a very low floor (~-80 dB).
+        # Even "silence" from a working mic has some noise > 1e-4.
+        return float(np.max(np.abs(buf))) > 1e-4
+
+    def reopen_stream(self) -> None:
+        """Close and reopen the audio stream (recovery from audio errors)."""
+        log.info("Reopening audio stream")
+        self.close_stream()
+        self._last_callback_time = 0.0
+        self.open_stream()
+
     def close_stream(self) -> None:
         """Stop the always-on audio stream."""
         if self._stream is not None:
@@ -201,6 +253,8 @@ class AudioRecorder:
     def _callback(
         self, indata: np.ndarray, frames: int, time_info: object, status: object
     ) -> None:
+        self._last_callback_time = time.monotonic()
+
         if status:
             log.warning("Audio stream status: %s", status)
 

{python_voiceio-0.3.2 → python_voiceio-0.3.3}/voiceio/streaming.py

@@ -135,10 +135,16 @@ class StreamingSession:
             self._pending.wait(timeout=1.0)
             if self._stop_event.is_set():
                 break
-            self._transcribe_and_apply()
+            try:
+                self._transcribe_and_apply()
+            except Exception:
+                log.exception("Streaming transcribe/apply error (non-fatal)")
 
         # Final transcription on stop using the audio snapshot
-        self._transcribe_and_apply(min_seconds=0.5, final=True)
+        try:
+            self._transcribe_and_apply(min_seconds=0.5, final=True)
+        except Exception:
+            log.exception("Final transcribe/apply error")
         self._final_audio = None  # release memory
 
     def _transcribe_and_apply(

{python_voiceio-0.3.2 → python_voiceio-0.3.3}/voiceio/tray/__init__.py

@@ -257,6 +257,54 @@ def set_error(error: bool) -> None:
         set_title("voiceio - error" if error else "voiceio - idle")
 
 
+def is_alive() -> bool:
+    """Check if the tray subprocess is still running (indicator backend only)."""
+    if _backend == "indicator":
+        return _proc is not None and _proc.poll() is None
+    # pystray runs in-process, assume alive if backend is set
+    return _backend is not None
+
+
+def restart(toggle_callback: Callable[[], None] | None = None) -> bool:
+    """Restart a dead indicator subprocess. Returns True on success."""
+    global _proc, _stdout_thread
+
+    if _backend != "indicator":
+        return False
+    if _proc is not None and _proc.poll() is None:
+        return True  # still alive
+
+    system_python = _find_system_python()
+    if not system_python or _theme_dir is None:
+        return False
+
+    from voiceio.tray._icons import ANIM_INTERVAL_MS
+    # Read icon names from existing theme dir
+    apps_dir = _theme_dir / "hicolor"
+    icon_names: list[str] = []
+    for d in apps_dir.rglob("apps"):
+        icon_names = sorted(
+            p.stem for p in d.glob("*.png")
+        )
+        break
+    if not icon_names:
+        return False
+
+    log.info("Restarting tray indicator subprocess")
+    _proc = _start_indicator(
+        _theme_dir, icon_names, ANIM_INTERVAL_MS, system_python,
+    )
+    if toggle_callback is not None:
+        _stdout_thread = threading.Thread(
+            target=_read_stdout,
+            args=(_proc, toggle_callback),
+            daemon=True,
+            name="tray-stdout",
+        )
+        _stdout_thread.start()
+    return True
+
+
 def stop() -> None:
     """Stop the tray icon and clean up."""
     global _proc, _backend, _stdout_thread

{python_voiceio-0.3.2 → python_voiceio-0.3.3}/voiceio/typers/ibus.py

@@ -274,13 +274,17 @@ class IBusTyper:
     """IBus preedit for streaming preview, IBus commit for final text.
 
     Also copies committed text to clipboard so terminal users (where IBus
-    doesn't reach) can Ctrl+Shift+V to paste.
+    doesn't reach) can Ctrl+Shift+V to paste.  When the IBus engine reports
+    that no client has focus (e.g. terminal emulators), we auto-paste via
+    ydotool/wtype so the user doesn't have to paste manually.
     """
 
     name = "ibus"
 
     def __init__(self, platform=None, **kwargs):
         self._wl_copy = shutil.which("wl-copy")
+        self._ydotool = shutil.which("ydotool")
+        self._wtype = shutil.which("wtype")
         self._sock: socket.socket | None = None
         self._wl_copy_proc: subprocess.Popen | None = None
 
@@ -331,6 +335,8 @@ class IBusTyper:
             return
         self._send(f"commit:{text}")
         self._copy_to_clipboard(text)
+        if not self._engine_has_focus():
+            self._simulate_paste()
 
     def delete_chars(self, n: int) -> None:
         pass  # Not needed: preedit handles corrections atomically
@@ -346,6 +352,8 @@ class IBusTyper:
         log.debug("Committing via IBus (%d chars)", len(text))
         self._send(f"commit:{text}")
         self._copy_to_clipboard(text)
+        if not self._engine_has_focus():
+            self._simulate_paste()
 
     def clear_preedit(self) -> None:
         self._send("clear")
@@ -363,6 +371,38 @@ class IBusTyper:
                 self._sock.close()
                 self._sock = None
 
+    def _engine_has_focus(self) -> bool:
+        """Ask the IBus engine whether it has input focus in the active window."""
+        try:
+            sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+            sock.settimeout(0.3)
+            sock.bind("")  # autobind for receiving reply
+            sock.sendto(b"focus?", str(SOCKET_PATH))
+            data, _ = sock.recvfrom(64)
+            sock.close()
+            return data == b"focused"
+        except (OSError, socket.timeout):
+            return True  # assume focused on error (safe default: no extra paste)
+
+    def _simulate_paste(self) -> None:
+        """Simulate Ctrl+V to paste clipboard into non-IBus apps (terminals)."""
+        try:
+            if self._ydotool:
+                # ydotool key scancodes: 29=LCtrl, 47=V
+                subprocess.run(
+                    [self._ydotool, "key", "29:1", "47:1", "47:0", "29:0"],
+                    capture_output=True, timeout=3,
+                )
+            elif self._wtype:
+                subprocess.run(
+                    [self._wtype, "-M", "ctrl", "-k", "v", "-m", "ctrl"],
+                    capture_output=True, timeout=3,
+                )
+            else:
+                log.debug("No paste tool available (ydotool/wtype)")
+        except (subprocess.TimeoutExpired, OSError) as e:
+            log.debug("Paste simulation failed: %s", e)
+
     def _copy_to_clipboard(self, text: str) -> None:
         """Copy text to clipboard as backup for non-IBus apps (terminals).
 

python_voiceio-0.3.2/voiceio/__init__.py

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