python-voiceio 0.2.0__py3-none-any.whl

voiceio/ibus/engine.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""VoiceIO IBus engine: receives commands via Unix socket, injects text via IBus.
+
+Run as a standalone process:
+    python3 -m voiceio.ibus.engine
+
+Architecture:
+    - GLib main loop drives the IBus engine (required by IBus).
+    - Socket listener thread receives commands from voiceio daemon.
+    - Commands are dispatched to the engine via GLib.idle_add() for thread safety.
+"""
+from __future__ import annotations
+
+import logging
+import logging.handlers
+import os
+import socket
+import sys
+import threading
+from pathlib import Path
+
+import gi
+
+gi.require_version("IBus", "1.0")
+from gi.repository import GLib, GObject, IBus
+
+from voiceio.ibus import READY_PATH, SOCKET_PATH
+
+log = logging.getLogger(__name__)
+ENGINE_NAME = "voiceio"
+COMPONENT_NAME = "org.voiceio.ibus"
+
+
+class VoiceIOEngine(IBus.Engine):
+    """IBus engine that receives text injection commands via socket."""
+
+    __gtype_name__ = "VoiceIOEngine"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._focused = False
+        log.info("VoiceIOEngine instance created (path=%s)", kwargs.get("object_path"))
+
+    def do_focus_in(self):
+        self._focused = True
+
+    def do_focus_out(self):
+        self._focused = False
+
+    def do_process_key_event(self, keyval, keycode, state):
+        # CRITICAL: Always pass all keys through. Never intercept typing.
+        # If this ever returns True (or raises), ALL keyboard input dies system-wide.
+        try:
+            return False
+        except Exception:
+            return False
+
+    def preedit(self, text: str) -> None:
+        """Show text as preedit (underlined preview)."""
+        if not text:
+            self.hide_preedit_text()
+            return
+        ibus_text = IBus.Text.new_from_string(text)
+        ibus_text.append_attribute(
+            IBus.AttrType.UNDERLINE,
+            IBus.AttrUnderline.SINGLE,
+            0,
+            len(text),
+        )
+        self.update_preedit_text(ibus_text, len(text), True)
+
+    def commit(self, text: str) -> None:
+        """Clear preedit and commit final text."""
+        self.hide_preedit_text()
+        if text:
+            self.commit_text(IBus.Text.new_from_string(text))
+
+    def clear(self) -> None:
+        """Clear preedit without committing."""
+        self.hide_preedit_text()
+
+
+class VoiceIOEngineFactory(IBus.Factory):
+    """Custom factory that creates engine instances with proper D-Bus object paths."""
+
+    __gtype_name__ = "VoiceIOEngineFactory"
+    _engine_count = 0
+
+    def __init__(self, bus):
+        self._bus = bus
+        super().__init__(
+            object_path=IBus.PATH_FACTORY,
+            connection=bus.get_connection(),
+        )
+        log.info("VoiceIOEngineFactory created")
+
+    def do_create_engine(self, engine_name):
+        global _engine
+        VoiceIOEngineFactory._engine_count += 1
+        obj_path = f"/org/freedesktop/IBus/Engine/{VoiceIOEngineFactory._engine_count}"
+        log.info("Creating engine '%s' at %s", engine_name, obj_path)
+        engine = VoiceIOEngine(
+            engine_name=engine_name,
+            object_path=obj_path,
+            connection=self._bus.get_connection(),
+        )
+        _engine = engine
+        # Signal readiness to the voiceio daemon
+        try:
+            READY_PATH.write_text(str(os.getpid()))
+            log.info("Engine ready signal written to %s", READY_PATH)
+        except OSError:
+            pass
+        return engine
+
+
+# Global engine reference (set when factory creates the engine)
+_engine: VoiceIOEngine | None = None
+_pending_commands: list[str] = []
+
+
+def _socket_listener(mainloop: GLib.MainLoop) -> None:
+    """Listen for commands on Unix DGRAM socket. Runs in a thread."""
+    SOCKET_PATH.unlink(missing_ok=True)
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+    sock.bind(str(SOCKET_PATH))
+    sock.settimeout(1.0)
+    log.info("Socket listener started at %s", SOCKET_PATH)
+
+    while mainloop.is_running():
+        try:
+            data, addr = sock.recvfrom(65536)
+        except socket.timeout:
+            continue
+        except OSError:
+            break
+
+        msg = data.decode("utf-8", errors="replace")
+        log.debug("Received: %s", msg[:80])
+
+        if msg == "ping":
+            # Respond to probe: send pong back
+            if addr:
+                try:
+                    sock.sendto(b"pong", addr)
+                except OSError:
+                    pass
+            continue
+
+        # Dispatch to engine on GLib main thread
+        GLib.idle_add(_handle_command, msg)
+
+    sock.close()
+    SOCKET_PATH.unlink(missing_ok=True)
+
+
+def _flush_pending() -> None:
+    """Replay any commands that arrived before the engine was ready."""
+    while _pending_commands:
+        _dispatch(_pending_commands.pop(0))
+
+
+def _dispatch(msg: str) -> None:
+    """Execute a single command on the engine."""
+    try:
+        if msg.startswith("preedit:"):
+            _engine.preedit(msg[8:])
+        elif msg.startswith("commit:"):
+            _engine.commit(msg[7:])
+        elif msg == "clear":
+            _engine.clear()
+        else:
+            log.warning("Unknown command: %s", msg[:40])
+    except Exception:
+        log.exception("Error dispatching command: %s", msg[:40])
+
+
+def _handle_command(msg: str) -> bool:
+    """Handle a command on the GLib main thread. Returns False to remove from idle."""
+    if _engine is None:
+        log.debug("Engine not ready, buffering command: %s", msg[:40])
+        _pending_commands.append(msg)
+        return False
+
+    # Flush any buffered commands first
+    if _pending_commands:
+        log.info("Engine ready, flushing %d buffered commands", len(_pending_commands))
+        _flush_pending()
+
+    _dispatch(msg)
+    return False  # run once, don't repeat
+
+
+def main() -> None:
+    # Log to file so we can debug when IBus spawns us
+    log_path = Path(os.environ.get("XDG_RUNTIME_DIR", "/tmp")) / "voiceio-ibus-engine.log"
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+        handlers=[
+            logging.StreamHandler(),
+            logging.handlers.RotatingFileHandler(
+                str(log_path), maxBytes=1_000_000, backupCount=1,
+            ),
+        ],
+    )
+
+    IBus.init()
+    bus = IBus.Bus()
+
+    if not bus.is_connected():
+        log.error("Cannot connect to IBus daemon. Is IBus running?")
+        sys.exit(1)
+
+    # Register GTypes
+    GObject.type_register(VoiceIOEngine)
+    GObject.type_register(VoiceIOEngineFactory)
+
+    # Create custom factory (registers on D-Bus at IBus.PATH_FACTORY)
+    VoiceIOEngineFactory(bus)  # registers on D-Bus at IBus.PATH_FACTORY
+
+    # Register component so IBus knows about our engine
+    component = IBus.Component.new(
+        COMPONENT_NAME,
+        "VoiceIO voice input",
+        "1.0",
+        "MIT",
+        "voiceio",
+        "",
+        "",
+        "voiceio",
+    )
+    engine_desc = IBus.EngineDesc.new(
+        ENGINE_NAME,
+        "VoiceIO",
+        "Voice-to-text input",
+        "other",
+        "MIT",
+        "voiceio",
+        "",
+        "us",
+    )
+    component.add_engine(engine_desc)
+    bus.register_component(component)
+
+    log.info("VoiceIO IBus engine registered with custom factory")
+    bus.request_name(COMPONENT_NAME, 0)
+
+    mainloop = GLib.MainLoop()
+
+    # Start socket listener in background thread
+    listener = threading.Thread(
+        target=_socket_listener, args=(mainloop,), daemon=True,
+    )
+    listener.start()
+
+    try:
+        mainloop.run()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        SOCKET_PATH.unlink(missing_ok=True)
+        READY_PATH.unlink(missing_ok=True)
+        log.info("VoiceIO IBus engine stopped")
+
+
+if __name__ == "__main__":
+    main()

voiceio/platform.py

@@ -0,0 +1,139 @@
+"""Platform detection: OS, display server, desktop environment, available tools."""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from dataclasses import dataclass
+from functools import lru_cache
+
+
+@dataclass(frozen=True)
+class Platform:
+    os: str                    # "linux", "darwin", "windows"
+    display_server: str        # "x11", "wayland", "quartz", "unknown"
+    desktop: str               # "gnome", "kde", "sway", "hyprland", "macos", "unknown"
+
+    # Tool availability
+    has_xdotool: bool = False
+    has_ydotool: bool = False
+    has_wtype: bool = False
+    has_xclip: bool = False
+    has_wl_copy: bool = False
+    has_dotool: bool = False
+    has_ibus: bool = False
+
+    # Permissions
+    has_input_group: bool = False
+    has_uinput_access: bool = False
+
+    @property
+    def is_linux(self) -> bool:
+        return self.os == "linux"
+
+    @property
+    def is_mac(self) -> bool:
+        return self.os == "darwin"
+
+    @property
+    def is_wayland(self) -> bool:
+        return self.display_server == "wayland"
+
+    @property
+    def is_x11(self) -> bool:
+        return self.display_server == "x11"
+
+    @property
+    def is_gnome(self) -> bool:
+        return self.desktop in ("gnome", "unity")
+
+
+def _detect_os() -> str:
+    if sys.platform.startswith("linux"):
+        return "linux"
+    if sys.platform == "darwin":
+        return "darwin"
+    if sys.platform == "win32":
+        return "windows"
+    return "unknown"
+
+
+def _detect_display_server() -> str:
+    plat = _detect_os()
+    if plat == "darwin":
+        return "quartz"
+    if plat == "windows":
+        return "unknown"
+
+    session = os.environ.get("XDG_SESSION_TYPE", "").lower()
+    if session == "wayland":
+        return "wayland"
+    if session == "x11":
+        return "x11"
+
+    # Fallback heuristics
+    if os.environ.get("WAYLAND_DISPLAY"):
+        return "wayland"
+    if os.environ.get("DISPLAY"):
+        return "x11"
+
+    return "unknown"
+
+
+def _detect_desktop() -> str:
+    plat = _detect_os()
+    if plat == "darwin":
+        return "macos"
+
+    raw = os.environ.get("XDG_CURRENT_DESKTOP", "").lower()
+
+    if "gnome" in raw:
+        return "gnome"
+    if "kde" in raw or "plasma" in raw:
+        return "kde"
+    if "sway" in raw:
+        return "sway"
+    if "hyprland" in raw:
+        return "hyprland"
+    if raw:
+        return raw.split(":")[0]  # take first component
+
+    return "unknown"
+
+
+def _check_input_group() -> bool:
+    try:
+        import grp
+        input_gid = grp.getgrnam("input").gr_gid
+        return input_gid in os.getgroups()
+    except (KeyError, ImportError):
+        return False
+
+
+def _check_uinput_access() -> bool:
+    try:
+        with open("/dev/uinput", "rb"):
+            pass
+        return True
+    except (PermissionError, FileNotFoundError, OSError):
+        return False
+
+
+@lru_cache(maxsize=1)
+def detect() -> Platform:
+    """Detect the current platform. Cached, safe to call multiple times."""
+    plat_os = _detect_os()
+    return Platform(
+        os=plat_os,
+        display_server=_detect_display_server(),
+        desktop=_detect_desktop(),
+        has_xdotool=shutil.which("xdotool") is not None,
+        has_ydotool=shutil.which("ydotool") is not None,
+        has_wtype=shutil.which("wtype") is not None,
+        has_xclip=shutil.which("xclip") is not None,
+        has_wl_copy=shutil.which("wl-copy") is not None,
+        has_dotool=shutil.which("dotool") is not None,
+        has_ibus=shutil.which("ibus") is not None,
+        has_input_group=_check_input_group() if plat_os == "linux" else False,
+        has_uinput_access=_check_uinput_access() if plat_os == "linux" else False,
+    )

voiceio/recorder.py

@@ -0,0 +1,208 @@
+"""Audio capture with pre-buffer ring to prevent clipping."""
+from __future__ import annotations
+
+import logging
+import threading
+from typing import TYPE_CHECKING, Callable
+
+import numpy as np
+import sounddevice as sd
+
+if TYPE_CHECKING:
+    from voiceio.config import AudioConfig
+
+log = logging.getLogger(__name__)
+
+
+class RingBuffer:
+    """Fixed-size ring buffer for float32 audio samples."""
+
+    def __init__(self, max_samples: int):
+        self._buf = np.zeros(max_samples, dtype=np.float32)
+        self._max = max_samples
+        self._write_pos = 0
+        self._filled = 0
+
+    def append(self, data: np.ndarray) -> None:
+        if self._max == 0:
+            return
+        flat = data.flatten()
+        n = len(flat)
+        if n >= self._max:
+            # Data larger than buffer: just keep the tail
+            self._buf[:] = flat[-self._max:]
+            self._write_pos = 0
+            self._filled = self._max
+            return
+
+        end = self._write_pos + n
+        if end <= self._max:
+            self._buf[self._write_pos:end] = flat
+        else:
+            first = self._max - self._write_pos
+            self._buf[self._write_pos:] = flat[:first]
+            self._buf[:n - first] = flat[first:]
+
+        self._write_pos = end % self._max
+        self._filled = min(self._filled + n, self._max)
+
+    def get(self) -> np.ndarray:
+        """Return buffered audio in chronological order."""
+        if self._filled == 0:
+            return np.zeros(0, dtype=np.float32)
+        if self._filled < self._max:
+            return self._buf[:self._filled].copy()
+        # Full ring: read from write_pos (oldest) through the end
+        return np.concatenate([
+            self._buf[self._write_pos:],
+            self._buf[:self._write_pos],
+        ])
+
+    def clear(self) -> None:
+        self._write_pos = 0
+        self._filled = 0
+
+
+class AudioRecorder:
+    """Audio recorder with always-on pre-buffer ring.
+
+    The audio stream runs continuously. A ring buffer captures the last
+    `prebuffer_secs` of audio. When recording starts, the ring buffer
+    contents become the start of the recording, so no first syllable is lost.
+    """
+
+    def __init__(self, cfg: AudioConfig, on_speech_pause: Callable[[], None] | None = None):
+        self.sample_rate = cfg.sample_rate
+        self.device = None if cfg.device == "default" else cfg.device
+        self.prebuffer_secs = cfg.prebuffer_secs
+
+        self._ring = RingBuffer(int(self.prebuffer_secs * self.sample_rate))
+        self._chunks: list[np.ndarray] = []
+        self._stream: sd.InputStream | None = None
+        self._lock = threading.Lock()
+        self._recording = False
+
+        # Streaming VAD
+        self._on_speech_pause = on_speech_pause
+        self._silence_threshold = cfg.silence_threshold
+        self._silence_duration = cfg.silence_duration
+        self._silent_chunks = 0.0
+        self._last_transcribed_len = 0
+        self._total_samples = 0
+
+    def open_stream(self) -> None:
+        """Start the always-on audio stream (feeds ring buffer)."""
+        if self._stream is not None:
+            return
+        self._stream = sd.InputStream(
+            samplerate=self.sample_rate,
+            channels=1,
+            dtype="float32",
+            device=self.device,
+            callback=self._callback,
+        )
+        self._stream.start()
+        log.debug("Audio stream opened (prebuffer=%.1fs)", self.prebuffer_secs)
+
+    def close_stream(self) -> None:
+        """Stop the always-on audio stream."""
+        if self._stream is not None:
+            self._stream.stop()
+            self._stream.close()
+            self._stream = None
+            self._ring.clear()
+
+    def start(self) -> None:
+        """Start recording. Grabs ring buffer contents as the beginning."""
+        with self._lock:
+            if self._recording:
+                return
+            # Ensure stream is running
+            if self._stream is None:
+                self.open_stream()
+            # Grab pre-buffer
+            prebuf = self._ring.get()
+            self._chunks = [prebuf.reshape(-1, 1)] if len(prebuf) > 0 else []
+            self._total_samples = sum(len(c) for c in self._chunks)
+            self._silent_chunks = 0.0
+            self._last_transcribed_len = 0
+            self._recording = True
+            prebuf_ms = len(prebuf) / self.sample_rate * 1000
+            log.info("Recording started (%.0fms pre-buffer)", prebuf_ms)
+
+    def stop(self) -> np.ndarray | None:
+        """Stop recording, return captured audio."""
+        with self._lock:
+            if not self._recording:
+                return None
+            self._recording = False
+
+            if not self._chunks:
+                log.warning("No audio captured")
+                return None
+
+            audio = np.concatenate(self._chunks, axis=0).flatten()
+            remaining = audio[self._last_transcribed_len:]
+            duration = len(remaining) / self.sample_rate
+
+            if duration < 0.3:
+                if self._last_transcribed_len > 0:
+                    return None
+                log.warning("Audio too short (%.1fs), skipping", duration)
+                return None
+
+            log.info("Recording stopped, %.1fs audio", duration)
+            return remaining
+
+    def get_audio_so_far(self) -> np.ndarray | None:
+        """Get all audio captured so far (for streaming)."""
+        with self._lock:
+            if not self._chunks:
+                return None
+            return np.concatenate(self._chunks, axis=0).flatten()
+
+    def set_on_speech_pause(self, callback: Callable[[], None] | None) -> None:
+        """Set/clear the speech pause callback (used by streaming session)."""
+        self._on_speech_pause = callback
+
+    def mark_transcribed(self, num_samples: int) -> None:
+        self._last_transcribed_len = num_samples
+
+    @property
+    def is_recording(self) -> bool:
+        return self._recording
+
+    def _callback(
+        self, indata: np.ndarray, frames: int, time_info: object, status: object
+    ) -> None:
+        if status:
+            log.warning("Audio stream status: %s", status)
+
+        # Always feed ring buffer
+        self._ring.append(indata)
+
+        # Only collect chunks when recording
+        if not self._recording:
+            return
+
+        chunk = indata.copy()
+        self._chunks.append(chunk)
+        self._total_samples += chunk.shape[0]
+
+        # Streaming VAD
+        if self._on_speech_pause is not None:
+            flat = indata.ravel()
+            rms = float(np.sqrt(np.dot(flat, flat) / len(flat)))
+            chunk_secs = frames / self.sample_rate
+
+            if rms < self._silence_threshold:
+                self._silent_chunks += chunk_secs
+            else:
+                self._silent_chunks = 0.0
+
+            has_new = self._total_samples > self._last_transcribed_len + self.sample_rate
+
+            if self._silent_chunks >= self._silence_duration and has_new:
+                self._silent_chunks = 0.0
+                # Signal pause. Don't concatenate on the audio thread.
+                self._on_speech_pause()