python-voiceio 0.9.3__tar.gz → 0.9.5__tar.gz

{python_voiceio-0.9.3/python_voiceio.egg-info → python_voiceio-0.9.5}/PKG-INFO

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

{python_voiceio-0.9.3 → python_voiceio-0.9.5}/pyproject.toml

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

{python_voiceio-0.9.3 → python_voiceio-0.9.5/python_voiceio.egg-info}/PKG-INFO

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

{python_voiceio-0.9.3 → python_voiceio-0.9.5}/tests/test_robustness.py

@@ -76,27 +76,45 @@ def _make_recorder():
 class TestAutoStop:
     """Auto-stop distinguishes 'spoke then paused' from 'nothing ever heard'."""
 
-    def _feed(self, rec, secs, *, speech):
-        """Drive _callback with `secs` of audio; speech=False → silence."""
+    def _feed(self, rec, secs, *, speech, amplitude=0.0):
+        """Drive _callback with `secs` of audio.
+
+        speech       → what the (mocked) VAD reports (is_speech).
+        amplitude    → raw sample level; 0.0 = digital silence (muted mic),
+                       >1e-4 = a real audio signal reaching the mic.
+        """
         rec._vad.is_speech.return_value = speech
         frames = int(secs * rec.sample_rate)
-        rec._callback(np.zeros((frames, 1), dtype=np.float32), frames, None, None)
+        data = np.full((frames, 1), amplitude, dtype=np.float32)
+        rec._callback(data, frames, None, None)
 
-    def test_no_speech_fires_no_speech_reason(self):
+    def test_muted_mic_fires_no_speech_reason(self):
         rec = _make_recorder()
         rec._recording = True
         fired = []
         rec.set_on_auto_stop(lambda reason: fired.append(reason))
-        # 21s of pure silence, speech never heard.
-        self._feed(rec, 21, speech=False)
+        # 21s of digital zeros — a muted / dead mic.
+        self._feed(rec, 21, speech=False, amplitude=0.0)
         assert fired == ["no_speech"]
 
+    def test_real_audio_vad_misses_does_not_autostop(self):
+        """Regression: real audio the VAD fails to flag as speech must NOT be
+        cut off. This is the 0.9.3 bug — a 20s dictation the Silero VAD scored
+        as silence auto-stopped mid-sentence."""
+        rec = _make_recorder()
+        rec._recording = True
+        fired = []
+        rec.set_on_auto_stop(lambda reason: fired.append(reason))
+        # 25s of clearly-present audio, but the VAD never calls it speech.
+        self._feed(rec, 25, speech=False, amplitude=0.05)
+        assert fired == []  # signal is present → neither auto-stop fires
+
     def test_no_speech_does_not_fire_early(self):
         rec = _make_recorder()
         rec._recording = True
         fired = []
         rec.set_on_auto_stop(lambda reason: fired.append(reason))
-        self._feed(rec, 10, speech=False)  # below the 20s threshold
+        self._feed(rec, 10, speech=False, amplitude=0.0)  # below the 20s threshold
         assert fired == []
 
     def test_speech_then_silence_fires_silence_reason(self):

{python_voiceio-0.9.3 → python_voiceio-0.9.5}/tests/test_vad.py

@@ -51,16 +51,39 @@ class TestSileroVad:
         chunk = np.zeros(1024, dtype=np.float32)
         assert vad.is_speech(chunk) is False
 
