python-voiceio 0.2.0__py3-none-any.whl

voiceio/service.py

@@ -0,0 +1,234 @@
+"""Systemd user service installation and management."""
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+LOCAL_BIN = Path.home() / ".local" / "bin"
+SCRIPT_NAMES = ["voiceio", "voiceio-toggle", "voiceio-doctor", "voiceio-setup", "voiceio-test"]
+_PATH_HINT_ADDED = False  # track if we already printed the PATH hint
+
+SERVICE_NAME = "voiceio.service"
+SERVICE_DIR = Path.home() / ".config" / "systemd" / "user"
+SERVICE_PATH = SERVICE_DIR / SERVICE_NAME
+
+
+def has_systemd() -> bool:
+    """Check if systemd is available on this system."""
+    return shutil.which("systemctl") is not None
+
+
+def _find_voiceio_bin() -> str:
+    """Find the voiceio binary path."""
+    # Check venv first
+    venv_bin = Path(sys.prefix) / "bin" / "voiceio"
+    if venv_bin.exists():
+        return str(venv_bin.resolve())
+    found = shutil.which("voiceio")
+    if found:
+        return str(Path(found).resolve())
+    return "voiceio"
+
+
+def _service_unit(bin_path: str) -> str:
+    """Generate the systemd unit file content."""
+    return f"""\
+[Unit]
+Description=VoiceIO - voice-to-text input
+Documentation=https://github.com/Hugo0/voiceio
+After=graphical-session.target
+PartOf=graphical-session.target
+
+[Service]
+Type=simple
+ExecStart={bin_path}
+Restart=on-failure
+RestartSec=3
+
+[Install]
+WantedBy=default.target
+"""
+
+
+def install_service() -> bool:
+    """Install and enable the voiceio systemd user service.
+
+    Returns True if installed successfully.
+    """
+    if not has_systemd():
+        log.warning("systemctl not found: cannot install service")
+        return False
+
+    bin_path = _find_voiceio_bin()
+
+    SERVICE_DIR.mkdir(parents=True, exist_ok=True)
+    SERVICE_PATH.write_text(_service_unit(bin_path))
+    log.info("Installed systemd service to %s", SERVICE_PATH)
+
+    # Reload systemd and enable the service
+    try:
+        subprocess.run(
+            ["systemctl", "--user", "daemon-reload"],
+            capture_output=True, timeout=5,
+        )
+        subprocess.run(
+            ["systemctl", "--user", "enable", SERVICE_NAME],
+            capture_output=True, timeout=5,
+        )
+        log.info("Enabled %s", SERVICE_NAME)
+        return True
+    except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+        log.warning("Could not enable service: %s", e)
+        return False
+
+
+def uninstall_service() -> bool:
+    """Disable and remove the voiceio systemd user service."""
+    try:
+        subprocess.run(
+            ["systemctl", "--user", "disable", SERVICE_NAME],
+            capture_output=True, timeout=5,
+        )
+        subprocess.run(
+            ["systemctl", "--user", "stop", SERVICE_NAME],
+            capture_output=True, timeout=5,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        pass
+
+    if SERVICE_PATH.exists():
+        SERVICE_PATH.unlink()
+        log.info("Removed %s", SERVICE_PATH)
+
+    try:
+        subprocess.run(
+            ["systemctl", "--user", "daemon-reload"],
+            capture_output=True, timeout=5,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        pass
+
+    return True
+
+
+def is_installed() -> bool:
+    """Check if the systemd service is installed."""
+    return SERVICE_PATH.exists()
+
+
+def is_running() -> bool:
+    """Check if the systemd service is currently running."""
+    try:
+        result = subprocess.run(
+            ["systemctl", "--user", "is-active", SERVICE_NAME],
+            capture_output=True, text=True, timeout=3,
+        )
+        return result.stdout.strip() == "active"
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def start_service() -> bool:
+    """Start the voiceio systemd user service."""
+    try:
+        result = subprocess.run(
+            ["systemctl", "--user", "start", SERVICE_NAME],
+            capture_output=True, timeout=5,
+        )
+        return result.returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def _is_pipx_install() -> bool:
+    """Check if voiceio is running from a pipx-managed venv."""
+    return "pipx/venvs" in sys.prefix
+
+
+def _local_bin_on_path() -> bool:
+    """Check if LOCAL_BIN is in the current PATH."""
+    path_dirs = os.environ.get("PATH", "").split(os.pathsep)
+    return str(LOCAL_BIN) in path_dirs or str(LOCAL_BIN.resolve()) in path_dirs
+
+
+def install_symlinks() -> list[str]:
+    """Create symlinks in ~/.local/bin/ pointing to venv scripts.
+
+    Returns list of names successfully linked.
+    For pipx installs, scripts are already in ~/.local/bin/ as real files,
+    so we skip symlink creation.
+    """
+    if _is_pipx_install():
+        # pipx already placed scripts in ~/.local/bin/, nothing to do
+        return [name for name in SCRIPT_NAMES if (LOCAL_BIN / name).exists()]
+
+    venv_bin = Path(sys.prefix) / "bin"
+    LOCAL_BIN.mkdir(parents=True, exist_ok=True)
+    linked = []
+    for name in SCRIPT_NAMES:
+        src = venv_bin / name
+        dest = LOCAL_BIN / name
+        if not src.exists():
+            continue
+        # Already correct
+        if dest.is_symlink() and dest.resolve() == src.resolve():
+            linked.append(name)
+            continue
+        # Remove stale symlink; skip regular files
+        if dest.exists() or dest.is_symlink():
+            if not dest.is_symlink():
+                log.warning("Skipping %s: regular file exists at %s", name, dest)
+                continue
+            dest.unlink()
+        dest.symlink_to(src.resolve())
+        log.info("Linked %s → %s", dest, src.resolve())
+        linked.append(name)
+
+    # On macOS (or any system where ~/.local/bin isn't on PATH), add it to shell profile
+    if linked and not _local_bin_on_path():
+        _add_local_bin_to_path()
+
+    return linked
+
+
+def _add_local_bin_to_path() -> None:
+    """Add ~/.local/bin to PATH via shell profile (for macOS etc.)."""
+    global _PATH_HINT_ADDED
+    line = '\nexport PATH="$HOME/.local/bin:$PATH"\n'
+    # Try .zshrc first (macOS default), then .bashrc
+    for rc_name in (".zshrc", ".bashrc", ".profile"):
+        rc = Path.home() / rc_name
+        if rc.exists():
+            content = rc.read_text()
+            if ".local/bin" in content:
+                return  # already there
+            rc.write_text(content + line)
+            log.info("Added ~/.local/bin to PATH in %s", rc)
+            _PATH_HINT_ADDED = True
+            return
+    # No shell rc found, create .profile
+    rc = Path.home() / ".profile"
+    rc.write_text(line)
+    log.info("Created %s with PATH entry", rc)
+    _PATH_HINT_ADDED = True
+
+
+def symlinks_installed() -> bool:
+    """Check if voiceio is accessible as a command."""
+    # Check if it's anywhere on PATH
+    if shutil.which("voiceio"):
+        return True
+    # Check if symlink exists (even if not on PATH yet, a new shell will pick it up)
+    dest = LOCAL_BIN / "voiceio"
+    return dest.exists()
+
+
+def path_hint_needed() -> bool:
+    """Return True if we modified shell profile and user needs to restart shell."""
+    return _PATH_HINT_ADDED

voiceio/streaming.py

@@ -0,0 +1,202 @@
+"""Streaming transcription with word-level append and final correction."""
+from __future__ import annotations
+
+import logging
+import re
+import threading
+import time
+from typing import TYPE_CHECKING
+
+from voiceio.transcriber import TRANSCRIBE_TIMEOUT
+from voiceio.typers.base import StreamingTyper
+
+if TYPE_CHECKING:
+    from voiceio.recorder import AudioRecorder
+    from voiceio.transcriber import Transcriber
+    from voiceio.typers.base import TyperBackend
+
+log = logging.getLogger(__name__)
+DELETE_SETTLE_SECS = 0.05  # delay between delete and type for ydotool reliability
+
+
+def _common_prefix_len(a: str, b: str) -> int:
+    """Length of the longest common prefix between two strings."""
+    limit = min(len(a), len(b))
+    for i in range(limit):
+        if a[i] != b[i]:
+            return i
+    return limit
+
+
+def _clean_word(w: str) -> str:
+    """Strip punctuation for fuzzy word matching."""
+    return re.sub(r'[^\w]', '', w).lower()
+
+
+def _word_match_len(old_words: list[str], new_words: list[str]) -> int:
+    """Count matching leading words, ignoring punctuation/case."""
+    count = 0
+    for o, n in zip(old_words, new_words):
+        if _clean_word(o) == _clean_word(n):
+            count += 1
+        else:
+            break
+    return count
+
+
+class StreamingSession:
+    """Manages one streaming transcription cycle.
+
+    During streaming: append-only with word-level fuzzy matching.
+    Whisper changes punctuation/capitalization between passes, so word-level
+    matching ignores these, so text keeps growing even when Whisper
+    flip-flops on commas vs periods.
+
+    On stop: one final char-level diff correction to fix accumulated drift.
+    """
+
+    def __init__(
+        self,
+        transcriber: Transcriber,
+        typer: TyperBackend,
+        recorder: AudioRecorder,
+    ):
+        self._transcriber = transcriber
+        self._typer = typer
+        self._recorder = recorder
+        self._typed_text = ""
+        self._pending = threading.Event()
+        self._stop = threading.Event()
+        self._worker_thread: threading.Thread | None = None
+
+    def start(self) -> None:
+        """Begin streaming. Recorder must already be started by caller."""
+        self._recorder.set_on_speech_pause(self._on_vad_pause)
+        self._worker_thread = threading.Thread(
+            target=self._worker_loop, daemon=True,
+        )
+        self._worker_thread.start()
+        log.debug("Streaming session started")
+
+    def stop(self) -> str:
+        """Stop streaming, run final transcription, return full text."""
+        self._stop.set()
+        self._pending.set()  # wake worker for final pass
+        if self._worker_thread is not None:
+            self._worker_thread.join(timeout=TRANSCRIBE_TIMEOUT + 2)
+        self._recorder.set_on_speech_pause(None)
+        log.debug("Streaming session stopped, typed: '%s'", self._typed_text)
+        return self._typed_text
+
+    def _on_vad_pause(self) -> None:
+        """Called from audio thread on speech pause. Signals worker."""
+        self._pending.set()
+
+    def _worker_loop(self) -> None:
+        """Worker thread: wake on Event, transcribe, apply diff."""
+        while not self._stop.is_set():
+            self._pending.wait(timeout=1.0)
+            self._pending.clear()
+            if self._stop.is_set():
+                break
+            self._transcribe_and_apply()
+
+        # Final transcription on stop: allow full correction
+        self._transcribe_and_apply(min_seconds=0.5, final=True)
+
+    def _transcribe_and_apply(
+        self, min_seconds: float = 1.0, final: bool = False,
+    ) -> None:
+        """Get all audio so far, transcribe, apply correction."""
+        audio = self._recorder.get_audio_so_far()
+        if audio is None:
+            return
+        if len(audio) < self._recorder.sample_rate * min_seconds:
+            return
+
+        try:
+            text = self._transcriber.transcribe(audio)
+        except Exception:
+            log.exception("Streaming transcription failed")
+            return
+
+        if text:
+            self._apply_correction(text, final=final)
+
+    def _apply_correction(self, new_text: str, final: bool = False) -> None:
+        """Apply correction to typed text.
+
+        With StreamingTyper (IBus): use preedit during streaming, commit on final.
+        Without: append-only via word-level matching, char-level diff on final.
+        """
+        old = self._typed_text
+
+        # Preedit path: trivial, just replace the preview text
+        if isinstance(self._typer, StreamingTyper):
+            if final:
+                # Always commit: preedit is just preview, clipboard paste is delivery
+                self._typer.commit_text(new_text)
+                self._typed_text = new_text
+                log.debug("Preedit commit: '%s'", new_text[:60])
+            elif new_text != old:
+                self._typer.update_preedit(new_text)
+                self._typed_text = new_text
+                log.debug("Preedit update: '%s'", new_text[:60])
+            return
+
+        if new_text == old:
+            return
+
+        if final:
+            self._apply_final_correction(new_text)
+            return
+
+        if not old:
+            # First transcription, just type it
+            self._typer.type_text(new_text)
+            self._typed_text = new_text
+            log.debug("Initial: '%s'", new_text)
+            return
+
+        # Short text: allow full replacement (Whisper still warming up)
+        if len(old.split()) <= 2:
+            self._typer.delete_chars(len(old))
+            time.sleep(DELETE_SETTLE_SECS)
+            self._typer.type_text(new_text)
+            self._typed_text = new_text
+            log.debug("Replaced short text: '%s'", new_text)
+            return
+
+        # Word-level append-only
+        old_words = old.split()
+        new_words = new_text.split()
+        matched = _word_match_len(old_words, new_words)
+
+        if matched >= len(old_words) and len(new_words) > matched:
+            # All our typed words match, so append the new ones
+            new_tail = " ".join(new_words[matched:])
+            to_type = " " + new_tail
+            self._typer.type_text(to_type)
+            self._typed_text = old + to_type
+            log.debug("Appended: '%s'", to_type.strip())
+        else:
+            log.debug(
+                "Skipping (matched %d/%d words)",
+                matched, len(old_words),
+            )
+
+    def _apply_final_correction(self, new_text: str) -> None:
+        """Final pass: char-level diff to fix accumulated drift."""
+        old = self._typed_text
+        prefix_len = _common_prefix_len(old, new_text)
+        to_delete = len(old) - prefix_len
+        to_type = new_text[prefix_len:]
+
+        if to_delete > 0:
+            log.debug("Final correction: delete %d, type '%s'", to_delete, to_type)
+            self._typer.delete_chars(to_delete)
+            time.sleep(DELETE_SETTLE_SECS)  # let deletions settle
+        if to_type:
+            self._typer.type_text(to_type)
+
+        self._typed_text = new_text

voiceio/transcriber.py

@@ -0,0 +1,165 @@
+"""Subprocess-isolated faster-whisper transcriber with crash recovery."""
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import subprocess
+import sys
+import threading
+import time
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from voiceio.config import ModelConfig
+
+log = logging.getLogger(__name__)
+
+TRANSCRIBE_TIMEOUT = 30  # seconds
+MAX_RESTARTS = 3
+
+
+class Transcriber:
+    def __init__(self, cfg: ModelConfig):
+        self._cfg = cfg
+        self._proc: subprocess.Popen | None = None
+        self._lock = threading.Lock()
+        self._restarts = 0
+        self._start_worker()
+
+    def _start_worker(self) -> None:
+        log.info(
+            "Loading model '%s' (device=%s, compute_type=%s)...",
+            self._cfg.name, self._cfg.device, self._cfg.compute_type,
+        )
+        language = self._cfg.language if self._cfg.language != "auto" else None
+
+        args = json.dumps({
+            "model": self._cfg.name,
+            "device": self._cfg.device,
+            "compute_type": self._cfg.compute_type,
+            "language": language,
+        })
+        from voiceio.config import LOG_DIR
+        LOG_DIR.mkdir(parents=True, exist_ok=True)
+        self._stderr_path = LOG_DIR / "worker.log"
+        self._stderr_file = open(self._stderr_path, "w")
+        self._proc = subprocess.Popen(
+            [sys.executable, "-m", "voiceio.worker", args],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=self._stderr_file,
+            text=True,
+        )
+
+        t0 = time.monotonic()
+        ready = self._proc.stdout.readline().strip()
+        if ready != "READY":
+            raise RuntimeError(f"Worker failed to start: {ready}")
+        elapsed = time.monotonic() - t0
+        log.info("Model ready (%.1fs)", elapsed)
+
+    def _ensure_worker(self) -> None:
+        """Restart worker if it has died."""
+        if self._proc is not None and self._proc.poll() is None:
+            return
+        if hasattr(self, "_stderr_path") and self._stderr_path.exists():
+            try:
+                stderr = self._stderr_path.read_text().strip()
+                if stderr:
+                    log.error("Worker stderr: %s", stderr[-500:])
+            except OSError:
+                pass
+        if self._restarts >= MAX_RESTARTS:
+            raise RuntimeError(f"Transcriber worker crashed {MAX_RESTARTS} times, giving up")
+        self._restarts += 1
+        log.warning("Worker died, restarting (attempt %d/%d)", self._restarts, MAX_RESTARTS)
+        self._start_worker()
+
+    def transcribe(self, audio: np.ndarray) -> str:
+        with self._lock:
+            self._ensure_worker()
+
+            duration = len(audio) / 16000
+            t0 = time.monotonic()
+
+            audio_b64 = base64.b64encode(audio.tobytes()).decode("ascii")
+            try:
+                self._proc.stdin.write(json.dumps({"audio_b64": audio_b64}) + "\n")
+                self._proc.stdin.flush()
+            except (BrokenPipeError, OSError):
+                log.warning("Worker pipe broken, restarting")
+                self._kill_worker()
+                self._ensure_worker()
+                self._proc.stdin.write(json.dumps({"audio_b64": audio_b64}) + "\n")
+                self._proc.stdin.flush()
+
+            # Read with timeout
+            result_line = self._read_with_timeout(TRANSCRIBE_TIMEOUT)
+            if result_line is None:
+                log.warning("Transcription timed out after %ds, restarting worker", TRANSCRIBE_TIMEOUT)
+                self._kill_worker()
+                self._ensure_worker()
+                return ""
+
+            try:
+                result = json.loads(result_line)
+            except (json.JSONDecodeError, TypeError):
+                log.warning("Invalid response from worker: %s", repr(result_line)[:100])
+                return ""
+            text = result.get("text", "")
+
+            elapsed = time.monotonic() - t0
+            ratio = duration / elapsed if elapsed > 0 else 999
+            log.info(
+                "Transcribed %.1fs audio in %.1fs (%.1fx realtime): %s",
+                duration, elapsed, ratio, text or "(silence)",
+            )
+            # Reset restart counter on success
+            self._restarts = 0
+            return text
+
+    def _read_with_timeout(self, timeout: float) -> str | None:
+        """Read a line from stdout with a timeout."""
+        result = [None]
+
+        def read():
+            try:
+                result[0] = self._proc.stdout.readline()
+            except (OSError, ValueError):
+                pass
+
+        t = threading.Thread(target=read, daemon=True)
+        t.start()
+        t.join(timeout)
+        if t.is_alive():
+            return None
+        return result[0]
+
+    def _kill_worker(self) -> None:
+        if self._proc is not None:
+            try:
+                self._proc.terminate()
+                self._proc.wait(timeout=2)
+            except (subprocess.TimeoutExpired, OSError):
+                self._proc.kill()
+            self._proc = None
+        if hasattr(self, "_stderr_file") and self._stderr_file:
+            self._stderr_file.close()
+            self._stderr_file = None
+
+    def shutdown(self) -> None:
+        """Graceful shutdown."""
+        if self._proc is not None and self._proc.poll() is None:
+            try:
+                self._proc.stdin.write("QUIT\n")
+                self._proc.stdin.flush()
+                self._proc.wait(timeout=2)
+            except (BrokenPipeError, OSError, subprocess.TimeoutExpired):
+                self._proc.terminate()
+            self._proc = None
+
+    def __del__(self):
+        self._kill_worker()

voiceio/tray.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import logging
+import threading
+
+log = logging.getLogger(__name__)
+
+_icon = None
+_thread = None
+
+
+def _make_icon(color: str):
+    from PIL import Image, ImageDraw
+
+    img = Image.new("RGBA", (64, 64), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+    fill = {"idle": (120, 120, 120, 255), "recording": (220, 40, 40, 255)}[color]
+    draw.ellipse([8, 8, 56, 56], fill=fill)
+    return img
+
+
+def start(quit_callback) -> None:
+    global _icon, _thread
+
+    try:
+        import pystray
+    except ImportError:
+        log.warning("pystray not installed, tray icon disabled. Install with: pip install voiceio[tray]")
+        return
+
+    _icon = pystray.Icon(
+        "voiceio",
+        icon=_make_icon("idle"),
+        title="voiceio - idle",
+        menu=pystray.Menu(pystray.MenuItem("Quit", lambda: quit_callback())),
+    )
+
+    _thread = threading.Thread(target=_icon.run, daemon=True)
+    _thread.start()
+
+
+def set_recording(recording: bool) -> None:
+    if _icon is None:
+        return
+    state = "recording" if recording else "idle"
+    _icon.icon = _make_icon(state)
+    _icon.title = f"voiceio - {state}"
+
+
+def stop() -> None:
+    global _icon
+    if _icon:
+        _icon.stop()
+        _icon = None

voiceio/typers/__init__.py

@@ -0,0 +1,31 @@
+"""Text injection backends."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from voiceio.platform import Platform
+    from voiceio.typers.base import TyperBackend
+
+
+def create_typer_backend(name: str, platform: Platform, **kwargs) -> TyperBackend:
+    """Create a typer backend by name."""
+    if name == "xdotool":
+        from voiceio.typers.xdotool import XdotoolTyper
+        return XdotoolTyper()
+    if name == "ydotool":
+        from voiceio.typers.ydotool import YdotoolTyper
+        return YdotoolTyper()
+    if name == "wtype":
+        from voiceio.typers.wtype import WtypeTyper
+        return WtypeTyper()
+    if name == "clipboard":
+        from voiceio.typers.clipboard import ClipboardTyper
+        return ClipboardTyper()
+    if name == "pynput":
+        from voiceio.typers.pynput_type import PynputTyper
+        return PynputTyper()
+    if name == "ibus":
+        from voiceio.typers.ibus import IBusTyper
+        return IBusTyper(platform, **kwargs)
+    raise ValueError(f"Unknown typer backend: {name}")