python-voiceio 1.9.0__tar.gz → 1.9.2__tar.gz

{python_voiceio-1.9.0/python_voiceio.egg-info → python_voiceio-1.9.2}/PKG-INFO

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

{python_voiceio-1.9.0 → python_voiceio-1.9.2}/pyproject.toml

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

{python_voiceio-1.9.0 → python_voiceio-1.9.2/python_voiceio.egg-info}/PKG-INFO

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

{python_voiceio-1.9.0 → python_voiceio-1.9.2}/tests/test_context_terms.py

@@ -251,3 +251,41 @@ class TestDaemon:
             v.on_hotkey()
             time.sleep(0.1)
         cap.assert_not_called()
+
+
+def _fake_tmux(outputs):
+    calls = []
+
+    def run(args, timeout):
+        calls.append(args)
+        return outputs.get(args[0], "")
+    return run, calls
+
+
+def test_tmux_session_names_become_words(monkeypatch):
+    """Session names are the terminal's tabs: their slug parts are terms."""
+    from voiceio import context_terms as c
+    run, calls = _fake_tmux({"list-sessions": "s claude-swarmmemo-live\ns claude-wordle-native\nc %1\nc %2\n"})
+    monkeypatch.setattr(c, "_tmux", run)
+    monkeypatch.setattr(c.shutil, "which", lambda name: "/usr/bin/tmux")
+    text = c._read_tmux(0.2)
+    assert "swarmmemo" in text.split() and "claude-swarmmemo-live" not in text
+    # Two clients: tmux can't say which one has focus, so no pane is read.
+    assert not any(a[0] == "capture-pane" for a in calls)
+    assert "swarmmemo" in c.extract_terms([text])
+
+
+def test_tmux_pane_read_only_with_a_single_client(monkeypatch):
+    from voiceio import context_terms as c
+    run, calls = _fake_tmux({"list-sessions": "s work\nc %3\n", "capture-pane": "run xdotool now\n"})
+    monkeypatch.setattr(c, "_tmux", run)
+    monkeypatch.setattr(c.shutil, "which", lambda name: "/usr/bin/tmux")
+    text = c._read_tmux(0.2)
+    assert ["capture-pane", "-p", "-J", "-t", "%3"] in calls
+    assert "xdotool" in text
+
+
+def test_no_tmux_no_terminal_text(monkeypatch):
+    from voiceio import context_terms as c
+    monkeypatch.setattr(c.shutil, "which", lambda name: None)
+    assert c._read_tmux(0.2) == ""

{python_voiceio-1.9.0 → python_voiceio-1.9.2}/tests/test_streaming.py

@@ -693,6 +693,67 @@ class TestSegmentFreeze:
         # Display untouched: interim text already covers this audio
         s._display.typer.type_text.assert_not_called()
 
