python-voiceio 0.9.9__tar.gz → 0.9.10__tar.gz

{python_voiceio-0.9.9/python_voiceio.egg-info → python_voiceio-0.9.10}/PKG-INFO

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

{python_voiceio-0.9.9 → python_voiceio-0.9.10}/pyproject.toml

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

{python_voiceio-0.9.9 → python_voiceio-0.9.10/python_voiceio.egg-info}/PKG-INFO

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

{python_voiceio-0.9.9 → python_voiceio-0.9.10}/tests/test_robustness.py

@@ -163,6 +163,43 @@ class TestAutoStopNotification:
         assert not notify.called
 
 
+class TestNothingCapturedWarning:
+    """A muted mic must be reported when the recording ENDS — the moment the
+    user looks for text and finds none — however it was stopped."""
+
+    def test_warns_when_no_signal_and_no_text(self):
+        vio, _, _ = _make_vio()
+        vio.recorder._heard_signal = False
+        with patch("voiceio.feedback.notify") as notify:
+            vio._warn_if_nothing_captured("", vio._generation)
+        assert notify.called
+        assert "mute" in " ".join(notify.call_args[0]).lower()
+        assert notify.call_args.kwargs.get("urgent") is True  # must persist
+
+    def test_quiet_when_text_was_produced(self):
+        vio, _, _ = _make_vio()
+        vio.recorder._heard_signal = False
+        with patch("voiceio.feedback.notify") as notify:
+            vio._warn_if_nothing_captured("[voice] hello there", vio._generation)
+        assert not notify.called
+
+    def test_quiet_when_mic_had_signal(self):
+        """Mic works, user just said nothing — not a fault, stay quiet."""
+        vio, _, _ = _make_vio()
+        vio.recorder._heard_signal = True
+        with patch("voiceio.feedback.notify") as notify:
+            vio._warn_if_nothing_captured("", vio._generation)
+        assert not notify.called
+
+    def test_superseded_generation_does_not_warn(self):
+        """A newer recording owns the recorder — don't judge this take by it."""
+        vio, _, _ = _make_vio()
+        vio.recorder._heard_signal = False
+        with patch("voiceio.feedback.notify") as notify:
+            vio._warn_if_nothing_captured("", vio._generation - 1)
+        assert not notify.called
+
+
 # ===========================================================================
 # 1. stream_health() tests
 # ===========================================================================

python_voiceio-0.9.10/voiceio/__init__.py

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

{python_voiceio-0.9.9 → python_voiceio-0.9.10}/voiceio/app.py

@@ -253,6 +253,9 @@ class VoiceIO:
         # system is not a zombie) and a guard against concurrent spawns
         # (health loop vs record-start).
         self._engine_ping_fails = 0
+        # Engine stderr goes to a file (never a pipe — see _spawn_ibus_engine).
+        self._engine_stderr_file = None
+        self._engine_stderr_path = None
         self._engine_spawn_lock = threading.Lock()
         self._shutdown = threading.Event()
         # IBus input-source ownership. We claim the GNOME input source ONLY
@@ -308,6 +311,29 @@ class VoiceIO:
                 )
         threading.Thread(target=self._request_stop, daemon=True).start()
 
+    def _warn_if_nothing_captured(self, final_text: str, gen: int) -> None:
+        """Warn when a finished recording captured no audio at all.
+
+        This is the moment the user actually notices — they look for their text
+        and nothing appeared. The pre-flight warning is a 3s toast they talk
+        straight through, and the 20s no-speech auto-stop never fires on a
+        shorter take stopped by hand, which is exactly how a muted mic slips
+        by silently. Generation-guarded: a newer recording owns the recorder,
+        so never read its state to judge this one.
+        """
+        if self._generation != gen:
+            return
+        if final_text.strip() or self.recorder.heard_signal:
+            return
+        log.warning("Recording captured no audio at all — mic muted?")
+        from voiceio import feedback
+        feedback.notify(
+            "VoiceIO: microphone is muted — nothing recorded",
+            "No audio reached voiceio for that entire recording. Check your "
+            "mic's mute button and which input device is selected.",
+            urgent=True,
+        )
+
     def _request_stop(self) -> None:
         """Stop recording if active. Unlike on_hotkey, never starts."""
         with self._hotkey_lock:
