python-voiceio 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

{python_voiceio-0.7.0.dist-info → python_voiceio-0.7.1.dist-info}/METADATA

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

{python_voiceio-0.7.0.dist-info → python_voiceio-0.7.1.dist-info}/RECORD

@@ -1,13 +1,13 @@
-python_voiceio-0.7.0.dist-info/licenses/LICENSE,sha256=Gz61o8jFTAvZUZyB3nWDB3DQQVuipjfPkVu9W8hBHM0,1072
-voiceio/__init__.py,sha256=RaANGbRu5e-vehwXI1-Qe2ggPPfs1TQaZj072JdbLk4,22
+python_voiceio-0.7.1.dist-info/licenses/LICENSE,sha256=Gz61o8jFTAvZUZyB3nWDB3DQQVuipjfPkVu9W8hBHM0,1072
+voiceio/__init__.py,sha256=2KJZDSMOG7KS82AxYOrZ4ZihYxX0wjfUjDsIZh3L024,22
 voiceio/__main__.py,sha256=xT5QCGGreYMisHO7Lh_Y-xAQ2TOzG2D7npKknGNcWSY,53
-voiceio/app.py,sha256=4o3nOv_Z_NCBr6KTHr1eSGT159ZE98dVBAy5wUOpzAo,64398
+voiceio/app.py,sha256=7FfQzXIyM5GFbGzmPtRamUp4jsIvEj4P5GiA1rPBa3s,69751
 voiceio/audit.py,sha256=vX3x-YAhmt6EZYRZd0_6wvTquZu5sxGMvH45BhSBnCk,14915
 voiceio/autocorrect.py,sha256=jGsglEYwAHWk2uWedeEZzyAMW2LWO_8nQGZgrWYy4Dc,26552
 voiceio/autocorrect_state.py,sha256=BNzdHP5slcOV_-OU4MlaKE7xgVJzrPncsYFK30JWTs8,6858
 voiceio/backends.py,sha256=-rs1YhPblub4NjFb6qCD7Ih9FqBRXtPuvjVv9bQoQ1w,368
 voiceio/cli.py,sha256=_HfcWQt2Jf34YfI4W1RavsyqegQy9jrg0nwLe6DvD6E,71639
-voiceio/clipboard_read.py,sha256=CqbHSvOztcQ3u2I2EzFm0jdcDVKv56gl0T1YfWxNpmI,3390
+voiceio/clipboard_read.py,sha256=lz75CkRGh7pyvO6xvoUmxJDl-Gwie1xlXQHK70PO84I,4261
 voiceio/commands.py,sha256=Vhtn8s5G5OcCbRN44YZ-_14Fa85ISXl_3Ix-KqSHs2A,4694
 voiceio/config.py,sha256=CHDtEigtv-aKPsDFFGkc1AiqmubiFHeU1HaEaPgoIMc,14343
 voiceio/consent.py,sha256=jtdp1TkTbicUSTCDmV4qo4SdbS4kQpYzy1Kjc_7pJVw,1883
@@ -43,7 +43,7 @@ voiceio/hotkeys/evdev.py,sha256=DHmd2IASBkYnyY5JEGFIoYfZtw3T9Ij6wKclkx-6m94,5109
 voiceio/hotkeys/pynput_backend.py,sha256=_rLb8p0JakR9T32LJclHVTch49M_mnB3UeUsI_IkfLk,3576
 voiceio/hotkeys/socket_backend.py,sha256=xLNFa8FvJbL5VLKqMRhKPeaKdhztYwxyVV_VOlG1PkM,3373
 voiceio/ibus/__init__.py,sha256=12n0pSsb1ZPE1kkscDFmcQjZzovC8zrAnmYbvIuv1AI,284
-voiceio/ibus/engine.py,sha256=yTCCHiUPL4-trggSCtIPZ-Wz0bxYoQWK72McypGNmXI,8735
+voiceio/ibus/engine.py,sha256=AUa0SUqo630uZrphnYX0JCsEo4ibN5yMR0P8BN3f-YA,8990
 voiceio/ibus/pending.py,sha256=T6Y_8oimhabahunp9RogtO-OTA5aw9d9G4T5lH1WAL4,1464
 voiceio/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 voiceio/models/silero_vad.onnx,sha256=GhU6IvRQnikqlOZ9b5uF6N6yW0mIaCt-F0xlJ52HiOM,2327524