+    def test_pause_freezes_tail_up_to_the_reported_pause(self):
+        from voiceio.streaming import _PAUSE_CUT_BACKOFF_SECS
+        s, tr, rec = self._make_session(freeze_secs=8.0)
+        audio = np.concatenate([_loud(4.5), _silent(0.7)])
+        rec.get_audio_so_far.return_value = audio
+        s._on_vad_pause()           # the recorder's VAD heard a pause here
+        rec.get_audio_so_far.return_value = np.concatenate([audio, _loud(0.5)])
+        tr.transcribe.return_value = "hello there friend"
+        s._transcribe_and_apply()
+        # Frozen long before freeze_secs, cut inside the pause
+        assert s._frozen_samples == len(audio) - int(_PAUSE_CUT_BACKOFF_SECS * SR)
+        assert s._frozen_raw == "hello there friend"
+        assert tr.transcribe.call_args.kwargs["final"] is True
+        assert len(tr.transcribe.call_args.args[0]) == s._frozen_samples
+        assert s.trace[-1]["cut"] == "pause"
+        s._display.typer.type_text.assert_not_called()
+
+    def test_pause_freeze_ignores_backpressure(self):
+        s, tr, rec = self._make_session(freeze_secs=8.0)
+        audio = np.concatenate([_loud(4.5), _silent(0.7)])
+        rec.get_audio_so_far.return_value = audio
+        s._last_decode_end = len(audio)   # an interim just covered all of it
+        s._last_decode_secs = 5.0
+        s._on_vad_pause()
+        tr.transcribe.return_value = "hello there friend"
+        s._transcribe_and_apply()
+        assert s._frozen_raw == "hello there friend"
+
+    def test_pause_after_too_little_speech_is_not_frozen(self):
+        from voiceio.streaming import _PAUSE_FREEZE_MIN_SECS
+        s, tr, rec = self._make_session(freeze_secs=8.0)
+        rec.get_audio_so_far.return_value = np.concatenate(
+            [_loud(_PAUSE_FREEZE_MIN_SECS - 1), _silent(0.7)])
+        s._on_vad_pause()
+        tr.transcribe.return_value = "hello"
+        s._transcribe_and_apply()
+        assert s._frozen_samples == 0
+        assert tr.transcribe.call_args.kwargs["final"] is False  # an interim
+        assert s._pause_at is None   # consumed: a later pause is judged afresh
+
+    def test_no_pause_freeze_when_freezing_disabled(self):
+        s, tr, rec = self._make_session(freeze_secs=0)
+        rec.get_audio_so_far.return_value = np.concatenate([_loud(6), _silent(0.7)])
+        s._on_vad_pause()
+        tr.transcribe.return_value = "hello there friend"
+        s._transcribe_and_apply()
+        assert s._frozen_samples == 0
+
+    def test_stop_after_pause_freeze_decodes_only_the_rest(self):
+        s, tr, rec = self._make_session(freeze_secs=8.0)
+        audio = np.concatenate([_loud(4.5), _silent(0.7)])
+        rec.get_audio_so_far.return_value = audio
+        s._on_vad_pause()
+        tr.transcribe.return_value = "hello there friend"
+        s._transcribe_and_apply()
+        final_audio = np.concatenate([audio, _loud(1.0)])
+        tr.transcribe.return_value = "bye"
+        s.stop(final_audio)
+        assert len(tr.transcribe.call_args.args[0]) == len(final_audio) - s._frozen_samples
+        assert s.raw_final_text == "hello there friend bye"
+
     def test_no_freeze_when_tail_is_speech(self):
         s, tr, rec = self._make_session(freeze_secs=2.0)
         rec.get_audio_so_far.return_value = _loud(3)
@@ -1073,3 +1134,4 @@ def test_stop_decodes_tail_in_parallel_with_inflight_freeze():
     release_freeze.set()
     stopper.join(5)
     assert ("result", "frozen part tail part") in calls
+

python_voiceio-1.9.2/voiceio/__init__.py

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

{python_voiceio-1.9.0 → python_voiceio-1.9.2}/voiceio/app.py

@@ -643,7 +643,7 @@ class VoiceIO:
         screen = context_terms.capture()
         if self.cfg.data.capture_context:
             self._context_title = screen.title or None
-        terms = self.engine.screen_terms([screen.title, screen.selection])
+        terms = self.engine.screen_terms(screen.texts())
         if not terms:
             return
         bias = self.engine.bias(screen_terms=terms)

{python_voiceio-1.9.0 → python_voiceio-1.9.2}/voiceio/config.py

@@ -144,12 +144,12 @@ class OutputConfig:
     # On by default: nobody wants "um" in their notes. Set false for verbatim.
     remove_disfluencies: bool = True
     voice_input_prefix: str = ""           # e.g. "[voice]" — empty disables
-    # Incremental finalization: once the un-finalized audio tail grows past
-    # this many seconds, it is cut at the nearest interior speech pause,
-    # beam-decoded and frozen during recording, so interim passes and the
-    # stop-time final decode only cover the short remaining tail. Smaller
-    # chunks decode faster (less worker blocking) at slightly more boundary
-    # risk. 0 disables (full re-decode at stop).
+    # Incremental finalization: during recording the audio is beam-decoded
+    # and frozen in chunks — at each speech pause the VAD reports, and,
+    # when no pause comes, once the un-finalized tail grows past this many
+    # seconds (cut at its quietest interior point) — so interim passes and
+    # the stop-time final decode only cover the short remaining tail.
+    # 0 disables both (full re-decode at stop).
     streaming_freeze_secs: float = 8.0
     # Mirror transcribed text to the system clipboard so it can be pasted:
     #   "off"   — never

