python-voiceio 0.8.2__tar.gz → 0.9.0__tar.gz

{python_voiceio-0.8.2/python_voiceio.egg-info → python_voiceio-0.9.0}/PKG-INFO

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

{python_voiceio-0.8.2 → python_voiceio-0.9.0}/pyproject.toml

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

{python_voiceio-0.8.2 → python_voiceio-0.9.0/python_voiceio.egg-info}/PKG-INFO

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

{python_voiceio-0.8.2 → python_voiceio-0.9.0}/python_voiceio.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ tests/test_concurrency_lockdown.py
 tests/test_config.py
 tests/test_correct_batch.py
 tests/test_corrections.py
+tests/test_evaluate.py
 tests/test_fallback.py
 tests/test_health.py
 tests/test_hints.py
@@ -42,6 +43,7 @@ tests/test_robustness.py
 tests/test_security_hardening.py
 tests/test_snapshots.py
 tests/test_streaming.py
+tests/test_tokens.py
 tests/test_transcriber.py
 tests/test_tts.py
 tests/test_vad.py
@@ -62,6 +64,7 @@ voiceio/config.py
 voiceio/consent.py
 voiceio/corrections.py
 voiceio/demo.py
+voiceio/evaluate.py
 voiceio/feedback.py
 voiceio/health.py
 voiceio/hints.py
@@ -79,8 +82,10 @@ voiceio/retention.py
 voiceio/service.py
 voiceio/snapshots.py
 voiceio/streaming.py
+voiceio/tokens.py
 voiceio/transcriber.py
 voiceio/vad.py
+voiceio/vocab_stats.py
 voiceio/vocabulary.py
 voiceio/wizard.py
 voiceio/wordfreq.py

{python_voiceio-0.8.2 → python_voiceio-0.9.0}/tests/test_adjudicate.py

@@ -212,6 +212,17 @@ def _suspicious():
 
 
 class TestBatchFlow:
+    """The adjudication flow. Correction mining is retired by default
+    ([autocorrect] mine_corrections = false, see test_correct_batch.py), so
+    these opt it back in — the machinery still has to be correct for anyone who
+    turns it on, and for the vocabulary path that shares it."""
+
+    def _cfg(self):
+        from voiceio.config import load
+        cfg = load()
+        cfg.autocorrect.mine_corrections = True
+        return cfg
+
     def _run(self, tmp_path, adj, *, review=None, suspicious=None, notify=None):
         from voiceio.autocorrect import ReviewResult
         cd = CorrectionDict(path=tmp_path / "c.json")
@@ -219,7 +230,8 @@ class TestBatchFlow:
             ask_user=[{"wrong": "mantekka", "right": "", "reason": "?"}],
         )
         suspicious = suspicious if suspicious is not None else _suspicious()
-        with patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
+        with patch("voiceio.config.load", return_value=self._cfg()), \
+             patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
              patch("voiceio.history.read", return_value=_entries()), \
              patch("voiceio.autocorrect.find_suspicious_words",
                    return_value=suspicious), \
@@ -274,6 +286,7 @@ class TestBatchFlow:
 
         cd = CorrectionDict(path=tmp_path / "c.json")
         with caplog.at_level(logging.INFO, logger="voiceio.cli"), \
+             patch("voiceio.config.load", return_value=self._cfg()), \
              patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
              patch("voiceio.history.read", return_value=_entries()), \
              patch("voiceio.autocorrect.find_suspicious_words", return_value=many), \

{python_voiceio-0.8.2 → python_voiceio-0.9.0}/tests/test_audio_quality.py