@@ -418,6 +444,7 @@ class VoiceIO:
                 feedback.notify(
                     "VoiceIO: microphone unavailable",
                     "Could not reopen the audio stream — check your input device.",
+                    urgent=True,
                 )
                 return
             if not self.recorder.has_signal():
@@ -426,6 +453,7 @@ class VoiceIO:
                 feedback.notify(
                     "VoiceIO: microphone appears silent",
                     "Check that your mic is unmuted and the right input device is selected.",
+                    urgent=True,
                 )
         elif not self.recorder.has_signal():
             log.warning("Mic appears silent or muted (pre-buffer is all zeros)")
@@ -639,6 +667,7 @@ class VoiceIO:
                 "passes": list(session.trace),
             })
         log.info("Streaming done (%.1fs): '%s'", elapsed, final_text)
+        self._warn_if_nothing_captured(final_text, gen)
         # Release the IBus input source now that the final commit is done.
         # Generation-checked inside: if a newer recording started, it already
         # re-claimed the source and we must not restore it out from under it.
@@ -989,6 +1018,18 @@ class VoiceIO:
         except Exception:
             log.exception("IBus engine respawn at record start failed")
 
+    def _engine_stderr_tail(self, limit: int = 500) -> str:
+        """Last bytes of the engine's stderr file, for crash reporting."""
+        path = getattr(self, "_engine_stderr_path", None)
+        if path is None:
+            return ""
+        try:
+            if self._engine_stderr_file is not None:
+                self._engine_stderr_file.flush()
+            return path.read_text(errors="replace").strip()[-limit:]
+        except OSError:
+            return ""
+
     def _ensure_ibus_engine(self, activate: bool = True) -> None:
         """Start the VoiceIO IBus engine, optionally pre-creating its instance.
 
@@ -1009,6 +1050,7 @@ class VoiceIO:
             self._engine_spawn_lock.release()
 
     def _spawn_ibus_engine(self, activate: bool = True) -> None:
+        from voiceio.config import LOG_DIR
         from voiceio.ibus import READY_PATH, SOCKET_PATH
         from voiceio.typers.ibus import LAUNCHER_PATH, _ibus_env
 
@@ -1032,12 +1074,24 @@ class VoiceIO:
         self._kill_stale_engine(SOCKET_PATH)
         READY_PATH.unlink(missing_ok=True)
 
-        # Spawn the engine process directly
+        # Spawn the engine process directly. stderr goes to a FILE, never a
+        # pipe: the engine logs at DEBUG through a StreamHandler, and a piped,
+        # undrained stderr fills its 64KB buffer and blocks the engine
+        # mid-write — alive but frozen, so it stops answering pings and the
+        # watchdog reaps it (the recurring "not responding to ping" churn).
+        # The worker already does it this way.
         log.info("Starting VoiceIO IBus engine...")
+        stderr_target = subprocess.DEVNULL
+        try:
+            self._engine_stderr_path = LOG_DIR / "ibus-engine-stderr.log"
+            self._engine_stderr_file = open(self._engine_stderr_path, "w")
+            stderr_target = self._engine_stderr_file
+        except OSError:
+            self._engine_stderr_path = None
         try:
             self._engine_proc = subprocess.Popen(
                 [str(LAUNCHER_PATH)],
-                stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
+                stdout=subprocess.DEVNULL, stderr=stderr_target,
                 env=ibus_env,
             )
         except OSError as e:
@@ -1052,8 +1106,8 @@ class VoiceIO:
             time.sleep(0.1)
         else:
             if self._engine_proc.poll() is not None:
-                stderr = self._engine_proc.stderr.read().decode(errors="replace") if self._engine_proc.stderr else ""
-                log.error("IBus engine crashed (rc=%d): %s", self._engine_proc.returncode, stderr.strip()[-500:])
+                log.error("IBus engine crashed (rc=%d): %s",
+                          self._engine_proc.returncode, self._engine_stderr_tail())
             else:
                 log.warning("IBus engine started but socket not found, commands may fail")
             return

{python_voiceio-0.9.9 → python_voiceio-0.9.10}/voiceio/feedback.py

@@ -106,10 +106,14 @@ def _play_sync(name: str) -> None:
         log.debug("Playback failed for %s", name, exc_info=True)
 
 
-def notify(title: str, body: str) -> None:
-    """Send a desktop notification without blocking the caller."""
+def notify(title: str, body: str, *, urgent: bool = False) -> None:
+    """Send a desktop notification without blocking the caller.
+
+    ``urgent=True`` marks it critical so the desktop keeps it on screen until
+    dismissed — for actionable failures (a muted mic) that a 3s toast loses.
+    """
     threading.Thread(
-        target=_send_notification, args=(title, body), daemon=True,
+        target=_send_notification, args=(title, body, urgent), daemon=True,
     ).start()
 
 
@@ -118,7 +122,7 @@ def notify_clipboard(text: str) -> None:
     notify("VoiceIO: copied to clipboard", preview)
 
 
-def _send_notification(title: str, body: str) -> None:
+def _send_notification(title: str, body: str, urgent: bool = False) -> None:
     import sys
 
     if sys.platform == "win32":
@@ -126,17 +130,18 @@ def _send_notification(title: str, body: str) -> None:
     elif sys.platform == "darwin":
         _send_notification_macos(title, body)
     else:
-        _send_notification_linux(title, body)
+        _send_notification_linux(title, body, urgent)
 
 
-def _send_notification_linux(title: str, body: str) -> None:
+def _send_notification_linux(title: str, body: str, urgent: bool = False) -> None:
     if not _which("notify-send"):
         return
+    # Critical urgency makes the desktop hold the notification until dismissed;
+    # a normal 3s toast is missed while the user is mid-dictation.
+    args = ["notify-send", "--app-name=VoiceIO"]
+    args += ["-u", "critical"] if urgent else ["-t", "3000"]
     try:
-        subprocess.run(
-            ["notify-send", "--app-name=VoiceIO", "-t", "3000", title, body],
-            capture_output=True, timeout=3,
-        )
+        subprocess.run([*args, title, body], capture_output=True, timeout=3)
     except (subprocess.TimeoutExpired, OSError):
         pass
 

{python_voiceio-0.9.9 → python_voiceio-0.9.10}/voiceio/recorder.py

@@ -185,6 +185,17 @@ class AudioRecorder:
             return False  # ring not yet full — can't judge
         return not self.has_signal()
 
+    @property
+    def heard_signal(self) -> bool:
+        """True if ANY real audio arrived during the recording just captured.
+
+        Latches on the first non-silent chunk and is reset by start(), so after
+        stop() it answers "did the mic actually deliver anything?" — False means
+        a muted or dead mic for the whole take, whether it ended by hotkey or
+        auto-stop.
+        """
+        return self._heard_signal
+
     def has_signal(self) -> bool:
         """Check if the pre-buffer ring contains non-silence audio.
 