@@ -66,13 +66,13 @@ voiceio/typers/__init__.py,sha256=lFIMEjfPGw8tfYGELhsq0mYM849uKLx_SZhbHqGJrlo,10
 voiceio/typers/base.py,sha256=VVMgARlpaSVqen-zFUssnbUMYDrWryacRE8MKvlLk-s,1180
 voiceio/typers/chain.py,sha256=F4QcAMTzYvrxeC-_Er4CbjnqQ1ONYjt7Fp11y8PNpqU,2964
 voiceio/typers/clipboard.py,sha256=cxeOL_a_P2HeJ-nr-klG94nHjbd9rWu3nxGDXmyfzys,6110
-voiceio/typers/ibus.py,sha256=ksYaCXHVrDTYR1R2MMt6H6csd4mtlbaf82DpebOyXbo,18715
+voiceio/typers/ibus.py,sha256=ciaB5OgW5RqgLVdGZqoBhU4q1ttkh7o2H4aAoXSCqbA,18531
 voiceio/typers/pynput_type.py,sha256=DTtkT59M-EKOAlTNkvcZrRvf_Fq52OpI8S5t_8S-QAY,1887
 voiceio/typers/wtype.py,sha256=d1wG-HZdYDQxXIysV_Xvk9HixDpaJgl3VEoKbP5vhIs,1786
 voiceio/typers/xdotool.py,sha256=dh1zhPqUT8ihJahJ7ZKm6PtfYY087UAzADx664DvQOM,1356
 voiceio/typers/ydotool.py,sha256=dt0W9ot__W8LQG2so8vZLGIw9leK2Q6g3i-Voo0LXE4,5327
-python_voiceio-0.7.0.dist-info/METADATA,sha256=hV7gmFjuAjAJpCb9O01qqobjZfk7qxk3Kjow7l5-oaI,15877
-python_voiceio-0.7.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-python_voiceio-0.7.0.dist-info/entry_points.txt,sha256=U64fA65zxzyLoC8bgbn2ztQVWHLsc0o0H0qCk1J9DMc,218
-python_voiceio-0.7.0.dist-info/top_level.txt,sha256=piwtn309lD6uexQyXdZ-efAVBJF9y6Wfr48Z-8zkNhg,8
-python_voiceio-0.7.0.dist-info/RECORD,,
+python_voiceio-0.7.1.dist-info/METADATA,sha256=fVpqxHUBfrnn_QwxBAthynoCWysESGlgDLcPK7nfsT8,15877
+python_voiceio-0.7.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+python_voiceio-0.7.1.dist-info/entry_points.txt,sha256=U64fA65zxzyLoC8bgbn2ztQVWHLsc0o0H0qCk1J9DMc,218
+python_voiceio-0.7.1.dist-info/top_level.txt,sha256=piwtn309lD6uexQyXdZ-efAVBJF9y6Wfr48Z-8zkNhg,8
+python_voiceio-0.7.1.dist-info/RECORD,,

voiceio/__init__.py

@@ -1 +1 @@
-__version__ = "0.7.0"
+__version__ = "0.7.1"

voiceio/app.py

@@ -234,6 +234,11 @@ class VoiceIO:
         # IBus engine management
         self._prev_ibus_engine: str | None = None
         self._engine_proc: subprocess.Popen | None = None
+        # Engine lifecycle: consecutive missed pings (one miss on a busy
+        # system is not a zombie) and a guard against concurrent spawns
+        # (health loop vs record-start).
+        self._engine_ping_fails = 0
+        self._engine_spawn_lock = threading.Lock()
         self._shutdown = threading.Event()
         # IBus input-source ownership. We claim the GNOME input source ONLY
         # while a recording is live (RECORDING/FINALIZING) and restore whatever
@@ -366,6 +371,15 @@ class VoiceIO:
 
         self._state = _State.RECORDING
         self._ibus_session_fallback = False
+        if self._typer.name == "ibus" and self._engine_proc is None:
+            # Engine was reaped while dormant (normal — see _check_health).
+            # Respawn in the background; the engine's pending buffer holds
+            # preedits until the instance is ready, and with state=RECORDING
+            # the spawn leaves the voiceio source active instead of yanking
+            # it back to dormant mid-recording.
+            threading.Thread(
+                target=self._respawn_engine_for_recording, daemon=True,
+            ).start()
         self._activate_ibus()
         self._corrections.load()  # hot-reload corrections on each recording
         self._refresh_hotwords()  # hot-reload vocabulary (mtime-cached)