-    def test_speech_detected(self, vad):
-        # Generate a sine wave at speech-like frequency
-        t = np.linspace(0, 0.1, 1600, dtype=np.float32)
-        chunk = 0.5 * np.sin(2 * np.pi * 300 * t)
-        # Run several chunks to build state
-        for _ in range(5):
-            result = vad.is_speech(chunk)
-        # At least one should detect speech (sine wave isn't silence)
-        # Note: Silero may not classify pure sine as speech, so we just test it runs
-        assert isinstance(result, bool)
+    def test_v5_feeds_context_window(self, vad):
+        """Regression: Silero v5 consumes 512+64=576 samples — the window plus
+        the previous window's 64-sample tail as context. Feeding a bare 512
+        (the pre-fix bug) makes the model score all real speech as silence
+        (measured: max prob 0.016 vs 1.0 with context)."""
+        if not vad._use_state:
+            pytest.skip("v4 model has no context requirement")
+        seen = []
+        real_run = vad._session.run
+
+        def spy(outs, inputs):
+            seen.append(inputs["input"])
+            return real_run(outs, inputs)
+
+        vad._session.run = spy
+        # Two distinct windows so we can check the context carries across.
+        w1 = np.arange(512, dtype=np.float32) / 512.0
+        w2 = np.arange(512, 1024, dtype=np.float32) / 512.0
+        vad.is_speech(w1)
+        vad.is_speech(w2)
+        assert seen[0].shape[-1] == 512 + 64        # 576, not a bare 512
+        # First call's context is zeros; second call's leading 64 samples must
+        # be the tail of the first window (state carried between steps).
+        assert np.allclose(seen[0][0, :64], 0.0)
+        assert np.allclose(seen[1][0, :64], w1[-64:])
+
+    def test_reset_clears_context(self, vad):
+        if not vad._use_state:
+            pytest.skip("v4 model has no context")
+        vad.is_speech(np.arange(512, dtype=np.float32) / 512.0)
+        assert not np.allclose(vad._context, 0.0)  # context now populated
+        vad.reset()
+        assert np.allclose(vad._context, 0.0)
 
     def test_reset_clears_state(self, vad):
         chunk = np.zeros(1024, dtype=np.float32)

python_voiceio-0.9.5/voiceio/__init__.py

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

{python_voiceio-0.9.3 → python_voiceio-0.9.5}/voiceio/recorder.py

@@ -15,6 +15,11 @@ if TYPE_CHECKING:
 
 log = logging.getLogger(__name__)
 
+# Peak amplitude below this is treated as no signal at all (a muted mic emits
+# exact zeros; a working mic's "silence" still noises above ~1e-4). Matches the
+# floor in has_signal(). Used only to detect a dead mic, never speech vs pause.
+_SIGNAL_FLOOR = 1e-4
+
 
 class RingBuffer:
     """Fixed-size ring buffer for float32 audio samples."""
@@ -111,6 +116,10 @@ class AudioRecorder:
         self._no_speech_secs = cfg.auto_stop_no_speech_secs
         self._sustained_silence = 0.0
         self._heard_speech = False
+        # Raw-signal (amplitude) tracking for the muted-mic auto-stop, kept
+        # separate from the VAD-based _heard_speech / _sustained_silence above.
+        self._heard_signal = False
+        self._silent_signal_secs = 0.0
         # Called with a reason: "silence" (spoke then paused) or "no_speech"
         # (nothing ever heard — a muted mic or a forgotten hotkey).
         self._on_auto_stop: Callable[[str], None] | None = None
@@ -221,6 +230,8 @@ class AudioRecorder:
             self._silent_chunks = 0.0
             self._sustained_silence = 0.0
             self._heard_speech = False
+            self._heard_signal = False
+            self._silent_signal_secs = 0.0
             self._pause_fired_at = 0
             self._meter_peak = 0.0
             self._meter_clipped = 0
@@ -301,8 +312,19 @@ class AudioRecorder:
 
         # Level metering
         abs_chunk = np.abs(chunk.ravel())
-        self._meter_peak = max(self._meter_peak, float(abs_chunk.max(initial=0.0)))
+        chunk_peak = float(abs_chunk.max(initial=0.0))
+        self._meter_peak = max(self._meter_peak, chunk_peak)
         self._meter_samples += len(abs_chunk)
+
+        # Raw-signal presence, independent of the VAD. A muted mic delivers
+        # digital zeros; real audio (even speech the VAD fails to classify)
+        # sits well above the floor. This — NOT the VAD — gates the muted-mic
+        # auto-stop, so a recording is never cut while real audio is coming in.
+        if chunk_peak > _SIGNAL_FLOOR:
+            self._heard_signal = True
+            self._silent_signal_secs = 0.0
+        else:
+            self._silent_signal_secs += frames / self.sample_rate
         pinned = abs_chunk >= 0.99
         if np.count_nonzero(pinned) >= 4:
             runs = np.convolve(pinned.astype(np.int8), np.ones(4, dtype=np.int8), "valid")