{python_voiceio-0.9.9 → python_voiceio-0.9.10}/voiceio/tray/__init__.py

@@ -131,6 +131,27 @@ _MENU_COMMANDS: dict[str, list[str]] = {
 }
 
 
+def _read_stderr(proc: subprocess.Popen) -> None:
+    """Drain the indicator's stderr so it can never block on a full pipe.
+
+    GTK/AppIndicator emit warnings continuously. With stderr piped and nobody
+    reading it, the 64KB pipe buffer fills and the tray process blocks forever
+    inside write() — the process stays "alive" (so is_alive() sees nothing
+    wrong) while its GLib main loop is frozen, which silently kills the icon
+    animation, the menu, AND the registration watchdog that would otherwise
+    re-register a dropped icon. Observed live: wchan=anon_pipe_write, icon gone
+    for ~2 days. Logged at debug so the diagnostics survive without noise.
+    """
+    try:
+        while proc.poll() is None and proc.stderr:
+            line = proc.stderr.readline()
+            if not line:
+                break
+            log.debug("tray: %s", line.decode(errors="replace").rstrip())
+    except (OSError, ValueError):
+        pass
+
+
 def _read_stdout(proc: subprocess.Popen, toggle_cb: Callable[[], None]) -> None:
     """Read toggle/menu commands from indicator subprocess stdout."""
     from voiceio.platform import open_in_terminal
@@ -194,6 +215,14 @@ def start(
             )
             _backend = "indicator"
 
+            # Always drain stderr — unconditionally, and regardless of whether
+            # a toggle callback wants stdout. An undrained pipe blocks the tray
+            # process mid-write and freezes its GLib loop (see _read_stderr).
+            threading.Thread(
+                target=_read_stderr, args=(_proc,), daemon=True,
+                name="tray-stderr",
+            ).start()
+
             if toggle_callback is not None:
                 _stdout_thread = threading.Thread(
                     target=_read_stdout,

python_voiceio-0.9.9/voiceio/__init__.py

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