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

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

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

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

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

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

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

{python_voiceio-1.14.0 → python_voiceio-1.15.1}/python_voiceio.egg-info/SOURCES.txt

@@ -79,6 +79,7 @@ tests/test_streaming.py
 tests/test_suggest.py
 tests/test_tokens.py
 tests/test_transcriber.py
+tests/test_tray.py
 tests/test_tts.py
 tests/test_typer_manager.py
 tests/test_vad.py

{python_voiceio-1.14.0 → python_voiceio-1.15.1}/tests/test_health.py

@@ -123,3 +123,29 @@ def test_learning_status_and_tips(monkeypatch):
     assert st["Voice model"] == "fine-tuned on you (v0001-small-x)"
     assert st["Recordings"].startswith("on (") and st["Scheduled learning"] == "off"
     assert any("learn schedule on" in t for t in _accuracy_tips(st))
+
+
+def test_silent_ibus_engine_is_not_a_warning_while_voiceio_is_stopped():
+    from voiceio.health import HealthReport, IBusStatus
+    p = Platform(os="linux", display_server="wayland", desktop="kde")
+    ib = IBusStatus(component_installed=True, daemon_running=True, voiceio_running=False)
+    text = format_report(HealthReport(platform=p, ibus_checks=ib))
+    line = next(ln for ln in text.splitlines() if "Engine answers" in ln)
+    assert "⚠" not in line and "isn't running" in line
+    ib.voiceio_running = True
+    line = next(ln for ln in format_report(HealthReport(platform=p, ibus_checks=ib)).splitlines()
+                if "Engine answers" in ln)
+    assert "⚠" in line and "service restart" in line
+
+
+def test_check_ibus_asks_about_voiceio_only_when_the_engine_is_silent():
+    from voiceio import health
+    with patch("voiceio.ibus.install.component_installed", return_value=True), \
+         patch("voiceio.ibus.install.daemon_running", return_value=True), \
+         patch("voiceio.ibus.ping_engine", return_value=False), \
+         patch("voiceio.pidlock.daemon_alive", return_value=False) as alive:
+        assert health._check_ibus().voiceio_running is False
+        with patch("voiceio.ibus.ping_engine", return_value=True):
+            alive.reset_mock()
+            assert health._check_ibus().voiceio_running is True
+            alive.assert_not_called()

{python_voiceio-1.14.0 → python_voiceio-1.15.1}/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.1}/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.1}/tests/test_report.py

@@ -9,7 +9,7 @@ import pytest
 
 from voiceio import report
 from voiceio.config import Config
-from voiceio.health import BackendStatus, HealthReport
+from voiceio.health import BackendStatus, HealthReport, IBusStatus
 from voiceio.platform import Platform
 
 FAKE_HOME = "/home/zelda-tester"
@@ -104,6 +104,16 @@ def test_report_lists_failures_and_warnings():
     assert "insecure permissions on 2 file(s)" in text
 
 
+def test_silent_ibus_engine_is_expected_while_voiceio_is_stopped():
+    # Two 1.15.0 reports warned "ibus engine ping" only because voiceio wasn't running.
+    ib = IBusStatus(component_installed=True, daemon_running=True, env_persisted=True)
+    stopped = report.build_report(_health(ibus_checks=IBusStatus(**{**vars(ib), "voiceio_running": False})),
+                                  cfg=Config())
+    assert "engine ping" not in stopped and "voiceio not running" in stopped
+    running = report.build_report(_health(ibus_checks=ib), cfg=Config())
+    assert "ibus engine ping" in running and "voiceio not running" not in running
+
+
 def test_comment_is_one_bounded_line():
     text = report.build_report(_health(), comment="a\nb\tc " + "x" * 1000, cfg=Config())
     line = next(ln for ln in text.splitlines() if ln.startswith("comment:"))
@@ -111,6 +121,14 @@ def test_comment_is_one_bounded_line():
     assert len(line) <= len("comment: ") + report.MAX_COMMENT
 
 
+def test_comment_drops_terminal_escapes():
+    # A real 1.15.0 report arrived with "comment: \x1bv" (Alt+V at the prompt).
+    text = report.build_report(_health(), comment="\x1bv", cfg=Config())
+    assert "comment:" not in text and "\x1b" not in text
+    text = report.build_report(_health(), comment="works\x1b[D\x1b[C great\x07", cfg=Config())
+    assert "comment: works great" in text.splitlines()
+
+
 # ── posting ──
 
 class _Resp(io.BytesIO):

{python_voiceio-1.14.0 → python_voiceio-1.15.1}/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.1}/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.1/tests/test_tray.py