@@ -898,8 +912,29 @@ class VoiceIO:
 
     # ── IBus engine lifecycle ───────────────────────────────────────────
 
+    def _respawn_engine_for_recording(self) -> None:
+        """Background lazy respawn at record start. Never raises."""
+        try:
+            self._ensure_ibus_engine()
+        except Exception:
+            log.exception("IBus engine respawn at record start failed")
+
     def _ensure_ibus_engine(self) -> None:
-        """Start the VoiceIO IBus engine and activate it."""
+        """Start the VoiceIO IBus engine and activate it.
+
+        Single-flight: a concurrent spawn (health loop vs record start)
+        is skipped rather than queued — two dances would fight over the
+        input source.
+        """
+        if not self._engine_spawn_lock.acquire(blocking=False):
+            log.debug("IBus engine spawn already in progress, skipping")
+            return
+        try:
+            self._spawn_ibus_engine()
+        finally:
+            self._engine_spawn_lock.release()
+
+    def _spawn_ibus_engine(self) -> None:
         from voiceio.ibus import READY_PATH, SOCKET_PATH
         from voiceio.typers.ibus import LAUNCHER_PATH, _ibus_env
 
@@ -976,9 +1011,16 @@ class VoiceIO:
         except subprocess.TimeoutExpired:
             activate_proc.kill()
 
-        # Return to dormancy on the user's real source (not hardcoded 0).
-        self._set_gnome_input_source_index(dormant_idx if dormant_idx is not None else 0)
-        log.info("VoiceIO IBus engine ready (dormant until recording)")
+        # Return to dormancy on the user's real source (not hardcoded 0) —
+        # unless a recording claimed the source while we were spawning:
+        # yanking it away now would kill the live preedit for that whole
+        # recording (the "underlined text never appears" symptom).
+        if self._state == _State.IDLE:
+            self._set_gnome_input_source_index(dormant_idx if dormant_idx is not None else 0)
+            self._release_ibus_engine()
+            log.info("VoiceIO IBus engine ready (dormant until recording)")
+        else:
+            log.info("VoiceIO IBus engine ready (recording live — staying active)")
 
     def _ping_ibus_engine(self) -> bool:
         """Check if the IBus engine's socket listener is alive.
@@ -991,7 +1033,7 @@ class VoiceIO:
         from voiceio.ibus import SOCKET_PATH
         try:
             sock = _socket.socket(_socket.AF_UNIX, _socket.SOCK_DGRAM)
-            sock.settimeout(1.0)
+            sock.settimeout(2.0)
             sock.bind("")
             sock.sendto(b"ping", str(SOCKET_PATH))
             data, _ = sock.recvfrom(64)
@@ -1091,6 +1133,49 @@ class VoiceIO:
         self._set_gnome_input_source_index(idx if idx is not None else 0)
         self._prev_input_source_index = None
         self._voiceio_source_index = None
+        self._release_ibus_engine()
+
+    def _ibus_engine_fallback(self) -> str:
+        """The user's non-voiceio ibus engine name, for releasing the engine."""
+        if self._prev_ibus_engine and self._prev_ibus_engine != "voiceio":
+            return self._prev_ibus_engine
+        try:
+            result = subprocess.run(
+                ["gsettings", "get", "org.gnome.desktop.input-sources", "sources"],
+                capture_output=True, text=True, timeout=3,
+            )
+            import ast
+            for kind, name in ast.literal_eval(result.stdout.strip()):
+                if kind == "xkb":
+                    return f"xkb:{name}::eng"
+        except Exception:
+            pass
+        return "xkb:us::eng"
+
+    def _release_ibus_engine(self) -> None:
+        """Point ibus's GLOBAL engine back at the user's layout when dormant.
+
+        Restoring the GNOME input source is not enough: the spawn dance sets
+        the global engine directly (`ibus engine voiceio`), and a gsettings
+        write that doesn't change the value never makes GNOME push an engine
+        change. The stale global engine then routes EVERY input context
+        through voiceio while "dormant" — constant focus churn that discards
+        any visible preedit, surviving daemon restarts.
+        """
+        from voiceio.typers.ibus import _ibus_env
+        try:
+            # Unconditional: querying first races the (async) activation —
+            # a stale reading made the release skip itself and left voiceio
+            # active. Going dormant means the user's engine should be the
+            # global one; setting it is idempotent.
+            fallback = self._ibus_engine_fallback()
+            subprocess.run(
+                ["ibus", "engine", fallback],
+                capture_output=True, timeout=3, env=_ibus_env(),
+            )
+            log.debug("Released ibus global engine to %s", fallback)
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            pass
 
     def _switch_gnome_input_source(self, engine_name: str) -> None:
         if not self.platform.is_gnome:
