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

{python_voiceio-1.9.1/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.1
+Version: 1.9.2
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

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

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

{python_voiceio-1.9.1 → 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.1
+Version: 1.9.2
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-1.9.1 → 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.1 → 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.1 → 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.1/voiceio/__init__.py

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