@@ -0,0 +1,58 @@
+"""Tray backend probing: what doctor/setup promise must match what start() does."""
+from __future__ import annotations
+
+import builtins
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from voiceio import tray
+from voiceio.tray import _pystray
+
+linux = pytest.mark.skipif(not sys.platform.startswith("linux"), reason="linux probe")
+
+
+@linux
+def test_appindicator_wins():
+    with patch.object(tray, "_find_system_python", return_value="/usr/bin/python3"):
+        assert tray.probe_availability() == (True, "AppIndicator3 available", "")
+
+
+@linux
+def test_pystray_xembed_fallback_counts_as_a_tray():
+    # KDE/LXQt users without python3-gi got "no tray" though start() falls back to pystray.
+    with patch.object(tray, "_find_system_python", return_value=None), \
+         patch.object(tray, "_pystray_backend", return_value="xorg"):
+        ok, reason, hint = tray.probe_availability()
+    assert ok and "no menu" in reason and "for the full menu" in hint
+
+
+@linux
+def test_no_backend_at_all():
+    with patch.object(tray, "_find_system_python", return_value=None), \
+         patch.object(tray, "_pystray_backend", return_value=None):
+        ok, reason, hint = tray.probe_availability()
+    assert not ok and "AppIndicator3" in reason and hint.startswith("install:")
+
+
+def _import_raising(exc):
+    real = builtins.__import__
+
+    def fake(name, *a, **kw):
+        if name == "pystray":
+            raise exc
+        return real(name, *a, **kw)
+    return fake
+
+
+class _DisplayNameError(Exception):
+    """Stands in for Xlib.error.DisplayNameError (no DISPLAY): not an ImportError."""
+
+
+def test_pystray_without_x_display_does_not_raise(monkeypatch):
+    monkeypatch.delitem(sys.modules, "pystray", raising=False)
+    with patch("builtins.__import__", _import_raising(_DisplayNameError(":0"))):
+        assert tray._pystray_backend() is None
+        assert _pystray.start(lambda: None, Path("idle.png"), []) is False

python_voiceio-1.15.1/voiceio/__init__.py

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

{python_voiceio-1.14.0 → python_voiceio-1.15.1}/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.1}/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.1}/voiceio/health.py

@@ -25,6 +25,8 @@ class IBusStatus:
     component_installed: bool = False
     daemon_running: bool = False
     socket_reachable: bool = False
+    # The engine runs while voiceio does, so a silent one only matters then.
+    voiceio_running: bool = True
     gnome_source_configured: bool = False
     env_persisted: bool = False
 
@@ -301,6 +303,10 @@ def _check_ibus() -> IBusStatus:
     # Ping, not exists(): an engine can hold a socket file yet be deaf.
     from voiceio.ibus import ping_engine
     status.socket_reachable = ping_engine(timeout=1.0)
+    if not status.socket_reachable:
+        from voiceio.config import PID_PATH
+        from voiceio.pidlock import daemon_alive
+        status.voiceio_running = daemon_alive(PID_PATH)
 
     # Check GNOME input source
     try:
@@ -433,7 +439,9 @@ def format_report(report: HealthReport) -> str:
     lines.append(_check_line("Tray icon", report.tray_ok,
                              report.tray_reason if not report.tray_ok else "",
                              warn=not report.tray_ok))
-    if report.tray_fix_hint and not report.tray_ok:
+    if report.tray_ok and report.tray_fix_hint:  # works, but degraded
+        lines[-1] += f"  {DIM}{report.tray_reason}{RESET}"
+    if report.tray_fix_hint:
         lines.append(f"    {DIM}→ {report.tray_fix_hint}{RESET}")
 
     # IBus pipeline
@@ -448,6 +456,10 @@ def format_report(report: HealthReport) -> str:
             ("GNOME input source", ibus.gnome_source_configured, "voiceio setup"),
             ("Env persisted (reboot-safe)", ibus.env_persisted, "voiceio setup"),
         ]:
+            if label == "Engine answers" and not ok and not ibus.voiceio_running:
+                lines.append(f"  {DIM}–{RESET} {label}  "
+                             f"{DIM}starts with voiceio, which isn't running{RESET}")
+                continue
             lines.append(_check_line(label, ok, hint if not ok else "",
                                      warn=not ok))
 

{python_voiceio-1.14.0 → python_voiceio-1.15.1}/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.1}/voiceio/report.py

@@ -30,6 +30,8 @@ TIMEOUT_SECS = 8.0
 MAX_COMMENT = 300
 MAX_DETAIL = 90
 
+# A terminal escape: CSI sequences (arrow keys) or ESC plus one key (Alt+key).
+_ESCAPE = re.compile(r"\x1b(?:\[[0-?]*[ -/]*[@-~]|.)?", re.S)
 _IPV4 = re.compile(r"\b(?:\d{1,3}\.){3}\d{1,3}\b")
 _IPV6 = re.compile(r"\b(?:[0-9a-f]{1,4}:){3,7}[0-9a-f]{1,4}\b", re.I)
 _MAC = re.compile(r"\b(?:[0-9a-f]{2}[:-]){5}[0-9a-f]{2}\b", re.I)
