python-voiceio 1.9.2__py3-none-any.whl → 1.9.3__py3-none-any.whl

{python_voiceio-1.9.2.dist-info → python_voiceio-1.9.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 1.9.2
+Version: 1.9.3
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT
@@ -98,7 +98,7 @@ voiceio learn schedule on             # learn from your recordings while the mac
 voiceio learn status                  # what it learned and how each model scores
 ```
 
-Scheduled learning runs daily or weekly at a time you pick, only on an idle machine on mains power, with a notification you can stop. It never switches models unless the new one wins, and `voiceio learn rollback` undoes a switch. Details: [docs/learning.md](docs/learning.md).
+Scheduled learning runs daily or weekly at a time you pick, on mains power and only while you're away from the computer: it stops within seconds when you come back and resumes later where it was. You get a notification with a button to stop it. It never switches models unless the new one wins, and `voiceio learn rollback` undoes a switch. Details: [docs/learning.md](docs/learning.md).
 
 ## Configure
 

{python_voiceio-1.9.2.dist-info → python_voiceio-1.9.3.dist-info}/RECORD

@@ -1,12 +1,12 @@
-python_voiceio-1.9.2.dist-info/licenses/LICENSE,sha256=Gz61o8jFTAvZUZyB3nWDB3DQQVuipjfPkVu9W8hBHM0,1072
-voiceio/__init__.py,sha256=FTcek0yfdI0OEbhOiGIFqV7WG2mj3gjw9X-8TnopjBM,22
+python_voiceio-1.9.3.dist-info/licenses/LICENSE,sha256=Gz61o8jFTAvZUZyB3nWDB3DQQVuipjfPkVu9W8hBHM0,1072
+voiceio/__init__.py,sha256=ZYlCJvbc_dIjUJ4oc5xuJBjjOfmrYgkggw_9VNQvlvY,22
 voiceio/__main__.py,sha256=xT5QCGGreYMisHO7Lh_Y-xAQ2TOzG2D7npKknGNcWSY,53
-voiceio/app.py,sha256=5tqDibXeok_psz9ewKOD47ka6ErR_Y4LD3jpOd2zZMw,43650
+voiceio/app.py,sha256=9xOLShYwBKq0M0WwBwM3LlYDii1LOOb1Pov5tvlqVlo,45140
 voiceio/audio_source.py,sha256=rR6NRtNzmZ8uqmNPxareBWTJmuBaOxIGI5QINR_l-qc,9102
 voiceio/backends.py,sha256=-rs1YhPblub4NjFb6qCD7Ih9FqBRXtPuvjVv9bQoQ1w,368
 voiceio/clipboard_read.py,sha256=7f5aX644Fiy2S6MXxADfSgRtvO3P1U-r_VkzEgWrwKQ,5376
 voiceio/commands.py,sha256=Jz-txXSw32Adf8B912M8CzQIh4UMmEKRCZBPXU4bBaU,6014
-voiceio/config.py,sha256=10TQpa-lo3TmHIpXScYpUr3AZUZ9tOsyc1B-T7hXnnk,22968
+voiceio/config.py,sha256=bA-1sNUHUL1bHXAuxfyON1g2eSJHnxSApAaAJZ2_Y0M,23302
 voiceio/consent.py,sha256=3stv3iZvYl_Dt4GUe-GUVOHEGi-2fOl-QqF3pDjraS4,1862
 voiceio/context_terms.py,sha256=rbVzEoqahroWdkYqiOmn4PJVsl6ftk_PDa-lXdoTBvA,11747
 voiceio/corrections.py,sha256=IIRViwjL9kkMy26-1dd0DtTfT0Tiedn6pmmHoaeayMQ,10047
@@ -26,12 +26,13 @@ voiceio/platform.py,sha256=uG_5KeYey_29GCn4nSOQJ1UpoCrBC_m2DR7IeoRnuL4,19142
 voiceio/postcorrect.py,sha256=JN5l9xnyGfYq2_owSUwkJ513QiQQKxCrT3hjU5aJCpg,17322
 voiceio/postprocess.py,sha256=9vpth8u2xOIKU6SimY-hsEDrs4X9YJSI67ZO_f2PpxM,6048
 voiceio/power.py,sha256=mKiG5ioHbzgtW2S-OKGFOPzZFbG0HwUUyMn8kE5JRoQ,681
+voiceio/presence.py,sha256=2zzhfDWdQHa7hCX_XB-tNxt0uybm6KYc8l9FYLYsCWo,6651
 voiceio/privacy.py,sha256=FqnA9jx9RCqWW-i6Dh7JcT7vzz97kbUGyQEvsHLvpqc,573
 voiceio/prompt.py,sha256=9iza8KoQxvO_U9NPMJ8Ep7j-zkIs9nW8N5sacCRpsEk,2904
 voiceio/quiet_audio.py,sha256=AapeuhrJwR20fsl-Ksgv4qpptrcQezk6A2_i4Kr18Ks,11451
-voiceio/recorder.py,sha256=E3YwZecJqd06GGoRSjFi2Q-7GoRzBkAMBGspKVkF9rc,16746
+voiceio/recorder.py,sha256=B_db2kijunZCIAH6cqmEFB5Zuvt3W1e8BCCaQg2EsZM,18469
 voiceio/retention.py,sha256=5ydw2dJ2gTQ39BYdg3Bk4mk-KNJkJcGUKzssndYwdY8,6137
-voiceio/service.py,sha256=q4_Mk8m3KCG14CGZ468ZrFvNvyXuWSOjKFUjRnksgAI,16391
+voiceio/service.py,sha256=0dB5vWBOhmW6fl3CZzVfHUK2zkPQYLzfSXuvaesrKfc,17402
 voiceio/streaming.py,sha256=PZoyAUVDjzdZsqQy3_XXDLdbDk7GeRHXY47hLHxSKVA,27970
 voiceio/suggest.py,sha256=jX4bCpnddyrteKfRBPbnUgf-Rk5145LFaSTat0_Ll2E,4836
 voiceio/tokens.py,sha256=y9KBDgLukUMieO576rgyBn8qEQqElra66spQwoWXDXk,6321
@@ -46,7 +47,7 @@ voiceio/cli/configcmd.py,sha256=YF7t-LkwEYEGH4qcO86xehWVX0LvltqxjDFpMF5ljjA,2858
 voiceio/cli/corrections.py,sha256=OBjgiOhtWlTQpQq0HLAvk5-EfKJ7NNt-hnNBHm7obEc,4247
 voiceio/cli/doctor.py,sha256=P8bOn4xedMistlKHhNeeGxRsmogV6jBVKc-CUbo0LXs,7769
 voiceio/cli/history.py,sha256=7FvEEgdw8jf5XXvC7-4S7iIpcjBbn7dx4czIijg61C0,2597
-voiceio/cli/learn.py,sha256=ajVP7RRFBLXa0Sf-pbYrccPpuB58oHjd4wR9JkcOwtw,32914
+voiceio/cli/learn.py,sha256=DrOenyjT9fqdWgBd8vWErkFLIKdlWb4SCmky2D_FxEs,36955
 voiceio/cli/models.py,sha256=fye_mHbsXLY11uRC1BCDlucCHPny9ftoehAeUJPMJv0,4263
 voiceio/cli/servicecmd.py,sha256=2St2WfLkt06EpC51I5i9Ykv_pvLKzu_dz01M-29O3-4,4830
 voiceio/cli/uninstall.py,sha256=Vqnq6-4hjhDrxqkU_1wtXkY5BU_Tqa-TjZA0Qpf12e4,8921
@@ -80,14 +81,14 @@ voiceio/ibus/textlimit.py,sha256=SJ5aSBYgMsCdg1SEjw6vJv03pLCqPcSeQjhSloa32R8,317
 voiceio/learn/__init__.py,sha256=Q98-C809lkMqTS0OAV1xNVtqHz9NvuekivXiHiVHBWA,750
 voiceio/learn/augment.py,sha256=qyegRlg3cQF5CT0HV85Jm93Jd9xZpjWwbFVk_VzFdiI,4105
 voiceio/learn/clean.py,sha256=1ItIfIAsqxZLZ76T4oF7kSr4Poo-z_6GEzhrlt21uMo,4922
-voiceio/learn/evaluate.py,sha256=sW2lfV9jK22fpFFgxh9p6cp0pcTt5KjXV3eatsrg9sM,13233
+voiceio/learn/evaluate.py,sha256=FwWI7A6vvKZu7u1Ex4RxQ9eV_GB6Butt61eYW_SL308,13355
 voiceio/learn/importer.py,sha256=uB-gHWwSewZYTx22j9h941ARtDE8BFHmf8p3HaHUC6g,3544
 voiceio/learn/metrics.py,sha256=b2xWUzPpNpXHn6zgS1upPbEcpW3ExH9SmSLIUzPhStQ,5174
-voiceio/learn/quiet.py,sha256=5Ov3mvE1G3CjhwFQOuJvGeju242zFASi29tketnUyew,1523
+voiceio/learn/quiet.py,sha256=mJsJRZH0KUhkVQ-Hm95n8SiuEdKOIE16pt-YU44jXDg,7083
 voiceio/learn/review.py,sha256=X5qs5yEf20Ao3gMhsbW3Eur62hSqy9AYlv08Pcrllxo,5572
-voiceio/learn/store.py,sha256=MauWhGaI2drMbiChIZOblpPS_uVAw-1sNWGyGACHYw8,12816
-voiceio/learn/teacher.py,sha256=FhCv08Js3chs4Vbh0VN3ZI9p05HFxeeeFJF8jTjjzPQ,3751
-voiceio/learn/train.py,sha256=FtZMa4ddsPMRUxkyqC-Qf9OveZmgRMHiGXx5WHj_jT8,18214
+voiceio/learn/store.py,sha256=_QXOmc6Qy_33o9Fh5P2qSf8V2I84haGZRlAa6RrNjXM,13090
+voiceio/learn/teacher.py,sha256=ZCQTklZFfgS_JywMA7lopjpAmaRsGPFnu0xIATOCobc,3778
+voiceio/learn/train.py,sha256=ad0qk_kqjTfcl_u5UWbe7E3mVCI-35NuNt-MI69U-vg,26472
 voiceio/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 voiceio/models/silero_vad.onnx,sha256=GhU6IvRQnikqlOZ9b5uF6N6yW0mIaCt-F0xlJ52HiOM,2327524
 voiceio/server/__init__.py,sha256=ybYb7CWgyMUhB-8AKypIWyMwCg17D3iNOaWOkqUd_8s,1751
@@ -101,7 +102,7 @@ voiceio/setup/extras.py,sha256=NGk_uAWl4GQAPwRfw_0nEPsPvma7ics9DnZqjoHgCUY,9685
 voiceio/setup/hotkey.py,sha256=xlDp2vWzsF73wbpvPSrwaqgjtiWnv294nzjlvHy0Ets,6473
 voiceio/setup/noninteractive.py,sha256=PF5dG6aOOYxdknbRGZD32xlv_kV2Mg8BRf_TfYI5bpY,10522
 voiceio/setup/speech.py,sha256=DahGBybPzkNryLjxtCkxojrUhECBksox2RKSwGr7a9I,7688
-voiceio/setup/steps.py,sha256=IXzP4zaeZg7EUAPNFnp1VQSbEyeW8PsKNJ6hpgfDSew,27688
+voiceio/setup/steps.py,sha256=N7E7SHTESWQWBppaFyz_6UF_5UFplcKx0EjK1p4bp1I,27695
 voiceio/setup/system.py,sha256=Cb1BJGCgGbZFAfqrS8eXRW2AKW7jNLq82DWWg4_fdAs,6019
 voiceio/setup/ui.py,sha256=h1gmerT_8EfWftSONUn5K5Ri19elNTRP2lwFAuxsGPc,13401
 voiceio/sounds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -133,8 +134,8 @@ voiceio/typers/pynput_type.py,sha256=f3w131YWJfNGd4IAcWtuKd2Gcwu3467QwGW3OBUEXNI
 voiceio/typers/wtype.py,sha256=11vOAKHjMat-fITd4sUoUWwgniyVp65EbH3i4mL6Vhg,1762
 voiceio/typers/xdotool.py,sha256=OuT_zW_z07jSAqu9Cmn_gL1mJfQsiX62ecqFRvpAarQ,1332
 voiceio/typers/ydotool.py,sha256=oY5EXB-nI7PvxTL_5Tb3JjfvyhmLNYNnUFvkb1XUn_U,5978
-python_voiceio-1.9.2.dist-info/METADATA,sha256=WXmKdOKMoP9EdCj4LE6yGCHIw3U9Vl-3p8HzZLiDn40,7519
-python_voiceio-1.9.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_voiceio-1.9.2.dist-info/entry_points.txt,sha256=iDIDmhvQ3xeN_CWsFne1t9STZ08I25I_wp0xmde_vMs,94
-python_voiceio-1.9.2.dist-info/top_level.txt,sha256=piwtn309lD6uexQyXdZ-efAVBJF9y6Wfr48Z-8zkNhg,8
-python_voiceio-1.9.2.dist-info/RECORD,,
+python_voiceio-1.9.3.dist-info/METADATA,sha256=jjNupEWDzxHL9ibmedy156_z8OqpNks44UUMOZpNuV8,7630
+python_voiceio-1.9.3.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+python_voiceio-1.9.3.dist-info/entry_points.txt,sha256=iDIDmhvQ3xeN_CWsFne1t9STZ08I25I_wp0xmde_vMs,94
+python_voiceio-1.9.3.dist-info/top_level.txt,sha256=piwtn309lD6uexQyXdZ-efAVBJF9y6Wfr48Z-8zkNhg,8
+python_voiceio-1.9.3.dist-info/RECORD,,

{python_voiceio-1.9.2.dist-info → python_voiceio-1.9.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (84.0.0)
+Generator: setuptools (84.2.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

voiceio/__init__.py

@@ -1 +1 @@
-__version__ = "1.9.2"
+__version__ = "1.9.3"

voiceio/app.py

@@ -359,6 +359,7 @@ class VoiceIO:
         rid = self._recording
         self._quiet.stop(then=lambda: self._play_record_cue(start=False))
         self.recorder.set_on_auto_stop(None)
+        self.recorder.set_on_dead_stream(None)
         self.recorder.stop()   # the audio is dropped here
         tray.set_recording(False)
         session, self._session = self._session, None
@@ -415,6 +416,35 @@ class VoiceIO:
         except Exception:
             log.exception("paste-last failed")
 
+    def _revive_mic(self, rid: int) -> None:
+        """The mic stream died mid-recording (real audio, then exact zeros):
+        reopen it and keep recording. Once it fails to come back, say so —
+        recording a dead stream to the end lost a 104 s dictation after a
+        suspend/resume."""
+        with self._hotkey_lock:
+            if self._state != _State.RECORDING or self._recording != rid:
+                return
+            log.warning("Mic stream went silent mid-recording (exact zeros) — reopening")
+            try:
+                self.recorder.revive_stream()
+            except Exception:
+                log.exception("Mic reopen failed")
+        time.sleep(1.5)
+        with self._hotkey_lock:
+            if self._state != _State.RECORDING or self._recording != rid:
+                return
+            dead = self.recorder.silent_signal_secs >= 1.0
+        if dead:
+            log.warning("Mic still silent after reopening")
+            from voiceio import feedback
+            feedback.notify(
+                "VoiceIO: microphone stopped sending audio",
+                "Your words so far are kept. Stop, check the input device, and try again.",
+                urgent=True,
+            )
+        else:
+            log.info("Mic stream recovered mid-recording")
+
     def _on_auto_stop(self, reason: str = "silence") -> None:
         """Called from the audio thread when the recorder auto-stops.
 
@@ -570,6 +600,8 @@ class VoiceIO:
         self._record_start = time.monotonic()
         self.recorder.start()
         self.recorder.set_on_auto_stop(self._on_auto_stop)
+        rid = self._recording
+        self.recorder.set_on_dead_stream(lambda: self._revive_mic(rid))
         # Ducking lowers the whole output, voiceio's chimes included: it waits
         # for the start chime to play out, and _do_stop restores the volume
         # before the stop chime plays.
@@ -598,6 +630,7 @@ class VoiceIO:
         # restore (see _do_start), off this thread.
         self._quiet.stop(then=lambda: self._play_record_cue(start=False))
         self.recorder.set_on_auto_stop(None)
+        self.recorder.set_on_dead_stream(None)
         audio = self.recorder.stop()
         tray.set_recording(False)
         self._idle_audio.touch()

voiceio/cli/learn.py

@@ -87,8 +87,9 @@ def register(sub: argparse._SubParsersAction) -> None:
     mt.add_argument("--auto-promote", action="store_true",
                     help="switch to the fine-tune when it wins, and restart the daemon")
     mt.add_argument("--when-idle", action="store_true",
-                    help="first wait for a quiet machine on mains power ([learn] max_load, "
-                         "wait_hours); the scheduled run uses this")
+                    help="work only while you're away from the computer, on mains power "
+                         "([learn] away_minutes, max_load, wait_hours): stop when you're "
+                         "back, resume later; the scheduled run uses this")
     mt.set_defaults(func=cmd_maintain)
 
     sc = lsub.add_parser("schedule", help="Run `maintain` on a schedule (systemd timer)")
@@ -257,7 +258,8 @@ def cmd_label(args: argparse.Namespace) -> None:
     cfg = _cfg()
     name = args.teacher or DEFAULT_TEACHER
     print(f"Loading teacher {name}…", flush=True)
-    teacher = WhisperTeacher(name, vocabulary=_vocabulary(), language=cfg.model.language)
+    teacher = WhisperTeacher(name, vocabulary=_vocabulary(), language=cfg.model.language,
+                             threads=cfg.learn.threads)
     clips = sorted(store.clips(), key=lambda c: c.duration)
     t0 = time.monotonic()
 
@@ -427,17 +429,41 @@ def _train_language() -> str:
     return lang
 
 
+def _runs_of(ds: Path, base: str) -> list[Path]:
+    """Run dirs that fine-tuned `base` on `ds`, oldest first."""
+    import re
+    pattern = re.compile(rf"{re.escape(ds.name)}-{re.escape(Path(base).name)}-\d{{8}}-\d{{4}}")
+    root = _models_dir()
+    return sorted(p for p in root.glob(f"{ds.name}-*") if pattern.fullmatch(p.name)) \
+        if root.exists() else []
+
+
+def _finished(run: Path) -> bool:
+    return (run / "ct2" / "model.bin").exists()
+
+
+def _finished_run(ds: Path, base: str) -> Path | None:
+    return next((r for r in reversed(_runs_of(ds, base)) if _finished(r)), None)
+
+
 def _train(ds: Path, *, base: str = "small", epochs: int = 4, synthetic_share: float = 0.3,
            full: bool = False, remote: bool = False) -> Path | None:
-    """Export `ds` and fine-tune on it; returns the run dir (None for --remote)."""
+    """Export `ds` and fine-tune on it; returns the run dir (None for --remote).
+    An interrupted run of the same dataset and base carries on where it was."""
     from voiceio.learn import augment, train
-    real = len(store.read_split(ds, "train"))
-    synth = augment.rows(max_share=synthetic_share, real_rows=real)
     folder = store.learn_dir() / "exports" / ds.name
-    counts = train.export(ds, folder, extra_train_rows=synth, hotwords=_live_hotwords())
-    print(f"exported {counts} windows ({len(synth)} synthetic) to {folder}")
+    unfinished = [r for r in _runs_of(ds, base) if not _finished(r)]
+    run = unfinished[-1] if unfinished and not remote else None
+    if run is not None and all((folder / f).exists()
+                               for f in ("train.jsonl", "dev.jsonl", train.HOTWORDS_FILE)):
+        print(f"resuming {run.name} (windows exported before)")
+    else:
+        real = len(store.read_split(ds, "train"))
+        synth = augment.rows(max_share=synthetic_share, real_rows=real)
+        counts = train.export(ds, folder, extra_train_rows=synth, hotwords=_live_hotwords())
+        print(f"exported {counts} windows ({len(synth)} synthetic) to {folder}")
     # A Hugging Face id or path names the run by its last part: one directory.
-    run = _models_dir() / f"{ds.name}-{Path(base).name}-{time.strftime('%Y%m%d-%H%M')}"
+    run = run or _models_dir() / f"{ds.name}-{Path(base).name}-{time.strftime('%Y%m%d-%H%M')}"
     if remote:
         print("\n" + train.remote_recipe(folder, run, base))
         return None
@@ -447,42 +473,106 @@ def _train(ds: Path, *, base: str = "small", epochs: int = 4, synthetic_share: f
     # with: training a Spanish voice under "en" taught it the wrong prompt.
     hf = train.train(folder, run, train.TrainConfig(
         base=base, epochs=epochs, decoder_only=False if full else None, hotwords=hotwords,
-        language=_train_language()))
+        language=_train_language(), threads=_cfg().learn.threads))
     train.convert(hf, run / "ct2")
+    train.discard_resume_state(run)
     return run
 
 
+# A dataset `maintain` built and has not finished with (trained, scored,
+# decided): a stopped run picks it up again instead of waiting for min_new
+# more clips past it.
+def _pending_path() -> Path:
+    return store.learn_dir() / "maintain-pending.json"
+
+
+def _pending_dataset() -> Path | None:
+    try:
+        name = json.loads(_pending_path().read_text())["dataset"]
+    except (OSError, ValueError, KeyError, TypeError):
+        return None
+    ds = store.learn_dir() / "datasets" / name
+    if not (ds / "manifest.json").exists():
+        _set_pending(None)
+        return None
+    return ds
+
+
+def _set_pending(ds: Path | None) -> None:
+    path = _pending_path()
+    if ds is None:
+        path.unlink(missing_ok=True)
+        return
+    tmp = path.with_name(path.name + ".tmp")
+    tmp.write_text(json.dumps({"dataset": ds.name}) + "\n")
+    os.replace(tmp, path)
+
+
 def cmd_maintain(args: argparse.Namespace) -> None:
     """Label what's new; once enough has piled up, rebuild, retrain and say
-    whether the result beats the current model. Never promotes by itself."""
+    whether the result beats the current model. Never promotes by itself.
+
+    With --when-idle this process only watches: the work runs in a child
+    that is stopped the moment you're back and started again (it resumes)
+    once you're away (voiceio.learn.quiet)."""
     _yield_cpu()
-    from voiceio.learn import evaluate, quiet
+    from voiceio.learn import quiet
     learn_cfg = _maintain_settings(args)
-    if getattr(args, "when_idle", False) and not quiet.wait_until_quiet(
-            learn_cfg.max_load, learn_cfg.wait_hours):
+    if getattr(args, "when_idle", False) and os.environ.get(quiet.WORKER_ENV) != "1":
+        store.learn_dir().mkdir(parents=True, exist_ok=True)
+        code = quiet.run_while_away(
+            quiet.worker_argv(), max_load=learn_cfg.max_load,
+            away_minutes=learn_cfg.away_minutes, wait_hours=learn_cfg.wait_hours,
+            threads=learn_cfg.threads, hold_file=store.learn_dir() / "maintain.hold")
+        if code:
+            raise SystemExit(code)
         return
-    _announce_learning(learn_cfg.min_new)
+    _maintain(args, learn_cfg)
+
+
+def _maintain(args: argparse.Namespace, learn_cfg) -> None:
+    from voiceio.learn import evaluate, quiet, train
+    if not os.environ.get(quiet.RESUMED_ENV):
+        _announce_learning(learn_cfg.min_new)
     cmd_label(argparse.Namespace(teacher=learn_cfg.teacher or None, limit=None, relabel=False))
-    from voiceio.learn import train
     if missing := train.missing_train_deps():
         # Labeling alone is worth it; retraining waits for the extra. Exit 0:
         # a nightly timer must not fail every night over an optional install.
         print(f"labeled; fine-tuning needs {', '.join(missing)}: {train.TRAIN_HINT}")
         return
-    labels = store.load_labels()
-    labeled = {c.audio for c in store.clips() if c.audio in labels}
-    ds = store.latest_dataset()
-    new = len(labeled - store.dataset_clips(ds)) if ds else len(labeled)
-    if new < learn_cfg.min_new:   # the first dataset too: a handful of clips trains nothing
-        since = f" since {ds.name}" if ds else ""
-        print(f"{new} new labeled clips{since}; retraining waits for {learn_cfg.min_new}.")
-        return
-    ds = store.build_dataset()
-    print(f"built {ds.name} ({new} new clips)")
-    current = _run_eval(None, ds)
-    run = _train(ds, base=learn_cfg.base, epochs=learn_cfg.epochs)
-    candidate = _run_eval(str(run / "ct2"), ds)
-    ok, table = evaluate.promotion_verdict(_scores(candidate), _scores(current))
+    ds = _pending_dataset()
+    if ds is not None:
+        print(f"carrying on with {ds.name}, which a stopped run had not finished")
+    else:
+        labels = store.load_labels()
+        labeled = {c.audio for c in store.clips() if c.audio in labels}
+        latest = store.latest_dataset()
+        new = len(labeled - store.dataset_clips(latest)) if latest else len(labeled)
+        if new < learn_cfg.min_new:   # the first dataset too: a handful of clips trains nothing
+            since = f" since {latest.name}" if latest else ""
+            print(f"{new} new labeled clips{since}; retraining waits for {learn_cfg.min_new}.")
+            return
+        ds = store.build_dataset()
+        _set_pending(ds)
+        print(f"built {ds.name} ({new} new clips)")
+    # Scores already saved for this dataset are reused: a resumed run doesn't
+    # spend its time again on evals it finished before it was stopped.
+    beam = _cfg().model.beam_size
+    current = evaluate.latest(_cfg().model.name, ds.name, beam=beam) or _scores(_run_eval(None, ds))
+    run = _finished_run(ds, learn_cfg.base) or _train(ds, base=learn_cfg.base,
+                                                      epochs=learn_cfg.epochs)
+    model = str(run / "ct2")
+    candidate = evaluate.latest(model, ds.name, beam=beam) or _scores(_run_eval(model, ds))
+    with quiet.hold():   # from here on: seconds of work that must not be torn
+        _set_pending(None)
+        _decide(args, run, ds, candidate, current)
+
+
+def _decide(args: argparse.Namespace, run: Path, ds: Path, candidate: dict,
+            current: dict) -> None:
+    """Report the comparison; switch models or say how to."""
+    from voiceio.learn import evaluate
+    ok, table = evaluate.promotion_verdict(candidate, current)
     print(f"\n{_cfg().model.name} → {run.name} on {ds.name}:\n{table}")
     print(f"better or equal on everything — `voiceio learn promote {run.name}`" if ok
           else "not better on everything — keeping the current model")
@@ -539,7 +629,7 @@ def _announce_learning(min_new: int) -> None:
     to_label = sum(1 for a in clips if a not in labels)
     ds = store.latest_dataset()
     new = len(set(clips) - (store.dataset_clips(ds) if ds else set()))
-    retrain = new >= min_new
+    retrain = new >= min_new or _pending_dataset() is not None
     if not to_label and not retrain:
         return
     from voiceio import feedback
@@ -547,7 +637,7 @@ def _announce_learning(min_new: int) -> None:
         (", then retraining" if to_label and retrain else "Retraining" if retrain else "")
     feedback.notify_actions(
         "VoiceIO is learning your voice",
-        f"{what}, on this computer at idle priority; dictation stays fast.",
+        f"{what}, on this computer while you're away; it stops the moment you're back.",
         {"stop": "Stop for now", "weekly": "Weekly instead"},
         _on_learning_action)
 
@@ -611,10 +701,12 @@ def cmd_schedule(args: argparse.Namespace) -> None:
         if not service.install_learn_timer(auto_promote=args.auto_promote):
             raise SystemExit("could not enable the timer (needs systemd --user)")
         learn = config.load().learn
-        print(f"on, {service.learn_schedule_summary()}: once the machine is quiet (load per CPU "
-              f"≤ {learn.max_load:g}, on mains power; waits up to {learn.wait_hours:g} h), "
+        print(f"on, {service.learn_schedule_summary()}: once you've been away from the computer "
+              f"{learn.away_minutes:g} min (or locked the screen), on mains power and with load "
+              f"per CPU ≤ {learn.max_load:g} (waiting up to {learn.wait_hours:g} h), "
               "`voiceio learn maintain` labels new dictation at idle priority, retrains once "
-              f"{min_new}+ clips are new, and "
+              f"{min_new}+ clips are new — stopping within seconds when you're back and "
+              "resuming where it was — and "
               + ("switches to the result when it wins on your held-out clips "
                  "(undo: voiceio learn rollback)." if args.auto_promote else
                  "tells you if the result is better. It never switches models by itself."))

voiceio/config.py

@@ -291,11 +291,17 @@ class LearnConfig:
     # and "day" or "week" (weekly runs on Sunday).
     at: str = "03:30"
     every: str = "day"
-    # It only starts on a quiet machine on mains power: 1-minute load per CPU
-    # at most max_load. It waits up to wait_hours for that, then tries again
-    # at the next scheduled run.
+    # It works only while nobody is using the computer: no keyboard or mouse
+    # input for away_minutes (or the screen locked), on mains power, and
+    # starts only when the 1-minute load per CPU is at most max_load. When
+    # you come back it stops within seconds and later resumes where it
+    # stopped. It waits up to wait_hours each time, then tries again at the
+    # next scheduled run.
+    away_minutes: float = 10.0
     max_load: float = 0.25
     wait_hours: float = 3.0
+    # CPU threads for labeling and training; 0 = half the logical CPUs.
+    threads: int = 0
     # What a scheduled run trains (`voiceio learn maintain`'s flags override):
     # the Whisper size or Hugging Face checkpoint to fine-tune, e.g. "medium.en";
     # the model that labels new clips (empty: large-v3-turbo); epochs per run;

voiceio/learn/evaluate.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import collections
 import difflib
 import json
+import os
 import statistics
 import time
 from dataclasses import asdict, dataclass, field
@@ -152,7 +153,9 @@ def save(result: EvalResult) -> Path:
                              "rtf": result.rtf, "metrics": metrics.METRICS_VERSION}
     if result.waits:
         data["stop_to_text_median"] = statistics.median(result.waits)
-    path.write_text(json.dumps(data, indent=2) + "\n")
+    tmp = path.with_name(f".{path.name}.tmp")   # whole or not at all: runs are reused
+    tmp.write_text(json.dumps(data, indent=2) + "\n")
+    os.replace(tmp, path)
     return path
 
 

voiceio/learn/quiet.py

@@ -1,41 +1,172 @@
-"""Is the machine quiet enough for background learning?
+"""Background learning that never competes with the person at the computer.
 
-Nightly learning is CPU-heavy for an hour or more. It runs at idle priority
-regardless, but it should not even start while the machine is busy or on
-battery: a laptop running on battery at 3am would just drain.
+Labeling, evaluating and training are CPU-heavy for an hour or more. Idle CPU
+priority is not enough on its own (see voiceio.presence), so a scheduled run
+only works while nobody is using the machine:
+
+  * it starts once you have been away `[learn] away_minutes` (no input, or
+    the screen locked), on mains power, with the machine otherwise quiet;
+  * the work runs in a child process, and the parent checks every couple of
+    seconds; when you come back (or unplug) the child is stopped at once;
+  * every stage resumes where it stopped: labels are saved per clip,
+    training checkpoints its progress (voiceio.learn.train), finished evals
+    are reused. The next time you are away it carries on, within the same
+    run while it waits, else at the next scheduled run.
+
+Load is checked only before starting: while the work runs, the load is
+mostly the work itself, and a check that its own evidence can trip would
+stop every run.
 """
 from __future__ import annotations
 
+import contextlib
 import os
+import re
+import signal
+import subprocess
+import sys
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
+from pathlib import Path
 
+from voiceio import presence
 from voiceio.power import on_battery
 
+# Set in the child that does the work; its absence makes `maintain
+# --when-idle` the watcher instead.
+WORKER_ENV = "VOICEIO_LEARN_WORKER"
+# A later child after an interruption: carry on quietly (no second "learning" notice).
+RESUMED_ENV = "VOICEIO_LEARN_RESUMED"
+# Path of a file the child holds while it must not be cut off (switching models).
+HOLD_ENV = "VOICEIO_LEARN_HOLD"
+
 
-def busy_reason(max_load: float) -> str | None:
-    """Why learning should wait right now, or None when the machine is quiet."""
+def busy_reason(max_load: float, away_after: float | None = None) -> str | None:
+    """Why learning should wait right now, or None when it may start."""
+    if on_battery():
+        return "on battery"
+    if away_after is not None:
+        p = presence.check(away_after)
+        if p.here:
+            return p.why
     load = os.getloadavg()[0] / (os.cpu_count() or 1)
     if load > max_load:
         return f"busy (load {load:.2f} per CPU, waiting for {max_load:g})"
+    return None
+
+
+def stop_reason(away_after: float) -> str | None:
+    """Why running work must stop now (you're back, or on battery), else None."""
     if on_battery():
         return "on battery"
-    return None
+    p = presence.check(away_after)
+    return p.why if p.here else None
 
 
-def wait_until_quiet(max_load: float, wait_hours: float, *, poll: float = 300,
+def wait_until_quiet(max_load: float, wait_hours: float, *, away_after: float | None = None,
+                     poll: float = 300,
                      sleep: Callable[[float], None] = time.sleep,
                      clock: Callable[[], float] = time.monotonic,
                      say: Callable[[str], None] = print) -> bool:
-    """Block until the machine is quiet. False when it stayed busy for wait_hours."""
+    """Block until learning may start. False when it couldn't for wait_hours."""
     deadline = clock() + wait_hours * 3600
     last = None
-    while (reason := busy_reason(max_load)) is not None:
-        if reason != last:
+    while (reason := busy_reason(max_load, away_after)) is not None:
+        if (kind := re.sub(r"[\d.]+", "#", reason)) != last:   # once per reason, not per reading
             say(f"waiting: {reason}")
-            last = reason
+            last = kind
         if clock() + poll > deadline:
             say(f"still {reason} after {wait_hours:g} h; trying again at the next scheduled run")
             return False
         sleep(poll)
     return True
+
+
+def worker_threads(threads: int) -> int:
+    """`[learn] threads`, with 0 meaning half the logical CPUs (the physical
+    cores on an SMT machine): fast on an idle machine, never all of it."""
+    return threads if threads > 0 else max(1, (os.cpu_count() or 2) // 2)
+
+
+def worker_argv() -> list[str]:
+    """This same command, for the child. orig_argv keeps "-m voiceio": re-
+    running __main__.py as a script would put voiceio/ first on sys.path."""
+    return [sys.executable, *sys.orig_argv[1:]]
+
+
+def _spawn(argv: list[str], env: dict[str, str]) -> subprocess.Popen:
+    # Own process group: stopping it takes the decoder subprocesses along.
+    return subprocess.Popen(argv, env=env, start_new_session=True)
+
+
+def _stop(proc: subprocess.Popen, grace: float = 5.0) -> None:
+    """End the work now. Nothing is lost that a later run needs: every stage
+    saves its progress as it goes, so there is no shutdown to wait for."""
+    for sig, wait in ((signal.SIGTERM, grace), (signal.SIGKILL, None)):
+        try:
+            os.killpg(proc.pid, sig)
+        except ProcessLookupError:
+            break
+        try:
+            proc.wait(timeout=wait)
+            break
+        except subprocess.TimeoutExpired:
+            continue
+    with contextlib.suppress(ProcessLookupError):   # stragglers left in the group
+        os.killpg(proc.pid, signal.SIGKILL)
+
+
+def run_while_away(argv: list[str], *, max_load: float, away_minutes: float,
+                   wait_hours: float, threads: int, hold_file: Path,
+                   poll: float = 2.0, wait_poll: float = 30.0,
+                   spawn: Callable[[list[str], dict[str, str]], subprocess.Popen] = _spawn,
+                   stop: Callable[[subprocess.Popen], None] = _stop,
+                   sleep: Callable[[float], None] = time.sleep,
+                   clock: Callable[[], float] = time.monotonic,
+                   say: Callable[[str], None] = print) -> int:
+    """Run `argv` (the work) only while nobody is using the machine: stop it
+    within `poll` seconds when that changes, and start it again (it resumes)
+    once they are away again. Returns its exit status; 0 when it gave up
+    waiting (the next scheduled run continues)."""
+    away_after = away_minutes * 60
+    n = str(worker_threads(threads))
+    # torch, CTranslate2 and numpy size their thread pools from these.
+    env = {**os.environ, WORKER_ENV: "1", HOLD_ENV: str(hold_file),
+           "OMP_NUM_THREADS": n, "MKL_NUM_THREADS": n}
+    resumed = False
+    while True:
+        if not wait_until_quiet(max_load, wait_hours, away_after=away_after, poll=wait_poll,
+                                sleep=sleep, clock=clock, say=say):
+            return 0
+        hold_file.unlink(missing_ok=True)
+        proc = spawn(argv, {**env, RESUMED_ENV: "1"} if resumed else env)
+        reason = None
+        while proc.poll() is None:
+            sleep(poll)
+            if hold_file.exists():  # switching models: seconds, and must not be torn
+                continue
+            reason = stop_reason(away_after)
+            if reason is not None and proc.poll() is None:
+                stop(proc)
+                break
+        else:
+            hold_file.unlink(missing_ok=True)
+            return proc.returncode
+        say(f"paused: {reason}; it resumes where it stopped once you've been away "
+            f"{away_minutes:g} min")
+        resumed = True
+
+
+@contextlib.contextmanager
+def hold() -> Iterator[None]:
+    """Don't let the watcher stop the work inside this block (a model switch:
+    config, history and the daemon restart belong together)."""
+    path = os.environ.get(HOLD_ENV)
+    if not path:
+        yield
+        return
+    Path(path).touch()
+    try:
+        yield
+    finally:
+        Path(path).unlink(missing_ok=True)