@@ -125,10 +125,31 @@ class TestPromptBudget:
     output. Oversized bias inputs truncated real transcriptions mid-utterance
     (2026-07-05 regression). These bounds must hold."""
 
-    def test_hotwords_capped(self):
-        from unittest.mock import MagicMock, patch
-        from voiceio.app import _HOTWORDS_MAX_CHARS
-        assert _HOTWORDS_MAX_CHARS <= 700
+    def test_hotwords_budget_leaves_room_to_transcribe(self):
+        """The bound that actually matters, in the unit that actually matters.
+
+        The old assertion was `_HOTWORDS_MAX_CHARS <= 700` — but chars are the
+        wrong unit: proper nouns tokenize at ~2.6 chars/token, so 600 chars was
+        really 238 tokens, already past faster-whisper's 223 cap.
+        """
+        from voiceio.app import _HOTWORDS_TOKEN_BUDGET
+        from voiceio.tokens import (
+            HOTWORDS_TOKEN_CAP,
+            MAX_SEQUENCE_TOKENS,
+            OUTPUT_RESERVE_TOKENS,
+            PROMPT_TOKEN_BUDGET,
+        )
+
+        # Past this, faster-whisper silently discards the tail of the list.
+        assert _HOTWORDS_TOKEN_BUDGET <= HOTWORDS_TOKEN_CAP
+        # The invariant that actually protects the user: hotwords + prompt must
+        # leave enough to transcribe with. Violating it truncated freeze chunks
+        # mid-sentence (~37 words of room for a 45-60 word chunk) and, worst
+        # case, drove the decode budget to <=0 (ValueError).
+        overhead = 4  # sot_prev + sot_sequence
+        left = (MAX_SEQUENCE_TOKENS - _HOTWORDS_TOKEN_BUDGET
+                - PROMPT_TOKEN_BUDGET - overhead)
+        assert left >= OUTPUT_RESERVE_TOKENS
 
     def test_prompt_builder_default_budget_small(self):
         from voiceio.prompt import PromptBuilder

{python_voiceio-0.8.2 → python_voiceio-0.9.0}/tests/test_correct_batch.py

@@ -20,6 +20,14 @@ def _suspicious():
                            contexts=["check the mantekka transfers"])]
 
 
+def _cfg_with_mining():
+    """Config with the retired correction mining explicitly opted back in."""
+    from voiceio.config import load
+    cfg = load()
+    cfg.autocorrect.mine_corrections = True
+    return cfg
+
+
 class TestBatchMode:
     def test_no_api_key_bails_quietly(self, tmp_path, capsys):
         cd = CorrectionDict(path=tmp_path / "c.json")
@@ -29,7 +37,11 @@ class TestBatchMode:
         assert "skipping batch" in capsys.readouterr().out.lower()
 
     def test_ambiguous_item_deferred_no_notify_cursor_advances(self, tmp_path):
-        """No consensus → silently deferred; no queue, no notification, cursor advances."""
+        """No consensus → silently deferred; no queue, no notification, cursor advances.
+
+        Opts mining back in: it's retired by default (see
+        TestCorrectionMiningRetired) but the machinery must still be correct.
+        """
         cd = CorrectionDict(path=tmp_path / "c.json")
         review = ReviewResult()
         review.ask_user.append({"wrong": "mantekka", "right": "Manteca",
@@ -37,7 +49,8 @@ class TestBatchMode:
         adj = AdjudicationResult(
             deferred=[{"wrong": "mantekka", "right": "Manteca", "votes": []}],
         )
-        with patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
+        with patch("voiceio.config.load", return_value=_cfg_with_mining()), \
+             patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
              patch("voiceio.history.read", return_value=_entries()), \
              patch("voiceio.autocorrect.find_suspicious_words",
                    return_value=_suspicious()), \
@@ -54,11 +67,13 @@ class TestBatchMode:
         assert "mantekka" in state.deferred
 
     def test_unanimous_correction_applied_and_notified(self, tmp_path):
+        """Mining opted back in — it's retired by default, not deleted."""
         cd = CorrectionDict(path=tmp_path / "c.json")
         review = ReviewResult()
         review.ask_user.append({"wrong": "mantekka", "right": "", "reason": "?"})
         adj = AdjudicationResult(apply=[{"wrong": "mantekka", "right": "manteca"}])
-        with patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
+        with patch("voiceio.config.load", return_value=_cfg_with_mining()), \
+             patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
              patch("voiceio.history.read", return_value=_entries()), \
              patch("voiceio.autocorrect.find_suspicious_words",
                    return_value=_suspicious()), \
@@ -127,3 +142,70 @@ class TestProtectLanguages:
         assert gate_correction("ngroc", "ngrok",
                                vocabulary={"ngrok"},
                                protect_languages=["es", "ca"]) is None
