Refine config and runtime flow
This commit is contained in:
parent
85e082dd46
commit
b3be444625
16 changed files with 642 additions and 137 deletions
253
src/leld.py
253
src/leld.py
|
|
@ -1,5 +1,8 @@
|
|||
#!/usr/bin/env python3
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import errno
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
|
|
@ -8,15 +11,14 @@ import sys
|
|||
import threading
|
||||
import time
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
import gi
|
||||
from faster_whisper import WhisperModel
|
||||
|
||||
from aiprocess import LlamaProcessor
|
||||
from config import Config, load, redacted_dict
|
||||
from constants import RECORD_TIMEOUT_SEC, STT_LANGUAGE
|
||||
from recorder import start_recording, stop_recording
|
||||
from aiprocess import LlamaProcessor
|
||||
from desktop import get_desktop_adapter
|
||||
from recorder import start_recording as start_audio_recording
|
||||
from recorder import stop_recording as stop_audio_recording
|
||||
|
||||
|
||||
class State:
|
||||
|
|
@ -27,11 +29,26 @@ class State:
|
|||
OUTPUTTING = "outputting"
|
||||
|
||||
|
||||
_LOCK_HANDLE = None
|
||||
|
||||
|
||||
def _build_whisper_model(model_name: str, device: str):
|
||||
try:
|
||||
from faster_whisper import WhisperModel # type: ignore[import-not-found]
|
||||
except ModuleNotFoundError as exc:
|
||||
raise RuntimeError(
|
||||
"faster-whisper is not installed; install dependencies with `uv sync`"
|
||||
) from exc
|
||||
return WhisperModel(
|
||||
model_name,
|
||||
device=device,
|
||||
compute_type=_compute_type(device),
|
||||
)
|
||||
|
||||
|
||||
def _compute_type(device: str) -> str:
|
||||
dev = (device or "cpu").lower()
|
||||
if dev == "cuda":
|
||||
if dev.startswith("cuda"):
|
||||
return "float16"
|
||||
return "int8"
|
||||
|
||||
|
|
@ -40,17 +57,20 @@ class Daemon:
|
|||
def __init__(self, cfg: Config, desktop, *, verbose: bool = False):
|
||||
self.cfg = cfg
|
||||
self.desktop = desktop
|
||||
self.verbose = verbose
|
||||
self.lock = threading.Lock()
|
||||
self._shutdown_requested = threading.Event()
|
||||
self.state = State.IDLE
|
||||
self.proc = None
|
||||
self.stream = None
|
||||
self.record = None
|
||||
self.timer = None
|
||||
self.model = WhisperModel(
|
||||
cfg.stt.get("model", "base"),
|
||||
device=cfg.stt.get("device", "cpu"),
|
||||
compute_type=_compute_type(cfg.stt.get("device", "cpu")),
|
||||
self.timer: threading.Timer | None = None
|
||||
self.model = _build_whisper_model(
|
||||
cfg.stt.model,
|
||||
cfg.stt.device,
|
||||
)
|
||||
self.ai_processor = LlamaProcessor(verbose=verbose)
|
||||
self.ai_enabled = cfg.ai.enabled
|
||||
self.ai_processor: LlamaProcessor | None = None
|
||||
self.log_transcript = cfg.logging.log_transcript or verbose
|
||||
|
||||
def set_state(self, state: str):
|
||||
with self.lock:
|
||||
|
|
@ -63,29 +83,39 @@ class Daemon:
|
|||
with self.lock:
|
||||
return self.state
|
||||
|
||||
def _quit(self):
|
||||
os._exit(0)
|
||||
def request_shutdown(self):
|
||||
self._shutdown_requested.set()
|
||||
|
||||
def toggle(self):
|
||||
should_stop = False
|
||||
with self.lock:
|
||||
if self._shutdown_requested.is_set():
|
||||
logging.info("shutdown in progress, trigger ignored")
|
||||
return
|
||||
if self.state == State.IDLE:
|
||||
self._start_recording_locked()
|
||||
return
|
||||
if self.state == State.RECORDING:
|
||||
self.state = State.STT
|
||||
threading.Thread(target=self._stop_and_process, daemon=True).start()
|
||||
return
|
||||
logging.info("busy (%s), trigger ignored", self.state)
|
||||
should_stop = True
|
||||
else:
|
||||
logging.info("busy (%s), trigger ignored", self.state)
|
||||
if should_stop:
|
||||
self.stop_recording(trigger="user")
|
||||
|
||||
def _start_recording_locked(self):
|
||||
if self.state != State.IDLE:
|
||||
logging.info("busy (%s), trigger ignored", self.state)
|
||||
return
|
||||
try:
|
||||
proc, record = start_recording(self.cfg.recording.get("input", ""))
|
||||
stream, record = start_audio_recording(self.cfg.recording.input)
|
||||
except Exception as exc:
|
||||
logging.error("record start failed: %s", exc)
|
||||
return
|
||||
self.proc = proc
|
||||
self.stream = stream
|
||||
self.record = record
|
||||
prev = self.state
|
||||
self.state = State.RECORDING
|
||||
logging.info("state: %s -> %s", prev, self.state)
|
||||
logging.info("recording started")
|
||||
if self.timer:
|
||||
self.timer.cancel()
|
||||
|
|
@ -94,30 +124,45 @@ class Daemon:
|
|||
self.timer.start()
|
||||
|
||||
def _timeout_stop(self):
|
||||
with self.lock:
|
||||
if self.state != State.RECORDING:
|
||||
return
|
||||
self.state = State.STT
|
||||
threading.Thread(target=self._stop_and_process, daemon=True).start()
|
||||
self.stop_recording(trigger="timeout")
|
||||
|
||||
def _stop_and_process(self):
|
||||
proc = self.proc
|
||||
def _start_stop_worker(self, stream: Any, record: Any, trigger: str, process_audio: bool):
|
||||
threading.Thread(
|
||||
target=self._stop_and_process,
|
||||
args=(stream, record, trigger, process_audio),
|
||||
daemon=True,
|
||||
).start()
|
||||
|
||||
def _begin_stop_locked(self):
|
||||
if self.state != State.RECORDING:
|
||||
return None
|
||||
stream = self.stream
|
||||
record = self.record
|
||||
self.proc = None
|
||||
self.stream = None
|
||||
self.record = None
|
||||
if self.timer:
|
||||
self.timer.cancel()
|
||||
self.timer = None
|
||||
prev = self.state
|
||||
self.state = State.STT
|
||||
logging.info("state: %s -> %s", prev, self.state)
|
||||
|
||||
if not proc or not record:
|
||||
if stream is None or record is None:
|
||||
logging.warning("recording resources are unavailable during stop")
|
||||
self.state = State.IDLE
|
||||
return None
|
||||
return stream, record
|
||||
|
||||
def _stop_and_process(self, stream: Any, record: Any, trigger: str, process_audio: bool):
|
||||
logging.info("stopping recording (%s)", trigger)
|
||||
try:
|
||||
audio = stop_audio_recording(stream, record)
|
||||
except Exception as exc:
|
||||
logging.error("record stop failed: %s", exc)
|
||||
self.set_state(State.IDLE)
|
||||
return
|
||||
|
||||
logging.info("stopping recording (user)")
|
||||
try:
|
||||
audio = stop_recording(proc, record)
|
||||
except Exception as exc:
|
||||
logging.error("record stop failed: %s", exc)
|
||||
if not process_audio or self._shutdown_requested.is_set():
|
||||
self.set_state(State.IDLE)
|
||||
return
|
||||
|
||||
|
|
@ -140,35 +185,64 @@ class Daemon:
|
|||
self.set_state(State.IDLE)
|
||||
return
|
||||
|
||||
logging.info("stt: %s", text)
|
||||
if self.log_transcript:
|
||||
logging.info("stt: %s", text)
|
||||
else:
|
||||
logging.info("stt produced %d chars", len(text))
|
||||
|
||||
self.set_state(State.PROCESSING)
|
||||
logging.info("ai processing started")
|
||||
try:
|
||||
ai_input = text
|
||||
text = self.ai_processor.process(ai_input) or text
|
||||
except Exception as exc:
|
||||
logging.error("ai process failed: %s", exc)
|
||||
if self.ai_enabled and not self._shutdown_requested.is_set():
|
||||
self.set_state(State.PROCESSING)
|
||||
logging.info("ai processing started")
|
||||
try:
|
||||
processor = self._get_ai_processor()
|
||||
ai_text = processor.process(text)
|
||||
if ai_text and ai_text.strip():
|
||||
text = ai_text.strip()
|
||||
except Exception as exc:
|
||||
logging.error("ai process failed: %s", exc)
|
||||
else:
|
||||
logging.info("ai processing disabled")
|
||||
|
||||
logging.info("processed: %s", text)
|
||||
if self.log_transcript:
|
||||
logging.info("processed: %s", text)
|
||||
else:
|
||||
logging.info("processed text length: %d", len(text))
|
||||
|
||||
if self._shutdown_requested.is_set():
|
||||
self.set_state(State.IDLE)
|
||||
return
|
||||
|
||||
try:
|
||||
self.set_state(State.OUTPUTTING)
|
||||
logging.info("outputting started")
|
||||
backend = self.cfg.injection.get("backend", "clipboard")
|
||||
backend = self.cfg.injection.backend
|
||||
self.desktop.inject_text(text, backend)
|
||||
except Exception as exc:
|
||||
logging.error("output failed: %s", exc)
|
||||
finally:
|
||||
self.set_state(State.IDLE)
|
||||
|
||||
|
||||
def stop_recording(self):
|
||||
def stop_recording(self, *, trigger: str = "user", process_audio: bool = True):
|
||||
payload = None
|
||||
with self.lock:
|
||||
if self.state != State.RECORDING:
|
||||
return
|
||||
self.state = State.STT
|
||||
threading.Thread(target=self._stop_and_process, daemon=True).start()
|
||||
payload = self._begin_stop_locked()
|
||||
if payload is None:
|
||||
return
|
||||
stream, record = payload
|
||||
self._start_stop_worker(stream, record, trigger, process_audio)
|
||||
|
||||
def shutdown(self, timeout: float = 5.0) -> bool:
|
||||
self.request_shutdown()
|
||||
self.stop_recording(trigger="shutdown", process_audio=False)
|
||||
return self.wait_for_idle(timeout)
|
||||
|
||||
def wait_for_idle(self, timeout: float) -> bool:
|
||||
end = time.time() + timeout
|
||||
while time.time() < end:
|
||||
if self.get_state() == State.IDLE:
|
||||
return True
|
||||
time.sleep(0.05)
|
||||
return self.get_state() == State.IDLE
|
||||
|
||||
def _transcribe(self, audio) -> str:
|
||||
segments, _info = self.model.transcribe(audio, language=STT_LANGUAGE, vad_filter=True)
|
||||
|
|
@ -179,22 +253,50 @@ class Daemon:
|
|||
parts.append(text)
|
||||
return " ".join(parts).strip()
|
||||
|
||||
def _get_ai_processor(self) -> LlamaProcessor:
|
||||
if self.ai_processor is None:
|
||||
self.ai_processor = LlamaProcessor(verbose=self.verbose)
|
||||
return self.ai_processor
|
||||
|
||||
|
||||
def _read_lock_pid(lock_file) -> str:
|
||||
lock_file.seek(0)
|
||||
return lock_file.read().strip()
|
||||
|
||||
|
||||
def _lock_single_instance():
|
||||
runtime_dir = Path(os.getenv("XDG_RUNTIME_DIR", "/tmp")) / "lel"
|
||||
runtime_dir.mkdir(parents=True, exist_ok=True)
|
||||
lock_path = runtime_dir / "lel.lock"
|
||||
f = open(lock_path, "w")
|
||||
lock_file = open(lock_path, "a+", encoding="utf-8")
|
||||
try:
|
||||
import fcntl
|
||||
|
||||
fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
except Exception:
|
||||
# TODO: kindly try to handle the running PID to the user cleanly in stdout if it's easy to get
|
||||
raise SystemExit("already running")
|
||||
return f
|
||||
fcntl.flock(lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
except BlockingIOError as exc:
|
||||
pid = _read_lock_pid(lock_file)
|
||||
lock_file.close()
|
||||
if pid:
|
||||
raise SystemExit(f"already running (pid={pid})") from exc
|
||||
raise SystemExit("already running") from exc
|
||||
except OSError as exc:
|
||||
if exc.errno in (errno.EACCES, errno.EAGAIN):
|
||||
pid = _read_lock_pid(lock_file)
|
||||
lock_file.close()
|
||||
if pid:
|
||||
raise SystemExit(f"already running (pid={pid})") from exc
|
||||
raise SystemExit("already running") from exc
|
||||
raise
|
||||
|
||||
lock_file.seek(0)
|
||||
lock_file.truncate()
|
||||
lock_file.write(f"{os.getpid()}\n")
|
||||
lock_file.flush()
|
||||
return lock_file
|
||||
|
||||
|
||||
def main():
|
||||
global _LOCK_HANDLE
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--config", default="", help="path to config.json")
|
||||
parser.add_argument("--dry-run", action="store_true", help="log hotkey only")
|
||||
|
|
@ -207,37 +309,50 @@ def main():
|
|||
format="lel: %(asctime)s %(levelname)s %(message)s",
|
||||
)
|
||||
cfg = load(args.config)
|
||||
_lock_single_instance()
|
||||
_LOCK_HANDLE = _lock_single_instance()
|
||||
|
||||
logging.info("hotkey: %s", cfg.daemon.get("hotkey", ""))
|
||||
logging.info("config (%s):\n%s", args.config or str(Path.home() / ".config" / "lel" / "config.json"), json.dumps(redacted_dict(cfg), indent=2))
|
||||
logging.info("hotkey: %s", cfg.daemon.hotkey)
|
||||
logging.info(
|
||||
"config (%s):\n%s",
|
||||
args.config or str(Path.home() / ".config" / "lel" / "config.json"),
|
||||
json.dumps(redacted_dict(cfg), indent=2),
|
||||
)
|
||||
|
||||
if args.verbose:
|
||||
logging.getLogger().setLevel(logging.DEBUG)
|
||||
desktop = get_desktop_adapter()
|
||||
try:
|
||||
desktop = get_desktop_adapter()
|
||||
daemon = Daemon(cfg, desktop, verbose=args.verbose)
|
||||
except Exception as exc:
|
||||
logging.error("startup failed: %s", exc)
|
||||
raise SystemExit(1)
|
||||
|
||||
shutdown_once = threading.Event()
|
||||
|
||||
def shutdown(reason: str):
|
||||
if shutdown_once.is_set():
|
||||
return
|
||||
shutdown_once.set()
|
||||
logging.info("%s, shutting down", reason)
|
||||
if not daemon.shutdown(timeout=5.0):
|
||||
logging.warning("timed out waiting for idle state during shutdown")
|
||||
desktop.request_quit()
|
||||
|
||||
def handle_signal(_sig, _frame):
|
||||
logging.info("signal received, shutting down")
|
||||
daemon.stop_recording()
|
||||
end = time.time() + 5
|
||||
while time.time() < end and daemon.get_state() != State.IDLE:
|
||||
time.sleep(0.1)
|
||||
os._exit(0)
|
||||
threading.Thread(target=shutdown, args=("signal received",), daemon=True).start()
|
||||
|
||||
signal.signal(signal.SIGINT, handle_signal)
|
||||
signal.signal(signal.SIGTERM, handle_signal)
|
||||
|
||||
desktop.start_hotkey_listener(
|
||||
cfg.daemon.get("hotkey", ""),
|
||||
cfg.daemon.hotkey,
|
||||
lambda: logging.info("hotkey pressed (dry-run)") if args.dry_run else daemon.toggle(),
|
||||
)
|
||||
logging.info("ready")
|
||||
desktop.run_tray(daemon.get_state, daemon._quit)
|
||||
try:
|
||||
desktop.run_tray(daemon.get_state, lambda: shutdown("quit requested"))
|
||||
finally:
|
||||
daemon.shutdown(timeout=1.0)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue