python-voiceio 0.7.1__tar.gz → 0.8.0__tar.gz

{python_voiceio-0.7.1/python_voiceio.egg-info → python_voiceio-0.8.0}/PKG-INFO

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

{python_voiceio-0.7.1 → python_voiceio-0.8.0}/pyproject.toml

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

{python_voiceio-0.7.1 → python_voiceio-0.8.0/python_voiceio.egg-info}/PKG-INFO

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

{python_voiceio-0.7.1 → python_voiceio-0.8.0}/tests/test_streaming.py

@@ -678,15 +678,21 @@ class TestSegmentFreeze:
         )
         return session, transcriber, recorder
 
-    def test_freeze_triggers_on_long_silent_tail(self):
+    def test_freeze_cuts_at_interior_pause(self):
         s, tr, rec = self._make_session(freeze_secs=2.0)
-        rec.get_audio_so_far.return_value = _silent(3)
+        # 2.5s speech, 0.5s pause, 2s speech: cut must land in the pause
+        rec.get_audio_so_far.return_value = np.concatenate(
+            [_loud(2.5), _silent(0.5), _loud(2.0)])
         tr.transcribe.return_value = "hello there friend"
         s._transcribe_and_apply()
         assert s._frozen_raw == "hello there friend"
-        assert s._frozen_samples == SR * 3
-        # Freeze pass gets beam search (final=True)
+        # Boundary inside the pause (2.5s..3.0s), NOT at the end of audio
+        assert SR * 2.5 <= s._frozen_samples <= SR * 3.0
+        # Freeze pass gets beam search and decodes ONLY the chunk
         assert tr.transcribe.call_args.kwargs["final"] is True
+        assert len(tr.transcribe.call_args.args[0]) == s._frozen_samples
+        # Display untouched: interim text already covers this audio
+        s._typer.type_text.assert_not_called()
 
     def test_no_freeze_when_tail_is_speech(self):
         s, tr, rec = self._make_session(freeze_secs=2.0)
@@ -785,16 +791,15 @@ class TestDecodeTrace:
             freeze_secs=2.0,
         )
         transcriber.transcribe.return_value = "hello there friend"
-        rec_audio = _silent(3)
-        recorder.get_audio_so_far.return_value = rec_audio
-        s._transcribe_and_apply()  # freeze pass
+        recorder.get_audio_so_far.return_value = _silent(3)
+        s._transcribe_and_apply()  # freeze pass (interior cut in silence)
         s._final_audio = np.concatenate([_silent(3), _loud(1)])
         transcriber.transcribe.return_value = "bye"
         s._transcribe_and_apply(min_seconds=0.5, final=True)
         kinds = [p["kind"] for p in s.trace]
         assert kinds == ["freeze", "final"]
         assert s.trace[0]["text"] == "hello there friend"
-        assert s.trace[1]["tail_secs"] == 1.0
+        assert s.trace[1]["tail_secs"] > 0
         assert all("secs" in p for p in s.trace)
 
 
@@ -856,31 +861,34 @@ class TestDecodeFailureSafety:
         s._typer.delete_chars.assert_not_called()
         assert s._typed_text == "hello there friend how are"
 
-    def test_quiet_mic_speech_is_not_silence(self):
-        from voiceio.streaming import _tail_ends_in_silence
+    def test_quiet_mic_speech_finds_no_cut(self):
+        from voiceio.streaming import _find_freeze_cut
         # Continuous speech on a low-gain mic: quiet in absolute terms but
-        # uniform — trailing window matches overall level, so NOT a pause.
+        # uniform — no window is quiet relative to the tail, so no cut.
         quiet_speech = np.full(SR * 3, 0.005, dtype=np.float32)
-        assert not _tail_ends_in_silence(quiet_speech, SR)
-        # Same quiet mic with a real trailing pause IS a pause.
+        assert _find_freeze_cut(quiet_speech, SR, 2.0) is None
+        # Same quiet mic with a real pause after the threshold IS cuttable.
         with_pause = np.concatenate([
-            np.full(int(SR * 2.5), 0.005, dtype=np.float32), _silent(0.5),
+            np.full(int(SR * 2.2), 0.005, dtype=np.float32), _silent(0.5),
+            np.full(int(SR * 0.3), 0.005, dtype=np.float32),
         ])
-        assert _tail_ends_in_silence(with_pause, SR)
+        cut = _find_freeze_cut(with_pause, SR, 2.0)
+        assert cut is not None and SR * 2.2 <= cut <= SR * 2.8
 
 
 class TestFreezeCalibration:
-    def test_hot_noise_floor_pause_is_silence(self):
+    def test_hot_noise_floor_pause_is_cuttable(self):
         """Real-mic calibration: noise floor ~0.3x of tail RMS IS a pause."""