+
+
+class TestCorrectionMiningRetired:
+    """Correction mining is off by default.
+
+    Measured over months: 387 rules mined, 4 ever fired (1%), while the runtime
+    postcorrect pass applied 288 edits. Rules are exact-string matches, so they
+    only fire if Whisper repeats a misrecognition verbatim — and the errors
+    worth fixing ("nuance" for "neurons") are common words the safety gate must
+    refuse. One run learned rules that destroyed real Spanish words. Vocabulary
+    mining is a different story and stays on.
+    """
+
+    def _review(self):
+        # "compain" -> "company" passes gate_correction: the target is a common
+        # word. ("olamma" -> "Ollama" would be rejected because the target is
+        # neither common nor already in the vocabulary — pre-existing gate
+        # behaviour, unrelated to mining being retired.)
+        from voiceio.autocorrect import ReviewResult
+        return ReviewResult(
+            auto_fix=[{"wrong": "compain", "right": "company", "reason": "typo"}],
+            ask_user=[{"wrong": "wordal", "right": "Wordle", "reason": "maybe"}],
+            vocabulary=["Kubernetes"],
+        )
+
+    def test_default_is_off(self):
+        from voiceio.config import AutocorrectConfig
+        assert AutocorrectConfig().mine_corrections is False
+
+    def test_no_rules_learned_by_default(self):
+        """The whole point: a batch run must not grow corrections.json."""
+        from voiceio.corrections import CorrectionDict
+
+        cd = CorrectionDict()
+        with patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
+             patch("voiceio.history.read", return_value=_entries()), \
+             patch("voiceio.autocorrect.find_suspicious_words", return_value=_suspicious()), \
+             patch("voiceio.autocorrect.review_suspicious", return_value=self._review()), \
+             patch("voiceio.autocorrect.adjudicate") as adj, \
+             patch("voiceio.vocabulary.add_terms", return_value=1) as add_terms, \
+             patch("voiceio.feedback.notify"):
+            _cmd_correct_auto(cd, batch=True)
+
+        assert cd.list_all() == {}       # no rules learned
+        assert not adj.called            # and no LLM spend adjudicating them
+        assert add_terms.called          # vocabulary mining still runs
+
+    def test_opt_in_still_mines(self):
+        """The machinery is retired, not deleted — it must still work if asked."""
+        from voiceio.autocorrect import AdjudicationResult
+        from voiceio.corrections import CorrectionDict
+
+        cfg = _cfg_with_mining()
+        cd = CorrectionDict()
+        adj = AdjudicationResult(apply=[], vocabulary=[], deferred=[])
+        with patch("voiceio.config.load", return_value=cfg), \
+             patch("voiceio.llm_api.resolve_api_key", return_value="sk-x"), \
+             patch("voiceio.history.read", return_value=_entries()), \
+             patch("voiceio.autocorrect.find_suspicious_words", return_value=_suspicious()), \
+             patch("voiceio.autocorrect.review_suspicious", return_value=self._review()), \
+             patch("voiceio.autocorrect.adjudicate", return_value=adj) as adjudicate, \
+             patch("voiceio.vocabulary.add_terms", return_value=1), \
+             patch("voiceio.feedback.notify"):
+            _cmd_correct_auto(cd, batch=True)
+
+        assert "compain" in cd.list_all()  # gate-passing auto_fix applied
+        assert adjudicate.called           # ambiguous ones still adjudicated

python_voiceio-0.9.0/tests/test_evaluate.py