@@ -345,18 +367,18 @@ class AudioRecorder:
             log.info("Auto-stopping after %.0fs of silence", self._auto_stop_secs)
             cb("silence")
 
-        # Safety net: nothing heard at all for a long time. Because speech
-        # resets _sustained_silence AND is gated out by not-_heard_speech, this
-        # measures continuous silence from the very start of the recording — a
-        # muted mic (all zeros) or a hotkey pressed by accident. Distinct reason
-        # so the app can surface it instead of failing silently.
+        # Safety net for a dead mic: NO raw audio signal at all for a long
+        # time — the mic is muted / unplugged / delivering zeros, never merely
+        # that the VAD didn't flag speech (that would cut real dictation off
+        # mid-sentence). _heard_signal latches on the first non-zero chunk, so
+        # this only fires for a mic that was silent from the very start.
         elif (self._on_auto_stop is not None
                 and self._no_speech_secs > 0
-                and not self._heard_speech
-                and self._sustained_silence >= self._no_speech_secs):
+                and not self._heard_signal
+                and self._silent_signal_secs >= self._no_speech_secs):
             cb = self._on_auto_stop
             self._on_auto_stop = None
-            self._sustained_silence = 0.0
-            log.info("Auto-stopping: no speech heard in %.0fs (mic muted?)",
+            self._silent_signal_secs = 0.0
+            log.info("Auto-stopping: no mic signal in %.0fs (muted?)",
                      self._no_speech_secs)
             cb("no_speech")

{python_voiceio-0.9.3 → python_voiceio-0.9.5}/voiceio/vad.py

@@ -16,6 +16,11 @@ log = logging.getLogger(__name__)
 _MODEL_PATH = Path(__file__).parent / "models" / "silero_vad.onnx"
 _WINDOW_SIZE = 512  # Silero expects 512 samples at 16kHz (~32ms)
 _SAMPLE_RATE = 16000
+# Silero v5 consumes 576 samples per step: the 512-sample window PLUS the 64
+# trailing samples of the previous window as context. Feeding a bare 512 makes
+# the model score everything as non-speech (measured: max prob 0.016 vs 1.0
+# with context). The official ONNX wrapper prepends this outside the graph.
+_CONTEXT_SIZE = 64
 
 
 @runtime_checkable
@@ -46,6 +51,8 @@ class SileroVad:
             state_meta = [inp for inp in self._session.get_inputs() if inp.name == "state"][0]
             state_dim = state_meta.shape[2]  # 128 for v5
             self._state = np.zeros((2, 1, state_dim), dtype=np.float32)
+            # v5 context: the previous window's trailing 64 samples.
+            self._context = np.zeros(_CONTEXT_SIZE, dtype=np.float32)
         else:
             self._h = np.zeros((2, 1, 64), dtype=np.float32)
             self._c = np.zeros((2, 1, 64), dtype=np.float32)
@@ -56,6 +63,7 @@ class SileroVad:
     def reset(self) -> None:
         if self._use_state:
             self._state = np.zeros_like(self._state)
+            self._context = np.zeros(_CONTEXT_SIZE, dtype=np.float32)
         else:
             self._h = np.zeros_like(self._h)
             self._c = np.zeros_like(self._c)
@@ -76,13 +84,15 @@ class SileroVad:
         return speech
 
     def _infer(self, window: np.ndarray) -> float:
-        input_data = window.reshape(1, -1)
         sr = np.array(_SAMPLE_RATE, dtype=np.int64)
         if self._use_state:
-            ort_inputs = {"input": input_data, "state": self._state, "sr": sr}
+            # Prepend the previous window's tail; the model needs 512+64=576.
+            x = np.concatenate([self._context, window])
+            self._context = window[-_CONTEXT_SIZE:].copy()
+            ort_inputs = {"input": x.reshape(1, -1), "state": self._state, "sr": sr}
             out, self._state = self._session.run(None, ort_inputs)
         else:
-            ort_inputs = {"input": input_data, "h": self._h, "c": self._c, "sr": sr}
+            ort_inputs = {"input": window.reshape(1, -1), "h": self._h, "c": self._c, "sr": sr}
             out, self._h, self._c = self._session.run(None, ort_inputs)
         return float(out.squeeze())
 

python_voiceio-0.9.3/voiceio/__init__.py

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