python-voiceio 0.5.0__tar.gz → 0.7.0__tar.gz

{python_voiceio-0.5.0/python_voiceio.egg-info → python_voiceio-0.7.0}/PKG-INFO

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

{python_voiceio-0.5.0 → python_voiceio-0.7.0}/pyproject.toml

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

{python_voiceio-0.5.0 → python_voiceio-0.7.0/python_voiceio.egg-info}/PKG-INFO

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

python_voiceio-0.7.0/tests/test_llm_api.py

@@ -0,0 +1,261 @@
+"""Tests for voiceio.llm_api — OpenAI-compatible chat completions client."""
+from __future__ import annotations
+
+import http.client
+import json
+import urllib.error
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from voiceio import llm_api
+from voiceio.config import AutocorrectConfig
+from voiceio.llm_api import chat, check_api_key, detect_provider, resolve_api_key
+
+
+@pytest.fixture(autouse=True)
+def _clear_pool():
+    """Keep-alive pool is process-global state — isolate every test."""
+    llm_api._CONN_POOL.clear()
+    yield
+    llm_api._CONN_POOL.clear()
+
+
+def _fake_conn(data: dict | None, status: int = 200) -> MagicMock:
+    """A mock http.client connection returning one JSON response."""
+    resp = MagicMock()
+    resp.status = status
+    resp.reason = "OK" if status == 200 else "ERR"
+    resp.read.return_value = json.dumps(data or {}).encode()
+    resp.getheaders.return_value = []
+    conn = MagicMock()
+    conn.getresponse.return_value = resp
+    return conn
+
+
+def _request_kwargs(conn: MagicMock) -> tuple[str, dict, dict]:
+    """(path, headers, parsed body) of the single request made on conn."""
+    args, kwargs = conn.request.call_args
+    return args[1], kwargs["headers"], json.loads(kwargs["body"])
+
+
+def _cfg(**kwargs) -> AutocorrectConfig:
+    defaults = {"api_key": "test-key", "model": "test-model"}
+    defaults.update(kwargs)
+    return AutocorrectConfig(**defaults)
+
+
+# ── resolve_api_key ──────────────────────────────────────────────────────
+
+
+def test_resolve_from_config():
+    cfg = _cfg(api_key="sk-from-config")
+    assert resolve_api_key(cfg) == "sk-from-config"
+
+
+@patch.dict("os.environ", {"OPENROUTER_API_KEY": "sk-from-env"}, clear=False)
+def test_resolve_from_env():
+    cfg = _cfg(api_key="")
+    assert resolve_api_key(cfg) == "sk-from-env"
+
+
+@patch.dict("os.environ", {}, clear=True)
+def test_resolve_empty():
+    cfg = _cfg(api_key="")
+    assert resolve_api_key(cfg) == ""
+
+
+# ── chat ─────────────────────────────────────────────────────────────────
+
+
+def test_chat_success():
+    conn = _fake_conn({"choices": [{"message": {"content": "Fixed text."}}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        result = chat(_cfg(), "system prompt", "user message")
+    assert result == "Fixed text."
+
+    path, headers, body = _request_kwargs(conn)
+    assert path == "/v1/chat/completions" or path.endswith("/chat/completions")
+    assert headers["Authorization"] == "Bearer test-key"
+    assert headers["Content-Type"] == "application/json"
+    assert body["model"] == "test-model"
+    assert body["messages"][0]["role"] == "system"
+    assert body["messages"][1]["role"] == "user"
+
+
+def test_chat_timeout():
+    conn = MagicMock()
+    conn.request.side_effect = OSError("timed out")
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_http_401():
+    conn = _fake_conn({"error": "invalid key"}, status=401)
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_no_api_key():
+    cfg = _cfg(api_key="")
+    with patch.dict("os.environ", {}, clear=True):
+        assert chat(cfg, "sys", "msg") is None
+
+
+def test_chat_malformed_response():
+    conn = _fake_conn({"unexpected": "format"})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_null_content_returns_none():
+    """Thinking models (Kimi K2.6 etc.) can return content=None — must not crash."""
+    conn = _fake_conn({"choices": [{"message": {"content": None}}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") is None
+
+
+def test_chat_falls_back_to_reasoning_field():
+    """When content is null but reasoning is present, use reasoning text."""
+    conn = _fake_conn({
+        "choices": [{"message": {"content": None, "reasoning": "the answer"}}],
+    })
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") == "the answer"
+
+
+def test_chat_falls_back_to_reasoning_content_field():
+    """Some providers expose `reasoning_content` instead of `reasoning`."""
+    conn = _fake_conn({
+        "choices": [{"message": {
+            "content": None,
+            "reasoning_content": "thought-through answer",
+        }}],
+    })
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert chat(_cfg(), "sys", "msg") == "thought-through answer"
+
+
+def test_chat_anthropic_null_content_array():
+    """Anthropic native API: content=null shouldn't crash."""
+    conn = _fake_conn({"content": None})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        cfg = _cfg(base_url="https://api.anthropic.com/v1")
+        assert chat(cfg, "sys", "msg") is None
+
+
+# ── check_api_key ────────────────────────────────────────────────────────
+
+
+def test_check_valid_key():
+    conn = _fake_conn({"choices": [{"message": {"content": ""}}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert check_api_key(_cfg(), "sk-valid") is True
+
+
+def test_check_invalid_key():
+    conn = _fake_conn({"error": "unauthorized"}, status=401)
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        assert check_api_key(_cfg(), "sk-invalid") is False
+
+
+def test_check_empty_key():
+    cfg = _cfg(api_key="")
+    with patch.dict("os.environ", {}, clear=True):
+        assert check_api_key(cfg) is False
+
+
+# ── Anthropic native API ────────────────────────────────────────────────
+
+
+def test_chat_anthropic_native():
+    conn = _fake_conn({"content": [{"type": "text", "text": "Fixed text."}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        cfg = _cfg(base_url="https://api.anthropic.com/v1")
+        result = chat(cfg, "system prompt", "user message")
+    assert result == "Fixed text."
+
+    path, headers, body = _request_kwargs(conn)
+    assert path.endswith("/messages")
+    assert headers["x-api-key"] == "test-key"
+    assert headers["anthropic-version"] == "2023-06-01"
+    assert "Authorization" not in headers
+    assert body["system"] == "system prompt"
+    assert body["messages"] == [{"role": "user", "content": "user message"}]
+
+
+def test_check_api_key_anthropic():
+    conn = _fake_conn({"content": [{"type": "text", "text": ""}]})
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        cfg = _cfg(base_url="https://api.anthropic.com/v1")
+        assert check_api_key(cfg, "sk-ant-test") is True
+    path, _, _ = _request_kwargs(conn)
+    assert path.endswith("/messages")
+
+
+# ── detect_provider ─────────────────────────────────────────────────────
+
+
+def test_detect_openrouter():
+    base_url, model = detect_provider("sk-or-abc123")
+    assert "openrouter" in base_url
+    assert "kimi" in model
+
+
+def test_detect_anthropic():
+    base_url, model = detect_provider("sk-ant-abc123")
+    assert "anthropic.com" in base_url
+    assert "claude" in model
+
+
+def test_detect_openai():
+    base_url, model = detect_provider("sk-proj-abc123")
+    assert "openai.com" in base_url
+
+
+def test_detect_unknown_defaults_openrouter():
+    base_url, _ = detect_provider("unknown-key-format")
+    assert "openrouter" in base_url
+
+
+# ── keep-alive connection pool ───────────────────────────────────────────
+
+
+def test_post_json_reuses_connection():
+    conn = _fake_conn({"ok": 1})
+    with patch("http.client.HTTPSConnection", return_value=conn) as cls:
+        r1 = llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+        r2 = llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+    assert r1 == {"ok": 1} and r2 == {"ok": 1}
+    cls.assert_called_once()  # second call reused the pooled connection
+    assert conn.request.call_count == 2
+
+
+def test_post_json_retries_stale_pooled_connection():
+    stale = MagicMock()
+    stale.sock = None
+    stale.request.side_effect = http.client.BadStatusLine("")  # server closed it
+    llm_api._CONN_POOL["https://api.example.com"] = stale
+    fresh = _fake_conn({"ok": 2})
+    with patch("http.client.HTTPSConnection", return_value=fresh):
+        r = llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+    assert r == {"ok": 2}
+    stale.close.assert_called_once()
+
+
+def test_post_json_fresh_connection_error_propagates():
+    conn = MagicMock()
+    conn.request.side_effect = OSError("connection refused")
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        with pytest.raises(OSError):
+            llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+
+
+def test_post_json_http_error_compatible():
+    conn = _fake_conn({"error": "bad key"}, status=401)
+    with patch("http.client.HTTPSConnection", return_value=conn):
+        with pytest.raises(urllib.error.HTTPError) as exc:
+            llm_api._post_json("https://api.example.com/v1/x", {}, {}, 5)
+    assert exc.value.code == 401
+    assert b"bad key" in exc.value.read()
+    assert not llm_api._CONN_POOL  # error connections are not pooled

{python_voiceio-0.5.0 → python_voiceio-0.7.0}/tests/test_postcorrect.py

@@ -161,3 +161,119 @@ def test_pipeline_runs_postcorrect_only_on_final():
         )
         assert text == "Crisp chat is the best tool"
         assert not abort
+
+
+# ── wall-clock deadline ──────────────────────────────────────────────────
+
+
+def test_deadline_exceeded_keeps_original():
+    """A chat call slower than timeout_secs is abandoned at the deadline."""
+    import time as _time
+    cfg = _cfg()
+    cfg.postcorrect.timeout_secs = 0.2
+
+    def slow_chat(*a, **kw):
+        _time.sleep(2.0)
+        return "Crisp chat is the tool"
+
+    pc = PostCorrector(cfg)
+    with patch("voiceio.llm_api.chat", side_effect=slow_chat):
+        t0 = _time.monotonic()
+        assert pc.correct("Chris chat is the tool") == "Chris chat is the tool"
+        elapsed = _time.monotonic() - t0
+    assert elapsed < 1.0  # returned at the deadline, not after the full call
+    assert pc.last_secs is not None
+
+
+def test_within_deadline_applies_correction():
+    cfg = _cfg()
+    cfg.postcorrect.timeout_secs = 5.0
+    pc = PostCorrector(cfg)
+    with patch("voiceio.llm_api.chat", return_value="Crisp chat is the tool"):
+        assert pc.correct("Chris chat is the tool") == "Crisp chat is the tool"
+
+
+# ── before/after pair persistence ────────────────────────────────────────
+
+
+def _read_pairs(path):
+    import json
+    return [json.loads(line) for line in path.read_text().splitlines()]
+
+
+def test_applied_correction_recorded(tmp_path, monkeypatch):
+    import voiceio.postcorrect as pcmod
+    from voiceio import config as cfgmod
+    pairs = tmp_path / "pairs.jsonl"
+    monkeypatch.setattr(cfgmod, "POSTCORRECT_PAIRS_PATH", pairs)
+    pc = PostCorrector(_cfg())
+    with patch("voiceio.llm_api.chat", return_value="Crisp chat is the tool"):
+        pc.correct("Chris chat is the tool")
+    entries = _read_pairs(pairs)
+    assert len(entries) == 1
+    assert entries[0]["outcome"] == "applied"
+    assert entries[0]["before"] == "Chris chat is the tool"
+    assert entries[0]["after"] == "Crisp chat is the tool"
+    assert entries[0]["secs"] is not None
+
+
+def test_rejected_rewrite_recorded(tmp_path, monkeypatch):
+    from voiceio import config as cfgmod
+    pairs = tmp_path / "pairs.jsonl"
+    monkeypatch.setattr(cfgmod, "POSTCORRECT_PAIRS_PATH", pairs)
+    pc = PostCorrector(_cfg())
+    with patch("voiceio.llm_api.chat", return_value="Completely different rewritten sentence with many other words entirely"):
+        out = pc.correct("Chris chat is the tool")
+    assert out == "Chris chat is the tool"
+    entries = _read_pairs(pairs)
+    assert len(entries) == 1
+    assert entries[0]["outcome"].startswith("rejected")
+
+
+def test_no_recording_when_disabled(tmp_path, monkeypatch):
+    from voiceio import config as cfgmod
+    pairs = tmp_path / "pairs.jsonl"
+    monkeypatch.setattr(cfgmod, "POSTCORRECT_PAIRS_PATH", pairs)
+    cfg = _cfg()
+    cfg.data.capture_intermediates = False
+    pc = PostCorrector(cfg)
+    with patch("voiceio.llm_api.chat", return_value="Crisp chat is the tool"):
+        pc.correct("Chris chat is the tool")
+    assert not pairs.exists()
+
+
+def test_hung_request_blocks_next_call_not_thread_pileup(tmp_path, monkeypatch):
+    """A worker abandoned at the deadline makes the NEXT call skip the LLM."""
+    import threading as _threading
+    import time as _time
+    from voiceio import config as cfgmod
+    monkeypatch.setattr(cfgmod, "POSTCORRECT_PAIRS_PATH", tmp_path / "pairs.jsonl")
+    cfg = _cfg()
+    cfg.postcorrect.timeout_secs = 0.1
+    pc = PostCorrector(cfg)
+    release = _threading.Event()
+
+    def hung_chat(*a, **kw):
+        release.wait(5)
+        return "x"
+
+    with patch("voiceio.llm_api.chat", side_effect=hung_chat) as mock_chat:
+        assert pc.correct("Chris chat is the tool") == "Chris chat is the tool"
+        assert mock_chat.call_count == 1
+        # Second call while the first worker is still hung: no new thread
+        assert pc.correct("Chris chat is the tool") == "Chris chat is the tool"
+        assert mock_chat.call_count == 1
+    release.set()
+    entries = _read_pairs(tmp_path / "pairs.jsonl")
+    assert [e["outcome"] for e in entries] == ["timeout", "skipped_busy"]
+
+
+def test_recorded_context_is_effective_context(tmp_path, monkeypatch):
+    from voiceio import config as cfgmod
+    monkeypatch.setattr(cfgmod, "POSTCORRECT_PAIRS_PATH", tmp_path / "pairs.jsonl")
+    pc = PostCorrector(_cfg())
+    pc.set_context(title="Stale Window")
+    with patch("voiceio.llm_api.chat", return_value="Crisp chat is the tool"):
+        pc.correct("Chris chat is the tool", context="Fresh Window")
+    entries = _read_pairs(tmp_path / "pairs.jsonl")
+    assert entries[0]["context"] == "Fresh Window"

{python_voiceio-0.5.0 → python_voiceio-0.7.0}/tests/test_retention.py

@@ -97,3 +97,72 @@ class TestHistoryExtra:
         entry = json.loads(p.read_text())
         assert entry["text"] == "hello"
         assert entry["ts"] != 0
+
+
+# ── intermediate data capture + disk floor ──────────────────────────────
+
+
+class TestAppendJsonl:
+    def test_appends_lines(self, tmp_path):
+        from voiceio import retention
+        p = tmp_path / "pairs.jsonl"
+        retention.append_jsonl(p, {"a": 1})
+        retention.append_jsonl(p, {"b": 2})
+        import json
+        lines = [json.loads(line) for line in p.read_text().splitlines()]
+        assert lines == [{"a": 1}, {"b": 2}]
+
+    def test_never_raises_on_bad_entry(self, tmp_path):
+        from voiceio import retention
+        retention.append_jsonl(tmp_path / "x.jsonl", {"bad": object()})  # not JSON-able
+
+
+class TestSaveTrace:
+    def test_writes_when_enabled(self, tmp_path, monkeypatch):
+        from voiceio import retention
+        from voiceio.config import DataConfig
+        monkeypatch.setattr(retention, "TRACES_PATH", tmp_path / "trace.jsonl")
+        retention.save_trace(DataConfig(), {"ts": 1, "passes": []})
+        assert (tmp_path / "trace.jsonl").exists()
+
+    def test_skips_when_disabled(self, tmp_path, monkeypatch):
+        from voiceio import retention
+        from voiceio.config import DataConfig
+        monkeypatch.setattr(retention, "TRACES_PATH", tmp_path / "trace.jsonl")
+        retention.save_trace(DataConfig(capture_intermediates=False), {"ts": 1})
+        assert not (tmp_path / "trace.jsonl").exists()
+
+
+class TestDiskFloor:
+    def test_save_audio_skips_below_floor(self, monkeypatch):
+        import numpy as np
+        from voiceio import retention
+        from voiceio.config import DataConfig
+        monkeypatch.setattr(retention, "_free_gb", lambda p: 1.0)
+        name = retention.save_audio(
+            np.zeros(1600, dtype=np.float32), 0.0, DataConfig(min_free_gb=5.0),
+        )
+        assert name is None
+
+    def test_save_audio_ok_above_floor(self, tmp_path, monkeypatch):
+        import numpy as np
+        from voiceio import retention
+        from voiceio.config import DataConfig
+        monkeypatch.setattr(retention, "RECORDINGS_DIR", tmp_path)
+        monkeypatch.setattr(retention, "_free_gb", lambda p: 100.0)
+        name = retention.save_audio(
+            np.zeros(1600, dtype=np.float32), 0.0, DataConfig(min_free_gb=5.0),
+        )
+        assert name is not None and (tmp_path / name).exists()
+
+    def test_prune_shrinks_budget_below_floor(self, tmp_path, monkeypatch):
+        from voiceio import retention
+        from voiceio.config import DataConfig
+        monkeypatch.setattr(retention, "RECORDINGS_DIR", tmp_path)
+        monkeypatch.setattr(retention, "_free_gb", lambda p: 1.0)
+        for i in range(4):
+            (tmp_path / f"r{i}.wav").write_bytes(b"x" * 1000)
+        retention.prune(DataConfig(max_audio_mb=1024, min_free_gb=5.0))
+        # Budget halved from 4000 bytes total → keep <= 2000 bytes
+        remaining = sum(p.stat().st_size for p in tmp_path.glob("*.wav"))
+        assert remaining <= 2000