@@ -0,0 +1,198 @@
+"""Tests for the decoder-config eval harness.
+
+The harness exists because every decoder knob was set from a plausible story and
+one example. Its own detectors must not be in the same position — hence real
+assertions on the hallucination/repetition counters, using the exact shapes seen
+in production.
+"""
+from __future__ import annotations
+
+import wave
+from unittest.mock import patch
+
+import numpy as np
+
+from voiceio.evaluate import (
+    count_hallucinations,
+    count_repetitions,
+    default_matrix,
+    evaluate,
+    sample_clips,
+)
+
+
+class TestHallucinationDetection:
+    def test_catches_whisper_filler(self):
+        assert count_hallucinations([" Thank you."]) == 1
+        assert count_hallucinations(["Thanks for watching!"]) == 1
+        assert count_hallucinations([" Thank you.", " Thank you."]) == 2
+
+    def test_ignores_real_speech(self):
+        assert count_hallucinations(["Thank you for the detailed review"]) == 0
+        assert count_hallucinations(["so I want you to own this end to end"]) == 0
+
+    def test_matches_whole_segment_not_substring(self):
+        """'thank you' inside a sentence is speech, not a hallucination."""
+        assert count_hallucinations(["I say thank you to the team"]) == 0
+
+    def test_empty(self):
+        assert count_hallucinations([]) == 0
+        assert count_hallucinations(["", "   "]) == 0
+
+
+class TestRepetitionDetection:
+    def test_catches_the_real_loop(self):
+        """Verbatim from a 422s dictation that looped four times."""
+        text = ("make a hypothesis why intelligence is not working out "
+                + "because it should not work out in the complex world " * 4
+                + "so we have seen simpler simulations")
+        assert count_repetitions(text) >= 1
+
+    def test_ignores_normal_speech(self):
+        text = ("So on each generation we have an algorithm to determine the "
+                "general shape of the brain and once that is determined we add "
+                "one or two nodes or more hidden nodes and more connections")
+        assert count_repetitions(text) == 0
+
+    def test_ignores_short_text(self):
+        assert count_repetitions("testing testing one two three") == 0
+
+    def test_needs_a_real_run_not_two(self):
+        """Saying something twice is emphasis; three-plus is a decode loop."""
+        twice = "the quick brown fox the quick brown fox and then it stopped"
+        assert count_repetitions(twice) == 0
+
+
+class TestDefaultMatrix:
+    def test_includes_shipped_baseline(self):
+        names = [c.name for c in default_matrix()]
+        assert "shipped" in names
+
+    def test_shipped_matches_the_worker(self):
+        """If worker.py's decode params drift, this baseline is a lie."""
+        shipped = next(c for c in default_matrix() if c.name == "shipped")
+        src = (__import__("pathlib").Path(__file__).resolve().parent.parent
+               / "voiceio" / "worker.py").read_text()
+        assert "condition_on_previous_text=False" in src
+        assert "vad_filter=True" in src
+        assert shipped.condition_on_previous_text is False
+        assert shipped.vad_filter is True
+
+    def test_never_pairs_cond_with_hotwords(self):
+        """They share faster-whisper's sot_prev slot: 223 + 223 + sot > 448,
+        which raises 'maximum decoding length must be > 0'. Not a config."""
+        for c in default_matrix():
+            assert not (c.condition_on_previous_text and c.hotwords), c.name
+
+
+def _write_wav(path, secs=1.0):
+    with wave.open(str(path), "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(16000)
+        w.writeframes((np.zeros(int(16000 * secs), dtype=np.int16)).tobytes())
+
+
+class TestSampleClips:
+    def test_respects_audio_budget(self, tmp_path, monkeypatch):
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        for i in range(10):
+            _write_wav(rec / f"c{i}.wav", secs=2.0)
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+        got = sample_clips(5.0)
+        assert 0 < len(got) <= 3  # 2s each, budget 5s
+
+    def test_no_recordings_dir(self, tmp_path, monkeypatch):
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", tmp_path / "nope")
+        assert sample_clips(100) == []
+
+    def test_includes_long_clips(self, tmp_path, monkeypatch):
+        """The bias this replaced: newest-first sampling was ALL short clips
+        (8 clips, 22s avg), so condition_on_previous_text's repetition loops —
+        which only happen on long dictation — could not appear, and the harness
+        happily recommended cond=True."""
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        for i in range(30):  # many short, newest
+            _write_wav(rec / f"short{i:02d}.wav", secs=10.0)
+        _write_wav(rec / "long.wav", secs=120.0)
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+
+        got = sample_clips(300)
+        names = [p.name for p in got]
+        assert "long.wav" in names
+        assert any(n.startswith("short") for n in names)
+
+    def test_all_short_still_fills_budget(self, tmp_path, monkeypatch):
+        """No long recordings must not mean a half-empty sample."""
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        for i in range(20):
+            _write_wav(rec / f"s{i:02d}.wav", secs=10.0)
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+        got = sample_clips(100)
+        assert len(got) >= 9  # ~10 x 10s, not capped at the 50% short share
+
+
+class TestEvaluate:
+    def test_no_audio_returns_empty(self, tmp_path, monkeypatch):
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", tmp_path / "nope")
+        from voiceio.config import Config
+        assert evaluate(Config(), default_matrix(), teacher=lambda p: "x") == []
+
+    def test_teacher_silence_returns_empty(self, tmp_path, monkeypatch):
+        """A teacher that hears nothing gives nothing to score against."""
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        _write_wav(rec / "a.wav")
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+        from voiceio.config import Config
+        assert evaluate(Config(), default_matrix(), teacher=lambda p: "") == []
+
+    def test_scores_and_ranks_by_wer(self, tmp_path, monkeypatch):
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        _write_wav(rec / "a.wav", secs=1.0)
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+
+        class _Seg:
+            def __init__(self, t):
+                self.text = t
+
+        class _Model:
+            def transcribe(self, audio, **kw):
+                # The no-vad config "hears" the reference exactly; shipped drops
+                # a word. Ranking must follow WER, not declaration order.
+                if kw.get("vad_filter"):
+                    return iter([_Seg("hello there")]), None
+                return iter([_Seg("hello there world")]), None
+
+        from voiceio.config import Config
+        with patch("voiceio.worker.load_model", return_value=_Model()), \
+             patch("voiceio.vocabulary.load_terms", return_value=[]):
+            scores = evaluate(Config(), default_matrix(),
+                              teacher=lambda p: "hello there world")
+
+        assert scores
+        assert scores[0].wer <= scores[-1].wer          # sorted best-first
+        assert scores[0].config.vad_filter is False     # the exact-match config
+        assert all(s.clips == 1 for s in scores)
+
+    def test_a_crashing_config_is_a_result_not_an_error(self, tmp_path, monkeypatch):
+        rec = tmp_path / "recordings"
+        rec.mkdir()
+        _write_wav(rec / "a.wav")
+        monkeypatch.setattr("voiceio.config.RECORDINGS_DIR", rec)
+
+        class _Model:
+            def transcribe(self, audio, **kw):
+                raise ValueError("The maximum decoding length must be > 0")
+
+        from voiceio.config import Config
+        with patch("voiceio.worker.load_model", return_value=_Model()), \
+             patch("voiceio.vocabulary.load_terms", return_value=[]):
+            scores = evaluate(Config(), default_matrix(), teacher=lambda p: "hi")
+
+        assert all(s.crashes == 1 for s in scores)
+        assert all(s.clips == 0 for s in scores)

python_voiceio-0.9.0/tests/test_tokens.py

@@ -0,0 +1,107 @@
+"""Tests for exact Whisper token counting and the shared 448-token budget.
+
+Every budget here used to be a character count with a guessed chars/token ratio.
+The guess was wrong in the direction that mattered: proper nouns tokenize at
+~2.6 chars/token vs prose's ~4.0, so the old 600-char hotwords cap was really
+238 tokens — past faster-whisper's 223 cap, which then silently dropped terms
+and starved the output budget.
+"""
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+
+from voiceio.tokens import (
+    HOTWORDS_TOKEN_CAP,
+    MAX_SEQUENCE_TOKENS,
+    OUTPUT_RESERVE_TOKENS,
+    PROMPT_TOKEN_BUDGET,
+    _tokenizer,
+    count_tokens,
+    truncate_to_tokens,
+)
+
+# Most tests here are self-consistent — they count and assert with the same
+# function, so the estimate fallback is fine. A few assert properties of the
+# REAL tokenizer and are meaningless against a fixed chars/token constant; those
+# need a cached model, which CI runners don't have.
+needs_tokenizer = pytest.mark.skipif(
+    _tokenizer("small") is None,
+    reason="no cached whisper tokenizer (CI runners have no model cache)",
+)
+
+
+class TestCountTokens:
+    def test_empty(self):
+        assert count_tokens("", "small") == 0
+
+    def test_counts_real_tokens(self):
+        n = count_tokens("Grafana, Hetzner, OpenRouter", "small")
+        assert 5 < n < 30
+
+    @needs_tokenizer
+    def test_proper_nouns_cost_more_than_prose_per_char(self):
+        """The measured fact the whole redesign rests on.
+
+        Only meaningful against the real tokenizer: the fallback is a fixed
+        chars/token constant, which makes both ratios equal by construction.
+        """
+        nouns = "Kalshi, Metaculus, HyperNEAT, Kubernetes, Hetzner, Grafana"
+        prose = "the quick brown fox jumps over the lazy dog and then it runs"
+        nouns_ratio = len(nouns) / count_tokens(nouns, "small")
+        prose_ratio = len(prose) / count_tokens(prose, "small")
+        assert nouns_ratio < prose_ratio
+
+    def test_falls_back_to_estimate_without_tokenizer(self):
+        """No tokenizer must degrade to an estimate, never break dictation."""
+        import voiceio.tokens as t
+        with patch.dict(t._cache, {"bogus-model": None}, clear=False):
+            n = count_tokens("hello world", "bogus-model")
+        assert n > 0
+
+    def test_survives_a_broken_tokenizer(self):
+        import voiceio.tokens as t
+
+        class _Boom:
+            def encode(self, _):
+                raise RuntimeError("corrupt")
+
+        with patch.dict(t._cache, {"broken": _Boom()}, clear=False):
+            assert count_tokens("hello world", "broken") > 0
+
+
+class TestTruncateToTokens:
+    def test_noop_when_within_budget(self):
+        assert truncate_to_tokens("short text", 100, "small") == "short text"
+
+    def test_trims_to_budget(self):
+        text = "word " * 500
+        out = truncate_to_tokens(text, 50, "small")
+        assert count_tokens(out, "small") <= 50
+        assert out  # not emptied
+
+    def test_keeps_the_end(self):
+        """Prompts condition the audio that follows, so the OLDEST context goes."""
+        text = "alpha beta gamma delta " * 50 + "FINALWORD"
+        out = truncate_to_tokens(text, 20, "small")
+        assert "FINALWORD" in out
+
+    def test_zero_budget_is_empty(self):
+        assert truncate_to_tokens("anything", 0, "small") == ""
+
+
+class TestSharedBudget:
+    def test_budgets_leave_room_to_transcribe(self):
+        """hotwords + prompt + output must fit 448, with output usable.
+
+        Before this, the live config spent 223 (hotwords) + 171 (prompt) and
+        left ~50 tokens — about 37 words — to transcribe a freeze chunk holding
+        45-60. Worst case it went negative and faster-whisper raised
+        "The maximum decoding length must be > 0".
+        """
+        from voiceio.app import _HOTWORDS_TOKEN_BUDGET
+
+        total = _HOTWORDS_TOKEN_BUDGET + PROMPT_TOKEN_BUDGET + OUTPUT_RESERVE_TOKENS
+        assert total + 4 <= MAX_SEQUENCE_TOKENS
+        assert _HOTWORDS_TOKEN_BUDGET <= HOTWORDS_TOKEN_CAP

{python_voiceio-0.8.2 → python_voiceio-0.9.0}/tests/test_transcriber.py

@@ -233,13 +233,11 @@ class TestDecodeTimeoutIsLazy:
 class TestWorkerModelLoad:
     """A cached model must load without touching the network."""
 
-    ARGS = {"model": "small", "device": "auto", "compute_type": "int8"}
-
     def test_prefers_local_cache(self):
         from voiceio import worker
 
         with patch("voiceio.worker.WhisperModel") as wm:
-            worker._load_model(dict(self.ARGS))
+            worker.load_model("small", device="auto", compute_type="int8")
         assert wm.call_args.kwargs["local_files_only"] is True
 
     def test_falls_back_to_network_when_not_cached(self):
@@ -248,6 +246,23 @@ class TestWorkerModelLoad:
         sentinel = object()
         with patch("voiceio.worker.WhisperModel",
                    side_effect=[OSError("not cached"), sentinel]) as wm:
-            got = worker._load_model(dict(self.ARGS))
+            got = worker.load_model("small")
         assert got is sentinel
         assert "local_files_only" not in wm.call_args.kwargs
+
+    def test_every_whisper_load_goes_through_the_guarded_helper(self):
+        """A raw WhisperModel(...) anywhere else reintroduces the hang: the
+        teacher audit and the wizard both load models on this same box."""
+        import re
+        from pathlib import Path
+
+        src = Path(__file__).resolve().parent.parent / "voiceio"
+        offenders = []
+        for py in src.rglob("*.py"):
+            for i, line in enumerate(py.read_text().splitlines(), 1):
+                if re.search(r"(?<!def )\bWhisperModel\(", line):
+                    # worker.load_model is the one sanctioned construction site.
+                    if py.name == "worker.py":
+                        continue
+                    offenders.append(f"{py.relative_to(src)}:{i}")
+        assert not offenders, f"unguarded WhisperModel loads: {offenders}"