python-voiceio 1.2.0__tar.gz → 1.4.0__tar.gz

{python_voiceio-1.2.0/python_voiceio.egg-info → python_voiceio-1.4.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 1.2.0
+Version: 1.4.0
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT
-Project-URL: Homepage, https://github.com/Hugo0/voiceio
+Project-URL: Homepage, https://voiceio.dev/
 Project-URL: Repository, https://github.com/Hugo0/voiceio
 Project-URL: Issues, https://github.com/Hugo0/voiceio/issues
 Project-URL: Changelog, https://github.com/Hugo0/voiceio/releases
@@ -58,7 +58,7 @@ Dynamic: license-file
 [![Python](https://img.shields.io/pypi/pyversions/python-voiceio)](https://pypi.org/project/python-voiceio/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-**Voice dictation that learns you.** Local, open source, private — and it fine-tunes itself on your own voice, on your own machine.
+**Voice dictation that learns you.** ([website](https://voiceio.dev/)) Local, open source, private — and it fine-tunes itself on your own voice, on your own machine.
 
 Off-the-shelf speech models stumble on exactly the words you say most: your colleagues' names, your project, your jargon. voiceio keeps (with your permission) the audio of what you dictate, has a bigger model transcribe it overnight, and trains a personal model from it — nothing uploaded, no GPU required. On the author's dictation, one overnight run on a laptop CPU cut word errors from **12.1% to 5.0%** on held-out clips and recognized more of the author's vocabulary, at the same speed. Every model is scored on clips it never trained on, and it only replaces the current one when it wins.
 
@@ -182,7 +182,8 @@ Most dictation errors are proper nouns and jargon: `PostgreSQL` heard as `post g
 voiceio learn import DIR --source phone   # optional: add your own recordings from elsewhere
 voiceio learn label      # a stronger teacher model (large-v3-turbo) transcribes your clips
 voiceio learn review     # fix the teacher where it matters: your names and terms
-voiceio learn review --test   # once: verify the held-out clips, so eval scores against the truth
+voiceio learn review --test   # verify the held-out clips, so eval scores against the truth: it asks only
+                              #   where the teacher and your live decode disagree, quickest clips first
 voiceio learn augment    # synthesize extra examples of rare terms with local TTS
 voiceio learn build      # freeze a versioned train/dev/test dataset (the test split never trains)
 voiceio learn eval       # score the current model on your held-out clips: WER and term recall
@@ -190,9 +191,16 @@ voiceio learn eval       # score the current model on your held-out clips: WER a
 voiceio learn train      # LoRA fine-tune (needs the `train` extra; decoder-only on CPU, --full on a GPU)
 voiceio learn promote <run>   # dictate with the fine-tune; `voiceio learn rollback` undoes it
 voiceio learn maintain   # later: label what's new, and once 50+ clips piled up, retrain and compare
-voiceio learn schedule on   # …or let it run `maintain` every night, and notify you when a model wins
+voiceio learn schedule on   # …or let it run `maintain` on a schedule, and notify you when a model wins
+                            #   --at 02:00 --every week: when (default daily at 03:30)
+                            #   --auto-promote: switch to a winner by itself; `learn rollback` undoes it
+voiceio learn stop          # stop a run in progress (it goes again next time)
 ```
 
+Scheduled runs wait for a quiet machine: they start only when the 1-minute load per CPU is at most `[learn] max_load` (0.25) and you're on mains power, and give up after `wait_hours` (3) until the next run. When one starts you get a notification with **Stop for now** and **Weekly instead**.
+
+To keep a second machine (say, the server your phone dictates through) on the same model, set `[learn] on_promote = "scripts/push_model.sh HOST"`: after every switch it copies the model there and flips a `current` link the server points at.
+
 Labeling, training and offline eval run in an idle-priority cgroup, so they never slow dictation down. Everything stays on your machine unless you choose `train --remote`.
 
 `voiceio learn status` shows where you are, each model's scores, and suggests `promote` only when a fine-tune wins on everything. `promote` itself refuses a model that hasn't, and reports how many clips got better or worse with a confidence interval — a few dozen test clips can move an average by luck.
@@ -300,8 +308,6 @@ Logs: `journalctl --user -u voiceio` or `~/.local/state/voiceio/voiceio.log`.
 
 ## Roadmap
 
-- **A landing page** — voiceio as local, open-source, private dictation that learns from you. A draft is in [`site/index.html`](site/index.html), ready for GitHub Pages.
-- **Hands-off promotion** — `learn schedule` already retrains nightly and tells you when a model wins; next is switching to it automatically, with one-command rollback.
 - **Unbounded vocabulary** — move to a decoder whose biasing has no token cap (see [model choice](CONTRIBUTING.md#model-choice-why-whisper-and-what-would-change-it)).
 - **One model everywhere** — sync your fine-tune to your phone server and laptops, peer to peer.
 

{python_voiceio-1.2.0 → python_voiceio-1.4.0}/README.md

@@ -5,7 +5,7 @@
 [![Python](https://img.shields.io/pypi/pyversions/python-voiceio)](https://pypi.org/project/python-voiceio/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-**Voice dictation that learns you.** Local, open source, private — and it fine-tunes itself on your own voice, on your own machine.
+**Voice dictation that learns you.** ([website](https://voiceio.dev/)) Local, open source, private — and it fine-tunes itself on your own voice, on your own machine.
 
 Off-the-shelf speech models stumble on exactly the words you say most: your colleagues' names, your project, your jargon. voiceio keeps (with your permission) the audio of what you dictate, has a bigger model transcribe it overnight, and trains a personal model from it — nothing uploaded, no GPU required. On the author's dictation, one overnight run on a laptop CPU cut word errors from **12.1% to 5.0%** on held-out clips and recognized more of the author's vocabulary, at the same speed. Every model is scored on clips it never trained on, and it only replaces the current one when it wins.
 
@@ -129,7 +129,8 @@ Most dictation errors are proper nouns and jargon: `PostgreSQL` heard as `post g
 voiceio learn import DIR --source phone   # optional: add your own recordings from elsewhere
 voiceio learn label      # a stronger teacher model (large-v3-turbo) transcribes your clips
 voiceio learn review     # fix the teacher where it matters: your names and terms
-voiceio learn review --test   # once: verify the held-out clips, so eval scores against the truth
+voiceio learn review --test   # verify the held-out clips, so eval scores against the truth: it asks only
+                              #   where the teacher and your live decode disagree, quickest clips first
 voiceio learn augment    # synthesize extra examples of rare terms with local TTS
 voiceio learn build      # freeze a versioned train/dev/test dataset (the test split never trains)
 voiceio learn eval       # score the current model on your held-out clips: WER and term recall
@@ -137,9 +138,16 @@ voiceio learn eval       # score the current model on your held-out clips: WER a
 voiceio learn train      # LoRA fine-tune (needs the `train` extra; decoder-only on CPU, --full on a GPU)
 voiceio learn promote <run>   # dictate with the fine-tune; `voiceio learn rollback` undoes it
 voiceio learn maintain   # later: label what's new, and once 50+ clips piled up, retrain and compare
-voiceio learn schedule on   # …or let it run `maintain` every night, and notify you when a model wins
+voiceio learn schedule on   # …or let it run `maintain` on a schedule, and notify you when a model wins
+                            #   --at 02:00 --every week: when (default daily at 03:30)
+                            #   --auto-promote: switch to a winner by itself; `learn rollback` undoes it
+voiceio learn stop          # stop a run in progress (it goes again next time)
 ```
 
+Scheduled runs wait for a quiet machine: they start only when the 1-minute load per CPU is at most `[learn] max_load` (0.25) and you're on mains power, and give up after `wait_hours` (3) until the next run. When one starts you get a notification with **Stop for now** and **Weekly instead**.
+
+To keep a second machine (say, the server your phone dictates through) on the same model, set `[learn] on_promote = "scripts/push_model.sh HOST"`: after every switch it copies the model there and flips a `current` link the server points at.
+
 Labeling, training and offline eval run in an idle-priority cgroup, so they never slow dictation down. Everything stays on your machine unless you choose `train --remote`.
 
 `voiceio learn status` shows where you are, each model's scores, and suggests `promote` only when a fine-tune wins on everything. `promote` itself refuses a model that hasn't, and reports how many clips got better or worse with a confidence interval — a few dozen test clips can move an average by luck.
@@ -247,8 +255,6 @@ Logs: `journalctl --user -u voiceio` or `~/.local/state/voiceio/voiceio.log`.
 
 ## Roadmap
 
-- **A landing page** — voiceio as local, open-source, private dictation that learns from you. A draft is in [`site/index.html`](site/index.html), ready for GitHub Pages.
-- **Hands-off promotion** — `learn schedule` already retrains nightly and tells you when a model wins; next is switching to it automatically, with one-command rollback.
 - **Unbounded vocabulary** — move to a decoder whose biasing has no token cap (see [model choice](CONTRIBUTING.md#model-choice-why-whisper-and-what-would-change-it)).
 - **One model everywhere** — sync your fine-tune to your phone server and laptops, peer to peer.
 

{python_voiceio-1.2.0 → python_voiceio-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "1.2.0"
+version = "1.4.0"
 description = "Voice dictation for Linux. Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"
@@ -58,7 +58,7 @@ sherpa = ["sherpa-onnx>=1.12"]
 dev = ["pytest>=7.0", "pytest-mock", "ruff>=0.15,<0.18"]
 
 [project.urls]
-Homepage = "https://github.com/Hugo0/voiceio"
+Homepage = "https://voiceio.dev/"
 Repository = "https://github.com/Hugo0/voiceio"
 Issues = "https://github.com/Hugo0/voiceio/issues"
 Changelog = "https://github.com/Hugo0/voiceio/releases"

{python_voiceio-1.2.0 → python_voiceio-1.4.0/python_voiceio.egg-info}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 1.2.0
+Version: 1.4.0
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT
-Project-URL: Homepage, https://github.com/Hugo0/voiceio
+Project-URL: Homepage, https://voiceio.dev/
 Project-URL: Repository, https://github.com/Hugo0/voiceio
 Project-URL: Issues, https://github.com/Hugo0/voiceio/issues
 Project-URL: Changelog, https://github.com/Hugo0/voiceio/releases
@@ -58,7 +58,7 @@ Dynamic: license-file
 [![Python](https://img.shields.io/pypi/pyversions/python-voiceio)](https://pypi.org/project/python-voiceio/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-**Voice dictation that learns you.** Local, open source, private — and it fine-tunes itself on your own voice, on your own machine.
+**Voice dictation that learns you.** ([website](https://voiceio.dev/)) Local, open source, private — and it fine-tunes itself on your own voice, on your own machine.
 
 Off-the-shelf speech models stumble on exactly the words you say most: your colleagues' names, your project, your jargon. voiceio keeps (with your permission) the audio of what you dictate, has a bigger model transcribe it overnight, and trains a personal model from it — nothing uploaded, no GPU required. On the author's dictation, one overnight run on a laptop CPU cut word errors from **12.1% to 5.0%** on held-out clips and recognized more of the author's vocabulary, at the same speed. Every model is scored on clips it never trained on, and it only replaces the current one when it wins.
 
@@ -182,7 +182,8 @@ Most dictation errors are proper nouns and jargon: `PostgreSQL` heard as `post g
 voiceio learn import DIR --source phone   # optional: add your own recordings from elsewhere
 voiceio learn label      # a stronger teacher model (large-v3-turbo) transcribes your clips
 voiceio learn review     # fix the teacher where it matters: your names and terms
-voiceio learn review --test   # once: verify the held-out clips, so eval scores against the truth
+voiceio learn review --test   # verify the held-out clips, so eval scores against the truth: it asks only
+                              #   where the teacher and your live decode disagree, quickest clips first
 voiceio learn augment    # synthesize extra examples of rare terms with local TTS
 voiceio learn build      # freeze a versioned train/dev/test dataset (the test split never trains)
 voiceio learn eval       # score the current model on your held-out clips: WER and term recall
@@ -190,9 +191,16 @@ voiceio learn eval       # score the current model on your held-out clips: WER a
 voiceio learn train      # LoRA fine-tune (needs the `train` extra; decoder-only on CPU, --full on a GPU)
 voiceio learn promote <run>   # dictate with the fine-tune; `voiceio learn rollback` undoes it
 voiceio learn maintain   # later: label what's new, and once 50+ clips piled up, retrain and compare
-voiceio learn schedule on   # …or let it run `maintain` every night, and notify you when a model wins
+voiceio learn schedule on   # …or let it run `maintain` on a schedule, and notify you when a model wins
+                            #   --at 02:00 --every week: when (default daily at 03:30)
+                            #   --auto-promote: switch to a winner by itself; `learn rollback` undoes it
+voiceio learn stop          # stop a run in progress (it goes again next time)
 ```
 
+Scheduled runs wait for a quiet machine: they start only when the 1-minute load per CPU is at most `[learn] max_load` (0.25) and you're on mains power, and give up after `wait_hours` (3) until the next run. When one starts you get a notification with **Stop for now** and **Weekly instead**.
+
+To keep a second machine (say, the server your phone dictates through) on the same model, set `[learn] on_promote = "scripts/push_model.sh HOST"`: after every switch it copies the model there and flips a `current` link the server points at.
+
 Labeling, training and offline eval run in an idle-priority cgroup, so they never slow dictation down. Everything stays on your machine unless you choose `train --remote`.
 
 `voiceio learn status` shows where you are, each model's scores, and suggests `promote` only when a fine-tune wins on everything. `promote` itself refuses a model that hasn't, and reports how many clips got better or worse with a confidence interval — a few dozen test clips can move an average by luck.
@@ -300,8 +308,6 @@ Logs: `journalctl --user -u voiceio` or `~/.local/state/voiceio/voiceio.log`.
 
 ## Roadmap
 
-- **A landing page** — voiceio as local, open-source, private dictation that learns from you. A draft is in [`site/index.html`](site/index.html), ready for GitHub Pages.
-- **Hands-off promotion** — `learn schedule` already retrains nightly and tells you when a model wins; next is switching to it automatically, with one-command rollback.
 - **Unbounded vocabulary** — move to a decoder whose biasing has no token cap (see [model choice](CONTRIBUTING.md#model-choice-why-whisper-and-what-would-change-it)).
 - **One model everywhere** — sync your fine-tune to your phone server and laptops, peer to peer.
 

{python_voiceio-1.2.0 → python_voiceio-1.4.0}/python_voiceio.egg-info/SOURCES.txt

@@ -37,6 +37,7 @@ tests/test_learn_clean.py
 tests/test_learn_import.py
 tests/test_learn_metrics.py
 tests/test_learn_pipeline.py
+tests/test_learn_quiet.py
 tests/test_learn_review.py
 tests/test_learn_targets.py
 tests/test_llm.py
@@ -144,6 +145,7 @@ voiceio/learn/clean.py
 voiceio/learn/evaluate.py
 voiceio/learn/importer.py
 voiceio/learn/metrics.py
+voiceio/learn/quiet.py
 voiceio/learn/review.py
 voiceio/learn/store.py
 voiceio/learn/teacher.py

{python_voiceio-1.2.0 → python_voiceio-1.4.0}/tests/test_health.py

@@ -121,5 +121,5 @@ def test_learning_status_and_tips(monkeypatch):
     cfg.model.name = str(learn_dir() / "models" / "v0001-small-x" / "ct2")
     st = _learning_status(cfg)
     assert st["Voice model"] == "fine-tuned on you (v0001-small-x)"
-    assert st["Recordings"].startswith("on (") and st["Nightly learning"] == "off"
+    assert st["Recordings"].startswith("on (") and st["Scheduled learning"] == "off"
     assert any("learn schedule on" in t for t in _accuracy_tips(st))

{python_voiceio-1.2.0 → python_voiceio-1.4.0}/tests/test_learn_pipeline.py

@@ -132,14 +132,34 @@ def test_learn_jobs_reexec_into_an_idle_scope(monkeypatch):
 
 
 def test_promotion_requires_a_winning_eval():
-    base = {"wer": 0.10, "term_recall": 0.40, "repetitions": 0}
-    better = {"wer": 0.101, "term_recall": 0.70, "repetitions": 0}   # vocab win, WER within slack
-    worse = {"wer": 0.13, "term_recall": 0.70, "repetitions": 0}
+    base = {"wer": 0.10, "term_recall": 0.40, "repetitions": 0, "clips": 44}
+    better = {"wer": 0.101, "term_recall": 0.70, "repetitions": 0, "clips": 44}   # vocab win
+    worse = {"wer": 0.13, "term_recall": 0.70, "repetitions": 0, "clips": 44}
     assert evaluate.promotion_verdict(better, base)[0]
     assert not evaluate.promotion_verdict(worse, base)[0]
     assert not evaluate.promotion_verdict({**better, "repetitions": 2}, base)[0]
 
 
+def test_no_promotion_without_evidence():
+    """A crashed decode scores 0% WER; an empty test split scores nothing."""
+    base = {"wer": 0.10, "term_recall": 0.40, "repetitions": 0, "clips": 44}
+    perfect = {"wer": 0.0, "term_recall": 1.0, "repetitions": 0}
+    assert not evaluate.promotion_verdict({**perfect, "clips": 44, "failures": 3}, base)[0]
+    assert not evaluate.promotion_verdict({**perfect, "clips": 40}, base)[0]      # other clips
+    assert not evaluate.promotion_verdict({**perfect, "clips": 2}, {**base, "clips": 2})[0]
+
+
+def test_latest_finds_runs_at_the_configured_beam():
+    runs = store.learn_dir() / "runs"
+    runs.mkdir(parents=True)
+    for i, (dec, wer) in enumerate([("faster-whisper:small", 5), ("faster-whisper:small@beam2+draft", 2)]):
+        (runs / f"eval-2026010{i}.json").write_text(json.dumps(
+            {"decoder": dec, "dataset": "v0001", "wer": wer, "metrics": metrics.METRICS_VERSION}))
+    assert evaluate.latest("small", "v0001")["wer"] == 5
+    assert evaluate.latest("small", "v0001", beam=2)["wer"] == 2
+    assert evaluate.latest("small", "v0001", beam=1) is None
+
+
 def test_latest_eval_matches_model_dataset_and_mode():
     runs = store.learn_dir() / "runs"
     runs.mkdir(parents=True)
@@ -308,3 +328,58 @@ def test_wait_summary_p90_never_exceeds_max():
     s = r.wait_summary()
     p90 = float(s.split("p90 ")[1].split("s")[0])
     assert p90 <= 6.83
+
+
+def test_maintain_auto_promote_switches_restarts_and_says_how_to_undo(monkeypatch):
+    import argparse
+    from types import SimpleNamespace
+
+    from voiceio import feedback, service
+    from voiceio.cli import learn as cli
+    from voiceio.learn import evaluate
+    for i in range(3):
+        _clip(f"{i}.wav", 3, "x")
+        store.add_label(f"{i}.wav", [Segment(0, 3, "hello there")], "teacher:fake")
+    run = store.learn_dir() / "models" / "v0001-small-x"
+    calls = []
+    monkeypatch.setattr(cli, "cmd_label", lambda a: None)
+    monkeypatch.setattr(cli, "_announce_learning", lambda min_new: None)
+    monkeypatch.setattr(train, "missing_train_deps", lambda: [])
+    monkeypatch.setattr(cli, "_run_eval", lambda *a, **k: SimpleNamespace(
+        wer=0.1, term_recall=0.5, repetitions=0, per_clip=[]))
+    monkeypatch.setattr(cli, "_train", lambda *a, **k: run)
+    monkeypatch.setattr(evaluate, "promotion_verdict", lambda c, b: (True, "table"))
+    monkeypatch.setattr(cli, "cmd_promote", lambda a: calls.append(("promote", a.run)))
+    monkeypatch.setattr(service, "is_installed", lambda: True)
+    monkeypatch.setattr(service, "restart_when_idle", lambda: calls.append(("restart",)) or True)
+    monkeypatch.setattr(feedback, "notify", lambda t, b, urgent=False: calls.append(("notify", b)))
+
+    cli.cmd_maintain(argparse.Namespace(min_new=1, base="small", epochs=1, auto_promote=True))
+    assert calls[:2] == [("promote", "v0001-small-x"), ("restart",)]
+    assert "voiceio learn rollback" in calls[2][1]
+
+    # The gate's own re-check refuses: no restart, no "switched" notification,
+    # and no crash (the nightly unit must not fail).
+    calls.clear()
+
+    def refuse(a):
+        raise SystemExit("evaluate both models first")
+    monkeypatch.setattr(cli, "cmd_promote", refuse)
+    cli.cmd_maintain(argparse.Namespace(min_new=1, base="small", epochs=1, auto_promote=True))
+    assert calls == []
+
+
+def test_promote_and_rollback_run_on_promote_with_the_model(monkeypatch, tmp_path):
+    import argparse
+
+    from voiceio import config
+    from voiceio.cli import learn as cli
+    run = store.learn_dir() / "models" / "v0002-small-x" / "ct2"
+    run.mkdir(parents=True)
+    (run / "model.bin").write_text("")
+    out = tmp_path / "hook.txt"
+    config.CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    config.CONFIG_PATH.write_text(f'[learn]\non_promote = "echo $VOICEIO_MODEL >> {out}"\n')
+    cli.cmd_promote(argparse.Namespace(run="v0002-small-x", force=True))
+    cli.cmd_rollback(argparse.Namespace())
+    assert out.read_text().split() == [str(run), "small"]

python_voiceio-1.4.0/tests/test_learn_quiet.py

@@ -0,0 +1,102 @@
+import argparse
+
+from voiceio.learn import quiet
+
+
+def _supply(root, name, kind, online):
+    d = root / name
+    d.mkdir()
+    (d / "type").write_text(kind + "\n")
+    (d / "online").write_text(online + "\n")
+
+
+def test_on_battery_needs_a_mains_supply_that_is_offline(tmp_path):
+    assert not quiet.on_battery(tmp_path)                 # desktop: no supplies listed
+    _supply(tmp_path, "BAT0", "Battery", "0")
+    _supply(tmp_path, "AC", "Mains", "0")
+    assert quiet.on_battery(tmp_path)
+    (tmp_path / "AC" / "online").write_text("1\n")
+    assert not quiet.on_battery(tmp_path)
+
+
+def test_busy_reason_is_load_per_cpu_then_battery(monkeypatch):
+    monkeypatch.setattr(quiet.os, "cpu_count", lambda: 8)
+    monkeypatch.setattr(quiet, "on_battery", lambda: False)
+    monkeypatch.setattr(quiet.os, "getloadavg", lambda: (4.0, 0, 0))     # 0.5 per CPU
+    assert "load 0.50 per CPU" in quiet.busy_reason(0.25)
+    monkeypatch.setattr(quiet.os, "getloadavg", lambda: (1.0, 0, 0))
+    assert quiet.busy_reason(0.25) is None
+    monkeypatch.setattr(quiet, "on_battery", lambda: True)
+    assert quiet.busy_reason(0.25) == "on battery"
+
+
+def test_wait_until_quiet_waits_then_gives_up(monkeypatch):
+    now = [0.0]
+    sleeps = []
+    reasons = iter(["busy", "busy", None])
+    monkeypatch.setattr(quiet, "busy_reason", lambda _: next(reasons))
+    args = dict(poll=300, sleep=lambda s: (sleeps.append(s), now.__setitem__(0, now[0] + s)),
+                clock=lambda: now[0], say=lambda _: None)
+    assert quiet.wait_until_quiet(0.25, 3, **args)
+    assert sleeps == [300, 300]
+
+    monkeypatch.setattr(quiet, "busy_reason", lambda _: "on battery")
+    said = []
+    now[0] = 0.0
+    assert not quiet.wait_until_quiet(0.25, 1, **{**args, "say": said.append})
+    assert now[0] <= 3600 and said[-1].startswith("still on battery after 1 h")
+
+
+def test_scheduled_maintain_waits_for_a_quiet_machine(monkeypatch):
+    from voiceio.cli import learn as cli
+    monkeypatch.setattr(cli, "_yield_cpu", lambda: None)
+    monkeypatch.setattr(quiet, "wait_until_quiet", lambda *a, **k: False)
+    ran = []
+    monkeypatch.setattr(cli, "cmd_label", lambda a: ran.append("label"))
+    cli.cmd_maintain(argparse.Namespace(min_new=5, base="small", epochs=1, when_idle=True))
+    assert ran == []                                      # busy all night: nothing ran
+
+
+def test_learning_announcement_offers_stop_and_weekly(monkeypatch, tmp_path):
+    from voiceio import feedback
+    from voiceio.cli import learn as cli
+    sent = []
+    monkeypatch.setattr(feedback, "notify_actions", lambda *a: sent.append(a))
+    monkeypatch.setattr(cli.store, "load_labels", lambda: {})
+    monkeypatch.setattr(cli.store, "clips", lambda: [argparse.Namespace(audio=f"a{i}.wav") for i in range(3)])
+    monkeypatch.setattr(cli.store, "latest_dataset", lambda: None)
+    cli._announce_learning(min_new=50)
+    (title, body, actions, _), = sent
+    assert "learning" in title and body.startswith("Labeling 3 new recordings,")
+    assert "on this computer" in body and set(actions) == {"stop", "weekly"}
+
+    sent.clear()
+    monkeypatch.setattr(cli.store, "load_labels", lambda: {f"a{i}.wav": 1 for i in range(3)})
+    monkeypatch.setattr(cli.store, "latest_dataset", lambda: tmp_path)
+    monkeypatch.setattr(cli.store, "dataset_clips", lambda _: {f"a{i}.wav" for i in range(3)})
+    cli._announce_learning(min_new=50)
+    assert sent == []                                     # nothing to do: no notification
+
+
+def test_notify_actions_runs_the_picked_action(monkeypatch):
+    import subprocess
+
+    from voiceio import feedback
+    monkeypatch.setattr("sys.platform", "linux")
+    monkeypatch.setattr(feedback, "_which", lambda _: "/usr/bin/notify-send")
+    monkeypatch.setattr(feedback, "_notify_send_has_actions", lambda: True)
+    calls = []
+
+    def fake_run(args, **kw):
+        calls.append(args)
+        return subprocess.CompletedProcess(args, 0, stdout="weekly\n")
+    monkeypatch.setattr(feedback.subprocess, "run", fake_run)
+    picked = []
+
+    class Now:   # run the waiting thread inline
+        def __init__(self, target, daemon): self.target = target
+        def start(self): self.target()
+    monkeypatch.setattr(feedback.threading, "Thread", Now)
+    feedback.notify_actions("t", "b", {"stop": "Stop", "weekly": "Weekly"}, picked.append)
+    assert picked == ["weekly"]
+    assert "--wait" in calls[0] and "--action=stop=Stop" in calls[0]

python_voiceio-1.4.0/tests/test_learn_review.py

@@ -0,0 +1,44 @@
+
+
+def test_queue_all_covers_every_segment_of_unreviewed_clips():
+    from voiceio.learn import review
+    from voiceio.learn.store import Clip, Label, Segment
+    a = Clip("a.wav", 0, 4, "", "")
+    b = Clip("b.wav", 0, 4, "", "")
+    segs = (Segment(0, 2, "one"), Segment(2, 4, "two"))
+    labels = {"a.wav": Label("a.wav", segs, "teacher:x", 0),
+              "b.wav": Label("b.wav", segs, "human", 0)}
+    items = review.queue_all([a, b], labels)
+    assert [(i.clip.audio, i.index) for i in items] == [("a.wav", 0), ("a.wav", 1)]
+
+
+def test_live_span_shows_the_live_decode_only_where_it_differs():
+    from voiceio.learn.review import live_span
+    live = "okay so we use kalchi daily and then more stuff"
+    assert live_span("We use Kalshi daily.", live) == "we use kalchi daily"
+    assert live_span("We use Kalshi daily.", "so we use Kalshi daily ok") is None
+    assert live_span("totally different words here", "nothing alike at all") is None
+
+
+def test_gold_review_asks_only_where_the_models_disagree_cheapest_clip_first():
+    from voiceio.learn import review
+    from voiceio.learn.store import Clip, Label, Segment
+    segs = (Segment(0, 2, "we use Kalshi daily"), Segment(2, 4, "ship it today"))
+    two = Clip("two.wav", 0, 4, "we use kalchi daily ship it to day", "")
+    one = Clip("one.wav", 0, 4, "we use kalchi daily ship it today", "")
+    agree = Clip("agree.wav", 0, 4, "we use Kalshi daily ship it today", "")
+    labels = {c.audio: Label(c.audio, segs, "teacher:x", 0) for c in (two, one, agree)}
+    items = review.queue_all([two, one, agree], labels)
+    assert [(i.clip.audio, i.index) for i in items] == [
+        ("one.wav", 0),                       # one answer completes a gold clip
+        ("two.wav", 0), ("two.wav", 1),
+    ]                                         # agree.wav: nothing to ask
+
+
+def test_gold_review_counts_one_misheard_term_as_disagreement():
+    from voiceio.learn import review
+    from voiceio.learn.store import Clip, Label, Segment
+    segs = (Segment(0, 4, "we ship the Kalshi bot every single day"),)
+    clip = Clip("a.wav", 0, 4, "we ship the kalchi bot every single day", "")
+    items = review.queue_all([clip], {"a.wav": Label("a.wav", segs, "teacher:x", 0)})
+    assert len(items) == 1

python_voiceio-1.4.0/tests/test_service.py

@@ -0,0 +1,116 @@
+import sys
+from pathlib import Path
+
+from voiceio import service
+
+
+def test_install_symlinks_relinks_and_drops_legacy(monkeypatch, tmp_path):
+    venv_bin = tmp_path / "venv" / "bin"
+    venv_bin.mkdir(parents=True)
+    for name in service.SCRIPT_NAMES:
+        (venv_bin / name).write_text("#!/bin/sh\n")
+    old = tmp_path / "old"
+    old.mkdir()
+    local_bin = tmp_path / "local-bin"
+    local_bin.mkdir()
+    (local_bin / "voiceio").symlink_to(old / "voiceio")        # stale install
+    (local_bin / "voiceio-doctor").symlink_to(old / "voiceio-doctor")
+    monkeypatch.setattr(service, "LOCAL_BIN", local_bin)
+    monkeypatch.setattr(sys, "prefix", str(tmp_path / "venv"))
+    monkeypatch.setattr(service, "_is_pipx_install", lambda: False)
+    monkeypatch.setattr(service, "_local_bin_on_path", lambda: True)
+
+    assert service.install_symlinks() == service.SCRIPT_NAMES
+    assert Path(local_bin / "voiceio").resolve() == (venv_bin / "voiceio").resolve()
+    assert not (local_bin / "voiceio-doctor").is_symlink()
+
+
+def test_learn_timer_runs_maintain_at_idle_priority(monkeypatch, tmp_path):
+    calls = []
+    monkeypatch.setattr(service, "has_systemd", lambda: True)
+    monkeypatch.setattr(service, "_systemctl", lambda *a: calls.append(a) or True)
+    monkeypatch.setattr(service, "_find_voiceio_bin", lambda: "/opt/v/bin/voiceio")
+    monkeypatch.setattr(service, "SERVICE_DIR", tmp_path)
+    monkeypatch.setattr(service, "LEARN_SERVICE_PATH", tmp_path / service.LEARN_SERVICE_NAME)
+    monkeypatch.setattr(service, "LEARN_TIMER_PATH", tmp_path / service.LEARN_TIMER_NAME)
+
+    assert service.install_learn_timer()
+    unit = service.LEARN_SERVICE_PATH.read_text()
+    assert "ExecStart=/opt/v/bin/voiceio learn maintain --when-idle" in unit
+    assert "CPUWeight=idle" in unit and "VOICEIO_IDLE_SCOPE=1" in unit
+    assert "Persistent=true" in service.LEARN_TIMER_PATH.read_text()
+    assert ("enable", "--now", service.LEARN_TIMER_NAME) in calls
+
+    service.uninstall_learn_timer()
+    assert not service.LEARN_TIMER_PATH.exists() and not service.LEARN_SERVICE_PATH.exists()
+
+
+def test_daemon_publishes_state_and_restart_waits_for_idle(monkeypatch):
+    import threading
+
+    from voiceio import config, pidlock
+    from voiceio.app import VoiceIO, _State
+    from voiceio.cli.servicecmd import wait_until_idle
+
+    vio = VoiceIO.__new__(VoiceIO)
+    vio._state = _State.RECORDING                      # not the lock holder:
+    assert not config.STATE_PATH.exists()              # says nothing
+    vio._publishes_state = True
+    vio._state = _State.RECORDING
+    assert config.STATE_PATH.read_text() == "recording"
+
+    monkeypatch.setattr(pidlock, "daemon_alive", lambda path: False)
+    assert wait_until_idle(timeout=5)                  # dead daemon: stale file, no wait
+    monkeypatch.setattr(pidlock, "daemon_alive", lambda path: True)
+    threading.Timer(0.3, lambda: setattr(vio, "_state", _State.IDLE)).start()
+    assert wait_until_idle(timeout=5, poll=0.05)       # waited for the dictation
+    vio._state = _State.FINALIZING                     # a hung finalize: short budget
+    assert not wait_until_idle(timeout=60, poll=0.05, finalizing_timeout=0.2)
+
+
+def test_daemon_alive_probes_the_pid_lock(tmp_path):
+    import fcntl
+
+    from voiceio.pidlock import daemon_alive
+    path = tmp_path / "voiceio.pid"
+    assert not daemon_alive(path)
+    with open(path, "a") as held:
+        fcntl.flock(held, fcntl.LOCK_EX)
+        assert daemon_alive(path)
+    assert not daemon_alive(path)
+
+
+def test_learn_timer_auto_promote_is_opt_in(monkeypatch, tmp_path):
+    monkeypatch.setattr(service, "has_systemd", lambda: True)
+    monkeypatch.setattr(service, "_systemctl", lambda *a: True)
+    monkeypatch.setattr(service, "_find_voiceio_bin", lambda: "voiceio")
+    monkeypatch.setattr(service, "LEARN_SERVICE_PATH", tmp_path / "s.service")
+    monkeypatch.setattr(service, "LEARN_TIMER_PATH", tmp_path / "s.timer")
+    service.install_learn_timer()
+    assert not service.learn_timer_auto_promotes()
+    service.install_learn_timer(auto_promote=True)
+    assert "learn maintain --when-idle --auto-promote" in service.LEARN_SERVICE_PATH.read_text()
+    assert service.learn_timer_auto_promotes()
+
+
+def test_learn_schedule_comes_from_config(monkeypatch, tmp_path):
+    import pytest
+
+    from voiceio import config
+    monkeypatch.setattr(service, "has_systemd", lambda: True)
+    monkeypatch.setattr(service, "_systemctl", lambda *a: True)
+    monkeypatch.setattr(service, "_find_voiceio_bin", lambda: "voiceio")
+    monkeypatch.setattr(service, "LEARN_SERVICE_PATH", tmp_path / "s.service")
+    monkeypatch.setattr(service, "LEARN_TIMER_PATH", tmp_path / "s.timer")
+    service.install_learn_timer()
+    assert "OnCalendar=*-*-* 03:30" in service.LEARN_TIMER_PATH.read_text()
+
+    config.set_value("learn", "at", "2:05")
+    config.set_value("learn", "every", "week")
+    service.install_learn_timer()
+    assert "OnCalendar=Sun *-*-* 02:05" in service.LEARN_TIMER_PATH.read_text()
+    assert service.learn_schedule_summary() == "weekly on Sunday at 2:05"
+
+    for at, every in (("25:00", "day"), ("3pm", "day"), ("03:30", "month")):
+        with pytest.raises(ValueError):
+            service.learn_calendar(at, every)

python_voiceio-1.4.0/voiceio/__init__.py

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

{python_voiceio-1.2.0 → python_voiceio-1.4.0}/voiceio/app.py

@@ -43,6 +43,10 @@ class VoiceIO:
     @_state.setter
     def _state(self, value: _State) -> None:
         self.__state = value
+        # Only the instance holding the PID lock speaks for the daemon: a
+        # second launch must not overwrite the running one's state.
+        if not getattr(self, "_publishes_state", False):
+            return
         try:   # best-effort: only `service restart` reads it
             tmp = config.STATE_PATH.with_suffix(".tmp")
             tmp.write_text(value.value)
@@ -660,7 +664,7 @@ class VoiceIO:
         self._typers.redetect_at_start()
 
         LOG_DIR.mkdir(parents=True, exist_ok=True)
-        self._pid_fd = open(PID_PATH, "w")
+        self._pid_fd = open(PID_PATH, "a")   # not "w": the running daemon's PID stays
         try:
             from voiceio.pidlock import lock_pid_file
             lock_pid_file(self._pid_fd)
@@ -669,8 +673,11 @@ class VoiceIO:
             log.error("Another voiceio instance is already running")
             print("voiceio is already running. Stop it first: voiceio service stop")
             return
+        self._pid_fd.truncate(0)
         self._pid_fd.write(str(os.getpid()))
         self._pid_fd.flush()
+        self._publishes_state = True
+        self._state = self._state
 
         self._typers.prepare()