python-voiceio 1.14.0__tar.gz → 1.15.0__tar.gz

{python_voiceio-1.14.0/python_voiceio.egg-info → python_voiceio-1.15.0}/PKG-INFO

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

{python_voiceio-1.14.0 → python_voiceio-1.15.0}/pyproject.toml

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

{python_voiceio-1.14.0 → python_voiceio-1.15.0/python_voiceio.egg-info}/PKG-INFO

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

{python_voiceio-1.14.0 → python_voiceio-1.15.0}/tests/test_learn_pipeline.py

@@ -307,6 +307,32 @@ def test_status_shows_scores_and_suggests_a_winning_run(capsys):
     assert "next: voiceio learn promote v0001-small-x" in out
 
 
+def test_status_never_suggests_whisper_over_another_decoder(capsys):
+    import argparse
+
+    from voiceio import config
+    from voiceio.cli import learn as cli
+    config.CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    config.CONFIG_PATH.write_text('[model]\nname = "parakeet-tdt-0.6b-v2"\n')
+    _clip("s.wav", 3, "x")
+    store.add_label("s.wav", [Segment(0, 3, "hi")], "teacher:fake")
+    ds = store.build_dataset()
+    run = store.learn_dir() / "models" / "v0001-small-x"
+    (run / "ct2").mkdir(parents=True)
+    runs = store.learn_dir() / "runs"
+    runs.mkdir()
+    for i, (dec, wer, rec) in enumerate([("sherpa:parakeet-tdt-0.6b-v2", 0.10, 0.5),
+                                         (f"faster-whisper:{run / 'ct2'}", 0.08, 0.8)]):
+        (runs / f"eval-2026010{i}.json").write_text(json.dumps({
+            "decoder": dec, "dataset": ds.name, "mode": "offline", "wer": wer,
+            "term_recall": rec, "repetitions": 0, "clips": 5, "gold": 0,
+            "metrics": metrics.METRICS_VERSION}))
+    cli.cmd_status(argparse.Namespace())
+    out = capsys.readouterr().out
+    assert "parakeet-tdt-0.6b-v2 (active)" in out and "WER 10.0%" in out
+    assert "next: voiceio learn promote" not in out
+
+
 def test_paired_comparison_reports_direction_and_uncertainty():
     clips = [f"{i}.wav" for i in range(20)]
     cur = {"per_clip": [{"file": f, "wer": 0.10} for f in clips]}

{python_voiceio-1.14.0 → python_voiceio-1.15.0}/tests/test_presence.py

@@ -38,6 +38,7 @@ AWAY = 600
     (Probe(idle=1800), False, "away 30 min"),
     (Probe(idle=1800, inhibited=True), True, "keeping the session awake"),   # a video
     (Probe(idle=1800, inhibited=True, locked=True), False, "away"),
+    (Probe(idle=3 * 3600, inhibited=True), False, "away 180 min"),   # an agent, not a viewer
     # No idle monitor: logind decides, and "can't tell" means in use.
     (Probe(), True, "can't tell"),
     (Probe(session=SeatSession(exists=False)), False, "nobody is logged in"),

{python_voiceio-1.14.0 → python_voiceio-1.15.0}/tests/test_server.py

@@ -310,6 +310,7 @@ def test_ws_ready_partial_final_sequence():
     assert final["text"] == "Hello world."
     assert final["raw"] == "hello world raw"
     assert isinstance(final["ms"], int)
+    assert final["cut_short"] is False and "why" not in final
     assert engine.committed == ["Hello world."]  # learned from; kept if opted in
 
 
@@ -348,8 +349,9 @@ def test_ws_client_disconnect_still_finalizes():
     assert engine.sessions[0].stopped_with is not None
 
 
-def test_ws_enforces_the_duration_cap():
+def test_ws_duration_cap_finalizes_what_fits_marked_cut_short():
     cfg = ServerConfig(max_audio_secs=0.05)  # 800 samples
+    engine = FakeEngine()
 
     async def go(client):
         ws = await client.ws_connect("/ws/transcribe")
@@ -361,11 +363,36 @@ def test_ws_enforces_the_duration_cap():
         await ws.close()
         return frames
 