@@ -1124,6 +1209,16 @@ class VoiceIO:
                          "current", str(i)],
                         capture_output=True, timeout=3,
                     )
+                    # The gsettings write alone is a no-op on newer GNOME
+                    # (the 'current' key is legacy) — activation only ever
+                    # worked while the global engine was accidentally stuck
+                    # on voiceio. Claim it explicitly, mirroring
+                    # _release_ibus_engine() on deactivation.
+                    from voiceio.typers.ibus import _ibus_env
+                    subprocess.run(
+                        ["ibus", "engine", engine_name],
+                        capture_output=True, timeout=3, env=_ibus_env(),
+                    )
                     log.info("Switched GNOME input source to index %d (%s)", i, engine_name)
                     time.sleep(0.5)
                     return
@@ -1216,17 +1311,13 @@ class VoiceIO:
         # of ibus) — the preferred backend may be available now.
         self._try_upgrade_typer(reason="resume")
 
-        # IBus: restart the engine only if its process died. Never re-force the
-        # active input source on resume — activation happens on record-start.
+        # IBus: an engine that died during sleep is respawned lazily at the
+        # next record start (same as health-loop reaping — respawning here
+        # would grab the input source right as the user unlocks).
         if self._typer.name == "ibus" and self._engine_proc is not None:
             if self._engine_proc.poll() is not None:
-                # Engine process died during sleep
+                log.debug("Resume: IBus engine died during sleep — will respawn at next recording")
                 self._engine_proc = None
-                try:
-                    self._ensure_ibus_engine()
-                    log.info("Resume: IBus engine restarted")
-                except Exception:
-                    log.exception("Resume: IBus engine restart failed")
 
         # Tray: restart if subprocess died
         if self.cfg.tray.enabled and not tray.is_alive():
@@ -1295,29 +1386,45 @@ class VoiceIO:
         if self._state == _State.IDLE:
             self._health_typer_upkeep()
 
-        # Check IBus engine liveness. When IDLE we ONLY restart a dead/zombie
-        # engine process — we never re-force the active input source, so we
-        # don't fight users running a real IME. When a recording is live we
-        # watch for the user switching source away from us and fall back.
+        # Check IBus engine liveness. A dormant engine dying is NORMAL:
+        # ibus-daemon reaps deactivated engine processes (SIGTERM ~10s after
+        # the input source switches away). Eagerly respawning here created a
+        # spawn→activate→dormant→reap loop that grabbed the user's input
+        # source every cycle — the focus churn wiped any visible preedit
+        # (flickering underline). Respawn lazily at the next record start.
         if self._typer.name == "ibus" and self._engine_proc is not None:
             if self._engine_proc.poll() is not None:
-                log.warning("IBus engine process died (rc=%d), restarting",
-                            self._engine_proc.returncode)
+                rc = self._engine_proc.returncode
                 self._engine_proc = None
-                try:
-                    self._ensure_ibus_engine()
-                    log.info("IBus engine recovered")
-                except Exception:
-                    log.exception("IBus engine recovery failed")
+                self._engine_ping_fails = 0
+                if self._state == _State.IDLE:
+                    log.debug(
+                        "IBus engine exited while dormant (rc=%s) — normal "
+                        "reaping, will respawn at next recording", rc,
+                    )
+                else:
+                    log.warning("IBus engine died mid-recording (rc=%s), restarting", rc)
+                    try:
+                        self._ensure_ibus_engine()
+                        log.info("IBus engine recovered")
+                    except Exception:
+                        log.exception("IBus engine recovery failed")
             elif self._state == _State.IDLE:
                 # Engine process alive — check if its socket listener is
                 # actually responding. A zombie engine (process alive but
                 # GLib loop stuck / socket thread dead) silently drops all
-                # preedit and commit messages, causing the "transcription
-                # works but no text appears" symptom. Restart it, but do NOT
-                # touch the active input source.
+                # preedit and commit messages. One missed ping on a loaded
+                # system is not a zombie — require two consecutive misses.
                 if not self._ping_ibus_engine():