@@ -155,7 +157,7 @@ def build_report(
     if health.ibus_checks is not None:
         ib = health.ibus_checks
         for label, ok in (("component", ib.component_installed), ("daemon", ib.daemon_running),
-                          ("engine ping", ib.socket_reachable),
+                          ("engine ping", ib.socket_reachable or not ib.voiceio_running),
                           ("env persisted", ib.env_persisted)):
             if not ok:
                 warned.append(f"ibus {label}")
@@ -178,7 +180,9 @@ def build_report(
         f"python {_py_platform.python_version()}",
         f"backends: hotkey {hotkey.name if hotkey else 'none'} · "
         f"typer {typer.name if typer else 'none'} · audio {audio} "
-        f"(vad {cfg.audio.vad_backend})",
+        f"(vad {cfg.audio.vad_backend})"
+        + (" · voiceio not running" if health.ibus_checks is not None
+           and not health.ibus_checks.voiceio_running else ""),
         f"model: {_model_label(cfg.model.name)}",
     ]
     if unavailable:
@@ -186,6 +190,7 @@ def build_report(
     lines.append("failed: " + "; ".join(failed) if failed else "failed: none")
     if warned:
         lines.append("warnings: " + "; ".join(warned))
+    comment = "".join(c if c.isprintable() else " " for c in _ESCAPE.sub("", comment))
     comment = " ".join(comment.split())[:MAX_COMMENT]
     if comment:
         lines.append(f"comment: {comment}")
@@ -233,6 +238,10 @@ def _interactive() -> bool:
 
 
 def _ask(prompt: str) -> str:
+    try:
+        import readline  # noqa: F401  line editing, so arrow keys don't type escapes
+    except ImportError:
+        pass
     try:
         return input(prompt)
     except (EOFError, KeyboardInterrupt):

{python_voiceio-1.14.0 → python_voiceio-1.15.1}/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.1}/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.1}/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 → python_voiceio-1.15.1}/voiceio/setup/steps.py

@@ -184,7 +184,8 @@ def _print_tray_check() -> bool:
     from voiceio.tray import probe_availability
     tray_ok, tray_reason, tray_fix_hint = probe_availability()
     if tray_ok:
-        _print_check("Tray icon", True, "system tray indicator available")
+        _print_check("Tray icon", True, f"{tray_reason}; {tray_fix_hint}" if tray_fix_hint
+                     else "system tray indicator available")
     else:
         _print_check("Tray icon", False,
                      tray_fix_hint if tray_fix_hint else tray_reason,

{python_voiceio-1.14.0 → python_voiceio-1.15.1}/voiceio/tray/__init__.py

@@ -59,11 +59,16 @@ def probe_availability() -> tuple[bool, str, str]:
         if py:
             return True, "AppIndicator3 available", ""
         from voiceio.platform import pkg_install
+        hint = f"install: {pkg_install('python3-gi', 'gir1.2-ayatanaappindicator3-0.1')}"
+        if _pystray_backend() == "xorg":
+            # What start() falls back to: an XEmbed icon (KDE and LXQt show
+            # it), animated, but without the menu.
+            return True, "basic icon (pystray, no menu)", f"for the full menu, {hint}"
         return (
             False,
             "no python3 with GTK3/AppIndicator3 bindings "
             "(set VOICEIO_SYSTEM_PYTHON to override)",
-            f"install: {pkg_install('python3-gi', 'gir1.2-ayatanaappindicator3-0.1')}",
+            hint,
         )
     elif sys.platform == "darwin":
         try:
@@ -82,6 +87,15 @@ def probe_availability() -> tuple[bool, str, str]:
     return False, "unsupported platform", ""
 
 
+def _pystray_backend() -> str | None:
+    """The backend pystray picks here ("xorg", "appindicator", ...), or None."""
+    try:
+        import pystray
+    except Exception:  # ImportError, or Xlib errors when there's no X display
+        return None
+    return pystray.Icon.__module__.rsplit("._", 1)[-1]
+
+
 def _start_indicator(
     theme_dir: Path,
     icon_names: list[str],

{python_voiceio-1.14.0 → python_voiceio-1.15.1}/voiceio/tray/_pystray.py

@@ -35,6 +35,9 @@ def start(
     except ImportError:
         log.warning("pystray/Pillow not installed, tray icon disabled")
         return False
+    except Exception as e:  # Linux import opens an X display: none means Xlib errors
+        log.warning("pystray unusable (%s), tray icon disabled", e)
+        return False
 
     _idle_img = Image.open(idle_path)
     _recording_frames = [Image.open(p) for p in frame_paths]

python_voiceio-1.14.0/voiceio/__init__.py

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