-        from voiceio.streaming import _tail_ends_in_silence
+        from voiceio.streaming import _find_freeze_cut
         speech = np.full(int(SR * 2.5), 0.12, dtype=np.float32)
         pause = np.full(int(SR * 0.5), 0.03, dtype=np.float32)  # noise floor
-        assert _tail_ends_in_silence(np.concatenate([speech, pause]), SR)
+        cut = _find_freeze_cut(np.concatenate([speech, pause]), SR, 2.0)
+        assert cut is not None and cut >= SR * 2.3
 
-    def test_speech_level_window_is_not_silence(self):
-        from voiceio.streaming import _tail_ends_in_silence
+    def test_speech_level_tail_has_no_cut(self):
+        from voiceio.streaming import _find_freeze_cut
         tail = np.full(SR * 3, 0.12, dtype=np.float32)
-        assert not _tail_ends_in_silence(tail, SR)
+        assert _find_freeze_cut(tail, SR, 2.0) is None
 
 
 class TestDecodeBackpressure:

python_voiceio-0.8.0/voiceio/__init__.py

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

{python_voiceio-0.7.1 → python_voiceio-0.8.0}/voiceio/config.py

@@ -85,10 +85,12 @@ class OutputConfig:
     number_conversion: bool = True
     voice_input_prefix: str = ""           # e.g. "[voice]" — empty disables
     # Incremental finalization: once the un-finalized audio tail grows past
-    # this many seconds AND ends in silence, beam-decode and freeze it during
-    # recording, so interim passes and the stop-time final decode only cover
-    # the short remaining tail. 0 disables (full re-decode at stop).
-    streaming_freeze_secs: float = 25.0
+    # 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).
+    streaming_freeze_secs: float = 15.0
     # Mirror transcribed text to the system clipboard so it can be pasted:
     #   "off"   — never
     #   "final" — the corrected final text, once ready

{python_voiceio-0.7.1 → python_voiceio-0.8.0}/voiceio/streaming.py

@@ -25,8 +25,7 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 DELETE_SETTLE_SECS = 0.05  # delay between delete and type for ydotool reliability
 
-# Incremental finalization: a freeze cut is only safe at a speech pause, so
-# require the tail's trailing window to be quiet before cutting there.
+# Incremental finalization: a freeze cut is only safe at a speech pause.
 _FREEZE_SILENCE_WINDOW_SECS = 0.3
 # Quiet is judged RELATIVE to the tail's own level: mic gains vary wildly
 # and the decode path normalizes audio anyway, so an absolute threshold
@@ -37,6 +36,10 @@ _FREEZE_SILENCE_WINDOW_SECS = 0.3
 # both with margin; 0.15 never fired on a mic with a normal noise floor.
 _FREEZE_SILENCE_RATIO = 0.6
 _FREEZE_SILENCE_FLOOR = 1e-4  # digital silence is always quiet
+# How far past freeze_secs to look for a pause. Real speech has a usable
+# pause every ~5s (measured: longest pause-free stretch 5.6s in a 3min
+# "continuous" note), so 20s of search span practically always finds one.
+_FREEZE_SEARCH_SECS = 20.0
 # Whisper conditions on ~224 prompt tokens; more frozen context is wasted.
 _FREEZE_CONTEXT_CHARS = 400
 
@@ -45,14 +48,31 @@ def _rms(samples: np.ndarray) -> float:
     return float(np.sqrt(np.mean(np.square(samples, dtype=np.float64))))
 
 