+                    self._engine_ping_fails += 1
+                    if self._engine_ping_fails < 2:
+                        log.debug(
+                            "IBus engine missed a ping (%d/2) — busy system?",
+                            self._engine_ping_fails,
+                        )
+                        return
                     log.warning("IBus engine not responding to ping, restarting")
+                    self._engine_ping_fails = 0
                     self._engine_proc.kill()
                     try:
                         self._engine_proc.wait(timeout=3)
@@ -1329,6 +1436,8 @@ class VoiceIO:
                         log.info("IBus engine recovered (was zombie)")
                     except Exception:
                         log.exception("IBus engine recovery failed")
+                else:
+                    self._engine_ping_fails = 0
             else:
                 # RECORDING / FINALIZING: don't re-force the source; if the
                 # user switched away from voiceio, fall back to clipboard.

voiceio/clipboard_read.py

@@ -70,10 +70,19 @@ def read_text() -> str | None:
 
 
 def _copy_via(cmd: list[str], text: str) -> bool:
-    """Pipe text into a copy command. Returns True on success."""
+    """Pipe text into a copy command. Returns True on success.
+
+    stdout/stderr go to DEVNULL, NOT pipes: xclip daemonizes (forks a child
+    that owns the selection and inherits the fds), so captured pipes never
+    reach EOF and run() would block for the full timeout, then report a
+    bogus failure — which used to trigger the wl-copy fallback and its
+    focus steal on every single copy.
+    """
     try:
         result = subprocess.run(
-            cmd, input=text.encode(), capture_output=True, timeout=_TIMEOUT,
+            cmd, input=text.encode(),
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            timeout=_TIMEOUT,
         )
         return result.returncode == 0
     except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
@@ -103,6 +112,13 @@ def copy_text(text: str) -> bool:
         return _copy_via(["pbcopy"], text)
 
     if p.is_wayland:
+        # Prefer xclip via the XWayland clipboard bridge: wl-copy can
+        # momentarily steal keyboard focus on GNOME (fallback surface),
+        # and a focus-out discards any visible IBus preedit — streaming
+        # milestone copies were wiping the underlined preview one frame
+        # after it painted. X11 selections never touch Wayland focus.
+        if shutil.which("xclip") and _copy_via(["xclip", "-selection", "clipboard"], text):
+            return True
         if shutil.which("wl-copy"):
             return _copy_via(["wl-copy", "--"], text)
     else:

voiceio/ibus/engine.py

@@ -43,9 +43,13 @@ class VoiceIOEngine(IBus.Engine):
         log.info("VoiceIOEngine instance created (path=%s)", kwargs.get("object_path"))
 
     def do_focus_in(self):
+        # Focus transitions also discard any visible preedit (IBus default
+        # mode), so log them — a flickering preedit is usually focus churn.
+        log.debug("focus_in")
         self._focused = True
 
     def do_focus_out(self):
+        log.debug("focus_out (preedit discarded by client if visible)")
         self._focused = False
 
     def do_process_key_event(self, keyval, keycode, state):

voiceio/typers/ibus.py

@@ -476,25 +476,17 @@ class IBusTyper:
     def _copy_to_clipboard(self, text: str) -> None:
         """Copy text to clipboard as backup for non-IBus apps (terminals).
 
-        Fire-and-forget. wl-copy stays alive to serve paste requests.
-        Kill previous instance to avoid accumulating processes.
+        Routed through clipboard_read.copy_text (xclip / XWayland bridge
+        first): wl-copy momentarily steals keyboard focus on GNOME, and the
+        focus-out discards any visible preedit.
         """
-        if not self._wl_copy:
-            return
-        # Kill previous wl-copy (it's replaced by the new one)
+        # Kill any wl-copy left over from the pre-xclip implementation.
         if self._wl_copy_proc is not None:
             try:
                 self._wl_copy_proc.kill()
             except OSError:
                 pass
-        try:
-            proc = subprocess.Popen(
-                ["wl-copy"],
-                stdin=subprocess.PIPE, stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
-            proc.stdin.write(text.encode())
-            proc.stdin.close()
-            self._wl_copy_proc = proc
-        except OSError as e:
-            log.debug("wl-copy failed to start: %s", e)
+            self._wl_copy_proc = None
+        from voiceio import clipboard_read
+        if not clipboard_read.copy_text(text):
+            log.debug("Clipboard copy failed (no working tool)")