-    frames = run_with_client(go, cfg=cfg)
-    kinds = [f["type"] for f in frames]
-    assert "error" in kinds
-    # An overrun must not also claim a usable final transcript.
-    assert "final" not in kinds
+    frames = run_with_client(go, cfg=cfg, engine=engine)
+    final = frames[-1]
+    assert final["type"] == "final" and final["text"] == "Hello world."
+    # The words are kept, and the client is told they are not the whole note.
+    assert final["cut_short"] is True and "limit" in final["why"]
+    assert len(engine.sessions[0].stopped_with) == 800   # only what fits is decoded
+
+
+def test_ws_stalled_stream_is_finalized_with_what_it_has():
+    """A client that goes quiet without a stop (a starved or frozen sender)
+    still gets a transcript of the audio it sent."""
+    cfg = ServerConfig(stall_secs=0.2)
+    engine = FakeEngine()
+
+    async def go(client):
+        ws = await client.ws_connect("/ws/transcribe")
+        await ws.receive_json()
+        await ws.send_bytes(_pcm(800))
+        frames = []
+        async for msg in ws:          # no stop: the server ends it
+            frames.append(json.loads(msg.data))
+        await ws.close()
+        return frames
+
+    frames = run_with_client(go, cfg=cfg, engine=engine)
+    final = frames[-1]
+    assert final["type"] == "final" and final["text"] == "Hello world."
+    assert final["cut_short"] is True and "no audio or stop" in final["why"]
+    assert len(engine.sessions[0].stopped_with) == 800
+    assert engine.committed == ["Hello world."]
 
 
 def test_ws_second_concurrent_session_is_refused():
@@ -439,11 +466,12 @@ def test_config_from_env(monkeypatch):
     monkeypatch.setenv("VOICE_MODEL", "base")
     monkeypatch.setenv("VOICE_THREADS", "2")
     monkeypatch.setenv("VOICE_MAX_SECS", "60")
+    monkeypatch.setenv("VOICE_STALL_SECS", "45")
     monkeypatch.setenv("VOICE_TTS_ALLOW_NETWORK", "1")
     cfg = ServerConfig.from_env()
     assert (cfg.host, cfg.port, cfg.model) == ("0.0.0.0", 8790, "base")
     assert cfg.threads == "2"
-    assert cfg.max_audio_secs == 60.0
+    assert (cfg.max_audio_secs, cfg.stall_secs) == (60.0, 45.0)
     assert cfg.tts_allow_network is True
 
 

{python_voiceio-1.14.0 → python_voiceio-1.15.0}/tests/test_sherpa.py

@@ -41,6 +41,10 @@ class FakeSherpa:
                 self.rec = {"hotwords": hotwords, "samples": 0}
                 fake.streams.append(self.rec)
 
+            def set_option(self, key, value):
+                assert isinstance(value, str)
+                self.rec[key] = value
+
             def accept_waveform(self, sr, a):
                 assert sr == 16000 and a.dtype == np.float32
                 self.rec["samples"] = len(a)
@@ -114,6 +118,7 @@ def test_one_recognizer_and_per_stream_pretokenized_proper_nouns(fake, tmp_path)
     assert out.text == "hello world"
     # Lowercase (mined jargon) and unusable terms never become hotwords.
     assert fake.streams[-1]["hotwords"] == "▁Kal shi/▁Hy per"
+    assert fake.streams[-1]["length_reward"] == "0.5"   # per stream, as upstream reads it
     dec.decode(_audio(2), bias=Bias(hotwords="Hyper"))
     dec.decode(_audio(2), bias=Bias())
     assert [s["hotwords"] for s in fake.streams[1:]] == ["▁Hy per", None]
@@ -135,7 +140,7 @@ def test_without_the_tdt_fix_decodes_greedy_and_unbiased(fake, monkeypatch, tmp_
     assert dec.decode(_audio(1), bias=Bias(hotwords="Kalshi")).text == "hello world"
     kw = fake.created[-1]
     assert kw["decoding_method"] == "greedy_search" and "length_reward" not in kw
-    assert fake.streams[-1]["hotwords"] is None
+    assert fake.streams[-1]["hotwords"] is None and "length_reward" not in fake.streams[-1]
 
 
 def test_long_audio_is_decoded_in_pieces_of_at_most_30s(fake, tmp_path):

python_voiceio-1.15.0/voiceio/__init__.py

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

{python_voiceio-1.14.0 → python_voiceio-1.15.0}/voiceio/cli/learn.py

@@ -211,6 +211,8 @@ def cmd_status(args: argparse.Namespace) -> None:
         print(f"note       {unused}")
     print(f"nightly    {_schedule_state()}")
     promotable = _print_scores(ds, active, runs) if ds else None
+    if unused:   # a Whisper fine-tune can't replace another decoder on WER alone
+        promotable = None
     if promotable:
         nxt = f"promote {promotable}"
     else:

{python_voiceio-1.14.0 → python_voiceio-1.15.0}/voiceio/core/decoders/sherpa.py

@@ -236,6 +236,9 @@ class SherpaTransducer:
                           bpe_vocab=_bpe_vocab_file(self._dir, self._tokenizer))
             if feats.length_reward:
                 kwargs.update(length_reward=length_reward)