{python_voiceio-1.9.0 → python_voiceio-1.9.2}/voiceio/context_terms.py

@@ -1,8 +1,10 @@
 """On-screen vocabulary: bias one dictation toward the names you can see.
 
 Most misrecognitions are proper nouns and jargon, and the word you are about
-to say is often already on screen: in the focused window's title or in the
-text you just selected. This reads those two sources when a recording starts,
+to say is often already on screen: in the focused window's title, in the
+text you just selected, or in the terminal you are working in (tmux: the
+visible pane and the session names, which are often the window's tabs). This
+reads those sources when a recording starts,
 picks out the terms Whisper is likely to miss (rare words, CamelCase,
 acronyms, multiword names) and hands them to `core.bias` for this one
 recording, inside a small share of the hotword budget.
@@ -30,9 +32,9 @@ from dataclasses import dataclass
 
 log = logging.getLogger(__name__)
 
-# Capture deadline. Long enough for two ~20 ms subprocess reads under load,
+# Capture deadline. Long enough for a few ~20 ms subprocess reads under load,
 # short enough that the terms are in place before the first interim pass.
-CAPTURE_TIMEOUT_SECS = 0.15
+CAPTURE_TIMEOUT_SECS = 0.25
 # Only the head of a large selection is scanned: extraction stays ~10 ms.
 MAX_SCAN_CHARS = 8000
 MAX_TERMS = 8
@@ -54,10 +56,16 @@ _MIXED = re.compile(r"[a-zà-ÿ][A-ZÀ-Þ]|[A-ZÀ-Þ]{2}[a-zà-ÿ]")
 class ScreenContext:
     title: str = ""
     selection: str = ""
+    terminal: str = ""
     secs: float = 0.0
 
+    def texts(self) -> list[str]:
+        """In priority order: what was selected on purpose first."""
+        return [self.selection, self.title, self.terminal]
+
     def sources(self) -> list[str]:
-        return [n for n, v in (("title", self.title), ("selection", self.selection)) if v]
+        return [n for n, v in (("title", self.title), ("selection", self.selection),
+                               ("terminal", self.terminal)) if v]
 
 
 def _kind(word: str, zipf: Callable[[str], float]) -> int:
@@ -205,6 +213,33 @@ def _read_primary(timeout: float) -> str:
     return out.stdout[:MAX_SCAN_CHARS * 4].decode("utf-8", "replace")
 
 
+def _tmux(args: list[str], timeout: float) -> str:
+    try:
+        out = subprocess.run(["tmux", *args], capture_output=True, timeout=timeout)
+    except (subprocess.TimeoutExpired, OSError):
+        return ""
+    return out.stdout.decode("utf-8", "replace") if out.returncode == 0 else ""
+
+
+def _read_tmux(timeout: float) -> str:
+    """tmux session names (often the terminal's tabs, so on screen) and, when
+    exactly one client is attached, its visible pane (the newest end). With
+    several clients tmux can't say which one has focus — activity times move
+    with output too — so their panes would be a guess."""
+    if not shutil.which("tmux"):
+        return ""
+    # One tmux call for both lists: each call is a process start (~20 ms).
+    out = _tmux(["list-sessions", "-F", "s #{session_name}", ";",
+                 "list-clients", "-F", "c #{pane_id}"], timeout).splitlines()
+    # "claude-wordle-native" → words; slugs are names joined for the shell.
+    sessions = "\n".join(re.sub(r"[-_.]+", " ", line[2:]) for line in out if line.startswith("s "))
+    panes = [line[2:] for line in out if line.startswith("c ")]
+    if len(panes) != 1:
+        return sessions
+    text = _tmux(["capture-pane", "-p", "-J", "-t", panes[0]], timeout).rstrip()
+    return sessions + "\n" + text[-MAX_SCAN_CHARS // 2:]
+
+
 def _read_title(_timeout: float) -> str:
     from voiceio import retention
     return retention.active_window_title() or ""
@@ -214,7 +249,8 @@ def capture(timeout: float = CAPTURE_TIMEOUT_SECS, *,
             readers: dict[str, Callable[[float], str]] | None = None) -> ScreenContext:
     """Read the window title and selection in parallel; whatever isn't back
     by `timeout` is dropped (its thread finishes on its own). Never raises."""
-    readers = readers or {"title": _read_title, "selection": _read_primary}
+    readers = readers or {"title": _read_title, "selection": _read_primary,
+                          "terminal": _read_tmux}
     t0 = time.monotonic()
     results: dict[str, str] = {}
 
@@ -233,7 +269,7 @@ def capture(timeout: float = CAPTURE_TIMEOUT_SECS, *,
         t.join(max(0.0, deadline - time.monotonic()))
     got = dict(results)   # snapshot: a late reader must not change it
     return ScreenContext(title=got.get("title", ""), selection=got.get("selection", ""),
-                         secs=time.monotonic() - t0)
+                         terminal=got.get("terminal", ""), secs=time.monotonic() - t0)
 
 
 def describe() -> str:
@@ -250,4 +286,6 @@ def describe() -> str:
         sources.append("window title")
     elif p.is_wayland and p.desktop in ("gnome", "kde"):
         sources.append("window title of X11 apps only")
+    if shutil.which("tmux"):
+        sources.append("tmux sessions")
     return ", ".join(sources) or "no source available"

{python_voiceio-1.9.0 → python_voiceio-1.9.2}/voiceio/streaming.py

@@ -46,6 +46,15 @@ _FREEZE_SILENCE_FLOOR = 1e-4  # digital silence is always quiet
 # spot beats re-decoding an ever-growing tail at stop (observed: 17 long
 # dictations never froze, one decoding 121s of audio after stop).
 _FREEZE_SEARCH_SECS = 8.0
+# Pause freezes: when the recorder reports a speech pause (its VAD heard
+# silence_duration of non-speech), the tail up to that pause is frozen as soon
+# as it holds this much audio, rather than waiting for freeze_secs. Stop then
+# decodes only the speech after the last pause instead of up to
+# freeze_secs + search span of it.
+_PAUSE_FREEZE_MIN_SECS = 4.0
+# The pause is reported once the silence has lasted a while: cut this far
+# before that point so the cut sits inside the silence, not at its edge.
+_PAUSE_CUT_BACKOFF_SECS = 0.3
 # Whisper conditions on ~224 prompt tokens; more frozen context is wasted.
 _FREEZE_CONTEXT_CHARS = 400
 
@@ -197,6 +206,8 @@ class StreamingSession:
         # been beam-decoded into _frozen_raw and is never decoded again.
         # Interim and final passes only decode the tail after this offset.
         self._freeze_secs = freeze_secs
+        # Sample offset of the latest speech pause the recorder reported.
+        self._pause_at: int | None = None
         self._frozen_samples = 0
         self._frozen_raw = ""
         self._frozen_segments: list[dict] = []
@@ -318,7 +329,12 @@ class StreamingSession:
             return None
 
     def _on_vad_pause(self) -> None:
-        """Called from audio thread on speech pause. Signals worker."""
+        """Called from audio thread on speech pause. Signals worker, and
+        remembers where the pause is: a clean place to freeze."""
+        recorder = self._recorder
+        audio = recorder.get_audio_so_far() if recorder is not None else None
+        if audio is not None:
+            self._pause_at = len(audio)
         self._pending.set()
 
     def _worker_loop(self) -> None:
@@ -353,7 +369,28 @@ class StreamingSession:
         context = self._frozen_raw[-_FREEZE_CONTEXT_CHARS:] if self._frozen_raw else None
         return self._bias.with_context(context)
 
-    def _freeze_chunk(self, audio: np.ndarray, chunk: np.ndarray) -> None:
+    def _pause_cut(self, tail_len: int) -> int | None:
+        """Tail offset to freeze at: the latest reported speech pause, once
+        the speech before it is long enough to decode on its own."""
+        pause, self._pause_at = self._pause_at, None
+        if self._freeze_secs <= 0 or pause is None:
+            return None
+        # Cut inside the pause, not at its end: speech may resume right there.
+        cut = pause - self._frozen_samples - int(_PAUSE_CUT_BACKOFF_SECS * self._sample_rate)
+        if cut < _PAUSE_FREEZE_MIN_SECS * self._sample_rate or cut > tail_len:
+            return None
+        return cut
+
+    def _long_tail_cut(self, tail: np.ndarray) -> int | None:
+        """Tail offset to freeze at once the tail outgrows freeze_secs: its
+        quietest interior window (see _find_freeze_cut)."""
+        if self._freeze_secs <= 0 or len(tail) < self._freeze_secs * self._sample_rate:
+            return None
+        # Past the whole search span with no pause found: force a cut.
+        force = len(tail) >= (self._freeze_secs + _FREEZE_SEARCH_SECS) * self._sample_rate
+        return _find_freeze_cut(tail, self._sample_rate, self._freeze_secs, force=force)
+
+    def _freeze_chunk(self, audio: np.ndarray, chunk: np.ndarray, cut: str = "long") -> None:
         """Beam-decode `chunk` (the tail up to a pause cut) and freeze it.
 
         On decode failure the boundary is left untouched — the audio will be
@@ -375,6 +412,7 @@ class StreamingSession:
         self.trace.append({
             "t": round(time.monotonic() - self._t0, 2),
             "kind": "freeze",
+            "cut": cut,
             "frozen_secs": round(self._frozen_samples / self._sample_rate, 2),
             "tail_secs": round(len(chunk) / self._sample_rate, 2),
             "secs": round(t_decode, 3),
@@ -411,30 +449,31 @@ class StreamingSession:
         tail = audio[self._frozen_samples:]
         if not final and len(tail) < self._sample_rate * min_seconds:
             return  # not enough new audio since the last freeze
-        grown_secs = (len(audio) - self._last_decode_end) / self._sample_rate
-        if not final and grown_secs < max(min_seconds, self._last_decode_secs):
-            return  # backpressure: don't decode faster than we can keep up
-
-        # Freeze: once the tail is long enough, cut it at an interior speech
-        # pause and beam-decode ONLY that chunk (its text is never decoded
-        # again). The freeze pass does not touch the display — the interim
-        # text already covers this audio; the next interim refreshes it.
-        if (not final and self._freeze_secs > 0
-                and len(tail) >= self._freeze_secs * self._sample_rate):
-            # Past the whole search span with no pause found: force a cut.
-            force = len(tail) >= (self._freeze_secs + _FREEZE_SEARCH_SECS) * self._sample_rate
-            cut = _find_freeze_cut(tail, self._sample_rate, self._freeze_secs, force=force)
-            if cut is not None:
-                with self._freeze_lock:
-                    # Stop may have won the race for the lock and already
-                    # finalized from the current boundary.
-                    if not self._stop_event.is_set():
-                        self._freeze_pending_end = self._frozen_samples + cut
-                        try:
-                            self._freeze_chunk(audio, tail[:cut])
-                        finally:
-                            self._freeze_pending_end = None
-                return
+
+        # Freeze: cut the tail at a speech pause and beam-decode ONLY that
+        # chunk (its text is never decoded again). The freeze pass does not
+        # touch the display — the interim text already covers this audio;
+        # the next interim refreshes it.
+        # A pause the recorder reported is frozen even under backpressure:
+        # it shrinks every later decode, the stop-time one included.
+        cut = None if final else self._pause_cut(len(tail))
+        reason = "pause"
+        if cut is None and not final:
+            grown_secs = (len(audio) - self._last_decode_end) / self._sample_rate
+            if grown_secs < max(min_seconds, self._last_decode_secs):
+                return  # backpressure: don't decode faster than we can keep up
+            cut, reason = self._long_tail_cut(tail), "long"
+        if cut is not None:
+            with self._freeze_lock:
+                # Stop may have won the race for the lock and already
+                # finalized from the current boundary.
+                if not self._stop_event.is_set():
+                    self._freeze_pending_end = self._frozen_samples + cut
+                    try:
+                        self._freeze_chunk(audio, tail[:cut], reason)
+                    finally:
+                        self._freeze_pending_end = None
+            return
 
         tail_text = ""
         tail_segments: list[dict] = []

python_voiceio-1.9.0/voiceio/__init__.py

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