-def _tail_ends_in_silence(tail: np.ndarray, sample_rate: int) -> bool:
-    """True when the last _FREEZE_SILENCE_WINDOW_SECS of audio are quiet
-    relative to the tail's overall level."""
-    window = tail[-int(_FREEZE_SILENCE_WINDOW_SECS * sample_rate):]
-    if len(window) == 0:
-        return False
-    threshold = max(_FREEZE_SILENCE_RATIO * _rms(tail), _FREEZE_SILENCE_FLOOR)
-    return _rms(window) < threshold
+def _find_freeze_cut(
+    tail: np.ndarray, sample_rate: int, min_secs: float,
+) -> int | None:
+    """Sample index of the best freeze cut in `tail`, or None.
+
+    Searches tail[min_secs : min_secs+_FREEZE_SEARCH_SECS] for the quietest
+    300ms window below the relative silence threshold and cuts at that
+    window's end. Searching the interior (rather than requiring the pass to
+    land on a trailing pause) is what makes freezing actually fire on real
+    speech: a pass's trailing 300ms is almost never a pause, but the
+    interior of a 15-35s span almost always contains one.
+    """
+    win = int(_FREEZE_SILENCE_WINDOW_SECS * sample_rate)
+    start = int(min_secs * sample_rate)
+    end = min(len(tail), int((min_secs + _FREEZE_SEARCH_SECS) * sample_rate))
+    if end - start < win:
+        return None
+    threshold = max(_FREEZE_SILENCE_RATIO * _rms(tail[:end]), _FREEZE_SILENCE_FLOOR)
+    best_cut, best_rms = None, threshold
+    for i in range(start, end - win + 1, win // 2):
+        window_rms = _rms(tail[i:i + win])
+        if window_rms < best_rms:
+            best_rms = window_rms
+            best_cut = i + win
+    return best_cut
 
 
 def _common_prefix_len(a: str, b: str) -> int:
@@ -277,6 +297,40 @@ class StreamingSession:
             return None
         return self._frozen_raw[-_FREEZE_CONTEXT_CHARS:]
 
+    def _freeze_chunk(self, audio: np.ndarray, chunk: np.ndarray) -> 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
+        decoded again by a later pass (never treat lost audio as silence).
+        """
+        t0 = time.monotonic()
+        try:
+            chunk_text = self._transcriber.transcribe(
+                chunk, final=True, context=self._frozen_context(),
+            )
+        except Exception:
+            log.exception("Freeze decode failed (boundary unchanged)")
+            return
+        t_decode = time.monotonic() - t0
+        self._frozen_raw = _join_text(self._frozen_raw, chunk_text)
+        self._frozen_samples += len(chunk)
+        self._frozen_segments.extend(
+            list(getattr(self._transcriber, "last_segments", [])))
+        self._last_decode_end = len(audio)
+        self._last_decode_secs = t_decode
+        self.trace.append({
+            "t": round(time.monotonic() - self._t0, 2),
+            "kind": "freeze",
+            "frozen_secs": round(self._frozen_samples / self._sample_rate, 2),
+            "tail_secs": round(len(chunk) / self._sample_rate, 2),
+            "secs": round(t_decode, 3),
+            "text": chunk_text,
+        })
+        log.debug(
+            "Froze %.1fs of audio in %.1fs (frozen text now %d chars)",
+            len(chunk) / self._sample_rate, t_decode, len(self._frozen_raw),
+        )
+
     def _transcribe_and_apply(
         self, min_seconds: float = 1.0, final: bool = False,
     ) -> None:
@@ -307,25 +361,26 @@ class StreamingSession:
         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 when the tail has grown long AND ends at a speech pause
-        # (never cut mid-word). The freeze pass gets beam search because its
-        # text is never decoded again.
-        freeze = (
-            not final
-            and self._freeze_secs > 0
-            and len(tail) >= self._freeze_secs * self._sample_rate
-            and _tail_ends_in_silence(tail, self._sample_rate)
-        )
+        # 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):
+            cut = _find_freeze_cut(tail, self._sample_rate, self._freeze_secs)
+            if cut is not None:
+                self._freeze_chunk(audio, tail[:cut])
+                return
 
         tail_text = ""
         tail_segments: list[dict] = []
         t0 = time.monotonic()
         # The final pass decodes ANY remaining audio (a clipped last word
-        # must not be dropped); interim/freeze passes skip sub-0.3s tails.
+        # must not be dropped); interim passes skip sub-0.3s tails.
         if len(tail) > (0 if final else self._sample_rate * 0.3):
             try:
                 tail_text = self._transcriber.transcribe(
-                    tail, final=final or freeze, context=self._frozen_context(),
+                    tail, final=final, context=self._frozen_context(),
                 )
             except Exception:
                 # Decode FAILED (timeout/crash) — this is not silence. Never
@@ -350,22 +405,14 @@ class StreamingSession:
 
         self.trace.append({
             "t": round(time.monotonic() - self._t0, 2),
-            "kind": "final" if final else ("freeze" if freeze else "interim"),
+            "kind": "final" if final else "interim",
             "frozen_secs": round(self._frozen_samples / self._sample_rate, 2),
             "tail_secs": round(len(tail) / self._sample_rate, 2),
             "secs": round(t_transcribe, 3),
             "text": tail_text,
         })
 
-        if freeze:
-            self._frozen_raw = _join_text(self._frozen_raw, tail_text)
-            self._frozen_samples = len(audio)
-            self._frozen_segments.extend(tail_segments)
-            log.debug(
-                "Froze %.1fs of audio (frozen text now %d chars)",
-                len(tail) / self._sample_rate, len(self._frozen_raw),
-            )
-        raw = self._frozen_raw if freeze else _join_text(self._frozen_raw, tail_text)
+        raw = _join_text(self._frozen_raw, tail_text)
 
         # A slow interim decode can complete AFTER the user pressed stop
         # (observed: 29s under CPU contention). Applying it would overwrite

python_voiceio-0.7.1/voiceio/__init__.py

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