+        # Upstream reads length_reward per stream (k2-fsa/sherpa-onnx#4084 after
+        # review); builds without that read ignore the option.
+        self._stream_reward = repr(float(length_reward)) if mbs and length_reward else ""
         t0 = time.monotonic()
         try:
             self._rec = sherpa_onnx.OfflineRecognizer.from_transducer(**kwargs)
@@ -276,6 +279,8 @@ class SherpaTransducer:
             for chunk in split_long(audio) if len(audio) else ():
                 stream = (self._rec.create_stream(hotwords) if hotwords
                           else self._rec.create_stream())
+                if self._stream_reward and hasattr(stream, "set_option"):
+                    stream.set_option("length_reward", self._stream_reward)
                 stream.accept_waveform(SAMPLE_RATE, chunk)
                 self._rec.decode_stream(stream)
                 if text := stream.result.text.strip():

{python_voiceio-1.14.0 → python_voiceio-1.15.0}/voiceio/presence.py

@@ -37,6 +37,9 @@ from dataclasses import dataclass
 log = logging.getLogger(__name__)
 
 _TIMEOUT = 3
+# No input for this long is away even when an app keeps the session awake:
+# past a film's length, the inhibitor is a long-running job, not a viewer.
+INHIBITED_MAX = 2 * 3600
 
 
 @dataclass(frozen=True)
@@ -144,7 +147,7 @@ def check(away_after: float, probe: SessionProbe | None = None) -> Presence:
             if probe.screen_locked():
                 return Presence(False, "screen locked")
             return Presence(True, f"in use (last input {_minutes(idle)} ago)")
-        if probe.idle_inhibited() and not probe.screen_locked():
+        if idle < INHIBITED_MAX and probe.idle_inhibited() and not probe.screen_locked():
             return Presence(True, "an app is keeping the session awake (a video or a call?)")
         return Presence(False, f"away {_minutes(idle)}")
     session = probe.seat_session()

{python_voiceio-1.14.0 → python_voiceio-1.15.0}/voiceio/server/__main__.py

@@ -21,6 +21,7 @@ def main(argv: list[str] | None = None) -> int:
             "  VOICE_COMPUTE, VOICE_DEVICE      compute type / device\n"
             "  VOICE_THREADS                    CPU threads (default 4, 0=all)\n"
             "  VOICE_MAX_BYTES, VOICE_MAX_SECS  request limits\n"
+            "  VOICE_STALL_SECS                 end a stream silent this long (30 s; 0 never)\n"
             "  VOICE_TTS_ENGINE, VOICE_TTS_VOICE, VOICE_TTS_SPEED\n"
             "  VOICE_TTS_ALLOW_NETWORK          1 to permit cloud TTS (off)\n"
             "  VOICE_LOG_LEVEL                  default INFO\n"

{python_voiceio-1.14.0 → python_voiceio-1.15.0}/voiceio/server/app.py

@@ -122,12 +122,15 @@ async def handle_ws_transcribe(request: web.Request) -> web.WebSocketResponse:
     Server → client (all JSON text frames):
         {"type":"ready","sample_rate":16000,"format":"pcm_s16le","channels":1}
         {"type":"partial","text":...,"audio_secs":...}
-        {"type":"final","text":...,"raw":...,"audio_secs":...,"ms":...}
+        {"type":"final","text":...,"raw":...,"audio_secs":...,"ms":...,
+         "cut_short":false}
         {"type":"error","error":...}
 
-    The final frame is sent before the socket closes. A client that simply
-    disconnects still gets its audio finalized server-side (for vocabulary
-    statistics), it just is not around to read the result.
+    The final frame is sent before the socket closes. A stream that sends
+    neither audio nor stop for `stall_secs`, or passes `max_audio_secs`, still
+    gets a final of the audio it sent, with "cut_short":true and a "why". A
+    client that simply disconnects still gets its audio finalized server-side
+    (for vocabulary statistics), it just is not around to read the result.
     """
     runtime: ServerRuntime = request.app[RUNTIME]
     cfg: ServerConfig = request.app[CONFIG]
@@ -190,17 +193,22 @@ async def _run_stream(ws, runtime: ServerRuntime, cfg: ServerConfig, app) -> Non
         "model": runtime.model_cfg.name,
     })
 
+    cut_short = ""   # why the stream ended without a stop, if it did
     overrun = False
     try:
-        async for msg in ws:
+        while True:
+            try:
+                msg = await ws.receive(timeout=cfg.stall_secs or None)
+            except TimeoutError:
+                cut_short = f"no audio or stop for {cfg.stall_secs:g} s"
+                break
+            if msg.type in (WSMsgType.CLOSE, WSMsgType.CLOSING, WSMsgType.CLOSED):
+                break
             if msg.type == WSMsgType.BINARY:
                 total = source.feed(msg.data)
                 if total / SAMPLE_RATE > cfg.max_audio_secs:
                     overrun = True
-                    await ws.send_json({
-                        "type": "error",
-                        "error": f"audio exceeded {cfg.max_audio_secs:.0f}s limit",
-                    })
+                    cut_short = f"audio passed the {cfg.max_audio_secs:g} s limit"
                     break
             elif msg.type == WSMsgType.TEXT:
                 try:
@@ -218,7 +226,9 @@ async def _run_stream(ws, runtime: ServerRuntime, cfg: ServerConfig, app) -> Non
     finally:
         source.close()
         audio = source.get_audio_so_far()
-        secs = source.duration_secs
+        if overrun and audio is not None:   # the last frame may run far past the limit
+            audio = audio[:int(cfg.max_audio_secs * SAMPLE_RATE)]
+        secs = len(audio) / SAMPLE_RATE if audio is not None else 0.0
 
         # stop() joins the worker thread through a final beam-search decode:
         # seconds of CPU, and it must not block the event loop.
@@ -238,18 +248,21 @@ async def _run_stream(ws, runtime: ServerRuntime, cfg: ServerConfig, app) -> Non
         outbox.put_nowait(None)
         await pump_task
 
-        if not ws.closed and not overrun:
+        if not ws.closed:
             await ws.send_json({
                 "type": "final",
                 "text": text,
                 "raw": session.raw_final_text or "",
                 "audio_secs": round(secs, 2),
                 "ms": round((time.monotonic() - t0) * 1000),
+                "cut_short": bool(cut_short),
+                **({"why": cut_short} if cut_short else {}),
             })
         if text:   # after the reply: retention must not add to the user's wait
             await loop.run_in_executor(app[EXECUTOR], runtime.commit, audio, text,
                                        session.raw_final_text or "")
-        log.info("streaming %.1fs audio → %s", secs, describe_transcript(text))
+        log.info("streaming %.1fs audio → %s%s", secs, describe_transcript(text),
+                 f" (cut short: {cut_short})" if cut_short else "")
         if not ws.closed:
             await ws.close()
 

{python_voiceio-1.14.0 → python_voiceio-1.15.0}/voiceio/server/config.py

@@ -59,6 +59,9 @@ class ServerConfig:
     # max_audio_secs; this exists so a bad client cannot stream us to death.
     max_bytes: int = 25 * 1024 * 1024
     max_audio_secs: float = 120.0
+    # A stream that sends neither audio nor stop for this long is finalized
+    # with what it has (marked cut_short). 0 waits forever.
+    stall_secs: float = 30.0
 
     # ── tts ──────────────────────────────────────────────────────────────
     tts_engine: str = "auto"
@@ -97,6 +100,7 @@ class ServerConfig:
             lanes=int(e(prefix, "LANES", "1")),
             max_bytes=int(e(prefix, "MAX_BYTES", str(25 * 1024 * 1024))),
             max_audio_secs=float(e(prefix, "MAX_SECS", "120")),
+            stall_secs=float(e(prefix, "STALL_SECS", "30")),
             tts_engine=e(prefix, "TTS_ENGINE", "auto"),
             tts_voice=e(prefix, "TTS_VOICE", ""),
             tts_speed=float(e(prefix, "TTS_SPEED", "1.0")),

python_voiceio-1.14.0/voiceio/__init__.py

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