python-voiceio 0.2.1__tar.gz → 0.2.3__tar.gz

{python_voiceio-0.2.1/python_voiceio.egg-info → python_voiceio-0.2.3}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.2.1
-Summary: Push-to-talk voice-to-text for Linux. Press a hotkey, speak, press again - text appears at your cursor.
+Version: 0.2.3
+Summary: Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/Hugo0/voiceio
@@ -39,9 +39,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)
 
-Push-to-talk voice-to-text for Linux and macOS, on any app. Press a hotkey, speak, press again - text appears at your cursor.
-
-100% local and open source. No API keys, no cloud, no telemetry. Use and modify at your will.
+Speak → text, locally, instantly.
 
 <!-- demo video -->
 <p align="center">

{python_voiceio-0.2.1 → python_voiceio-0.2.3}/README.md

@@ -5,9 +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)
 
-Push-to-talk voice-to-text for Linux and macOS, on any app. Press a hotkey, speak, press again - text appears at your cursor.
-
-100% local and open source. No API keys, no cloud, no telemetry. Use and modify at your will.
+Speak → text, locally, instantly.
 
 <!-- demo video -->
 <p align="center">

{python_voiceio-0.2.1 → python_voiceio-0.2.3}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "0.2.1"
-description = "Push-to-talk voice-to-text for Linux. Press a hotkey, speak, press again - text appears at your cursor."
+version = "0.2.3"
+description = "Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.11"

{python_voiceio-0.2.1 → python_voiceio-0.2.3/python_voiceio.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.2.1
-Summary: Push-to-talk voice-to-text for Linux. Press a hotkey, speak, press again - text appears at your cursor.
+Version: 0.2.3
+Summary: Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/Hugo0/voiceio
@@ -39,9 +39,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)
 
-Push-to-talk voice-to-text for Linux and macOS, on any app. Press a hotkey, speak, press again - text appears at your cursor.
-
-100% local and open source. No API keys, no cloud, no telemetry. Use and modify at your will.
+Speak → text, locally, instantly.
 
 <!-- demo video -->
 <p align="center">

python_voiceio-0.2.3/tests/test_app_wiring.py

@@ -0,0 +1,139 @@
+"""Test that VoiceIO app wires up correctly with mocked backends."""
+from __future__ import annotations
+
+import threading
+import time
+from unittest.mock import MagicMock, patch
+
+import numpy as np
+import pytest
+
+from voiceio.config import Config
+
+
+def _make_vio(mock_transcriber=None):
+    """Create a VoiceIO instance with mocked backends."""
+    mock_hotkey = MagicMock()
+    mock_hotkey.name = "socket"
+    mock_typer = MagicMock()
+    mock_typer.name = "clipboard"
+    if mock_transcriber is None:
+        mock_transcriber = MagicMock()
+
+    with patch("voiceio.app.hotkey_chain.select", return_value=mock_hotkey), \
+         patch("voiceio.app.typer_chain.select", return_value=mock_typer), \
+         patch("voiceio.app.Transcriber", return_value=mock_transcriber), \
+         patch("voiceio.app.plat.detect") as mock_detect:
+        mock_detect.return_value = MagicMock(display_server="wayland", desktop="gnome")
+
+        from voiceio.app import VoiceIO
+        vio = VoiceIO(Config())
+        vio.recorder._stream = MagicMock()  # skip real audio
+        return vio, mock_typer, mock_transcriber
+
+
+class TestVoiceIOInit:
+    def test_init_with_mocked_backends(self):
+        vio, mock_typer, _ = _make_vio()
+        assert vio._typer is mock_typer
+
+    def test_on_hotkey_toggle_cycle(self):
+        mock_trans = MagicMock()
+        mock_trans.transcribe.return_value = "hello world"
+        vio, _, _ = _make_vio(mock_trans)
+
+        # Start recording
+        vio.on_hotkey()
+        assert vio.recorder.is_recording
+
+        # Feed some audio
+        for _ in range(20):
+            data = np.full((1024, 1), 0.3, dtype=np.float32)
+            vio.recorder._callback(data, 1024, None, None)
+
+        # Set record_start far back so debounce allows stop
+        vio._record_start = time.monotonic() - 5.0
+        vio._last_hotkey = time.monotonic() - 5.0
+
+        # Stop recording
+        vio.on_hotkey()
+        assert not vio.recorder.is_recording
+
+
+class TestHotkeyDebounce:
+    """Verify that duplicate hotkey events are properly debounced."""
+
+    def test_rapid_duplicate_ignored(self):
+        """Two on_hotkey calls within 0.3s should only trigger once."""
+        vio, _, _ = _make_vio()
+
+        vio.on_hotkey()
+        assert vio.recorder.is_recording
+
+        # Simulate duplicate from socket backend ~50ms later
+        vio.on_hotkey()
+        # Should still be recording (duplicate was debounced, not treated as stop)
+        assert vio.recorder.is_recording
+
+    def test_stop_after_debounce_window(self):
+        """on_hotkey after debounce window should stop recording."""
+        vio, _, _ = _make_vio()
+
+        vio.on_hotkey()
+        assert vio.recorder.is_recording
+
+        # Feed audio
+        for _ in range(20):
+            data = np.full((1024, 1), 0.3, dtype=np.float32)
+            vio.recorder._callback(data, 1024, None, None)
+
+        # Move timestamps back so debounce allows through
+        vio._record_start = time.monotonic() - 2.0
+        vio._last_hotkey = time.monotonic() - 2.0
+
+        vio.on_hotkey()
+        assert not vio.recorder.is_recording
+
+    def test_concurrent_hotkey_no_phantom_recording(self):
+        """Socket event waiting behind lock must not start phantom recording.
+
+        This is the critical race: evdev stops recording (takes time),
+        socket event waits on lock, then must be debounced when lock releases.
+        """
+        vio, _, _ = _make_vio()
+
+        # Start recording
+        vio.on_hotkey()
+        assert vio.recorder.is_recording
+
+        # Feed audio
+        for _ in range(20):
+            data = np.full((1024, 1), 0.3, dtype=np.float32)
+            vio.recorder._callback(data, 1024, None, None)
+
+        # Allow stop
+        vio._record_start = time.monotonic() - 2.0
+        vio._last_hotkey = time.monotonic() - 2.0
+
+        # Simulate: evdev thread stops recording, socket thread waits then fires
+        results = []
+
+        def evdev_stop():
+            vio.on_hotkey()
+            results.append(("evdev", vio.recorder.is_recording))
+
+        def socket_delayed():
+            time.sleep(0.05)  # socket arrives 50ms after evdev
+            vio.on_hotkey()
+            results.append(("socket", vio.recorder.is_recording))
+
+        t1 = threading.Thread(target=evdev_stop)
+        t2 = threading.Thread(target=socket_delayed)
+        t1.start()
+        t2.start()
+        t1.join(timeout=5)
+        t2.join(timeout=5)
+
+        # Recording must be stopped and NOT restarted by socket
+        assert not vio.recorder.is_recording, \
+            f"Phantom recording started! results={results}"

python_voiceio-0.2.3/voiceio/__init__.py

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

{python_voiceio-0.2.1 → python_voiceio-0.2.3}/voiceio/app.py

@@ -33,7 +33,7 @@ class VoiceIO:
         self._typer = typer_chain.select(self.platform, cfg.output.method)
         self._auto_fallback = cfg.health.auto_fallback
 
-        # Always start socket backend alongside native hotkey
+        # Socket backend runs alongside native hotkey for extra robustness
         self._socket: SocketHotkey | None = None
         if self._hotkey.name != "socket":
             self._socket = SocketHotkey()
@@ -47,6 +47,8 @@ class VoiceIO:
         self._session: StreamingSession | None = None
         self._processing = False
         self._record_start: float = 0
+        self._hotkey_lock = threading.Lock()
+        self._last_hotkey: float = 0
         self._prev_ibus_engine: str | None = None
         self._engine_proc: subprocess.Popen | None = None
         self._shutdown = threading.Event()
@@ -56,23 +58,21 @@ class VoiceIO:
         self._shutdown.set()
 
     def on_hotkey(self) -> None:
-        if self.recorder.is_recording:
-            elapsed = time.monotonic() - self._record_start
-            if elapsed < self.cfg.output.cancel_window_secs:
-                # Quick double-press = cancel recording without typing
-                if self._streaming and self._session is not None:
-                    self._session.stop()
-                    self._session = None
-                self.recorder.stop()
-                if isinstance(self._typer, StreamingTyper):
-                    self._typer.clear_preedit()
-                self._deactivate_ibus()
-                log.info("Recording cancelled (double-press)")
-                return
-            if elapsed < self.cfg.output.min_recording_secs:
-                log.debug("Ignoring stop, only %.1fs into recording (min %.1fs)", elapsed, self.cfg.output.min_recording_secs)
+        with self._hotkey_lock:
+            now = time.monotonic()
+            # Deduplicate: multiple backends (evdev + socket) may fire
+            # for the same physical keypress
+            if now - self._last_hotkey < 0.3:
                 return
+            self._last_hotkey = now
+            self._on_hotkey_inner()
+            # Update timestamp after completion so threads that waited
+            # behind the lock see a fresh timestamp and get debounced
+            self._last_hotkey = time.monotonic()
 
+    def _on_hotkey_inner(self) -> None:
+        if self.recorder.is_recording:
+            elapsed = time.monotonic() - self._record_start
             self._play_record_cue(start=False)
             if self._streaming and self._session is not None:
                 final_text = self._session.stop()
@@ -82,11 +82,11 @@ class VoiceIO:
                     self._play_feedback(final_text)
                 log.info("Streaming done (%.1fs): '%s'", elapsed, final_text)
             else:
+                self._play_record_cue(start=False)
                 audio = self.recorder.stop()
                 log.info("Stopped recording (%.1fs)", elapsed)
                 if audio is not None and not self._processing:
                     threading.Thread(target=self._process, args=(audio,), daemon=True).start()
-            # Deactivate IBus engine, return keyboard to normal
             self._deactivate_ibus()
         elif not self._processing:
             # Activate IBus engine so preedit/commit can reach the focused app

{python_voiceio-0.2.1 → python_voiceio-0.2.3}/voiceio/cli.py

@@ -429,14 +429,15 @@ def _cmd_uninstall() -> None:
         print("\nNothing to remove. voiceio was not installed on this system.")
 
     # Offer to uninstall the Python package itself
+    from voiceio.config import PYPI_NAME
     is_pipx = "pipx" in sys.prefix
     if is_pipx:
         answer = input("\nAlso uninstall the voiceio Python package (pipx uninstall)? [Y/n] ").strip().lower()
         if answer in ("y", "yes", ""):
             try:
-                subprocess.run(["pipx", "uninstall", "voiceio"], timeout=30)
+                subprocess.run(["pipx", "uninstall", PYPI_NAME], timeout=30)
             except (FileNotFoundError, subprocess.TimeoutExpired):
-                print("Failed. Run manually: pipx uninstall python-voiceio")
+                print(f"Failed. Run manually: pipx uninstall {PYPI_NAME}")
     else:
         # Dev install or pip install: check if voiceio is still reachable
         voiceio_bin = shutil.which("voiceio")
@@ -444,10 +445,10 @@ def _cmd_uninstall() -> None:
             print(f"\nNote: 'voiceio' is still available at {voiceio_bin}")
             if ".venv" in str(voiceio_bin) or "site-packages" in str(voiceio_bin):
                 print("This is a development install. To fully remove:")
-                print("  pip uninstall python-voiceio")
+                print(f"  pip uninstall {PYPI_NAME}")
             else:
                 print("To fully remove the package:")
-                print("  pip uninstall python-voiceio")
+                print(f"  pip uninstall {PYPI_NAME}")
         else:
             print("\nvoiceio fully removed.")
 

{python_voiceio-0.2.1 → python_voiceio-0.2.3}/voiceio/config.py

@@ -9,6 +9,8 @@ from pathlib import Path
 
 log = logging.getLogger(__name__)
 
+PYPI_NAME = "python-voiceio"
+
 CONFIG_DIR = Path.home() / ".config" / "voiceio"
 CONFIG_PATH = CONFIG_DIR / "config.toml"
 LOG_DIR = Path.home() / ".local" / "state" / "voiceio"

{python_voiceio-0.2.1 → python_voiceio-0.2.3}/voiceio/hotkeys/evdev.py

@@ -108,16 +108,20 @@ class EvdevHotkey:
                     if event.type != ecodes.EV_KEY:
                         continue
                     key_event = evdev.categorize(event)
+                    should_trigger = False
                     with pressed_lock:
                         if key_event.keystate == evdev.KeyEvent.key_down:
                             pressed.add(event.code)
                             if event.code == key_code and check_mods():
                                 now = time.monotonic()
-                                if now - last_trigger[0] >= DEBOUNCE_SECS:
+                                since = now - last_trigger[0]
+                                if since >= DEBOUNCE_SECS:
                                     last_trigger[0] = now
-                                    on_trigger()
+                                    should_trigger = True
                         elif key_event.keystate == evdev.KeyEvent.key_up:
                             pressed.discard(event.code)
+                    if should_trigger:
+                        on_trigger()
             except OSError:
                 pass
 

{python_voiceio-0.2.1 → python_voiceio-0.2.3}/voiceio/wizard.py

@@ -844,22 +844,23 @@ def run_wizard() -> None:
         _streaming_test(model=_get_or_load_model())
 
     # ── Done ────────────────────────────────────────────────────────────
-    # Restart service if it was already running (setup may have killed the
-    # IBus engine via `ibus restart`)
-    from voiceio.service import is_running
-    if is_running():
-        subprocess.run(
-            ["systemctl", "--user", "restart", "voiceio.service"],
-            capture_output=True, timeout=5,
-        )
-        print(f"  {GREEN}✓{RESET} {DIM}Restarted voiceio service{RESET}")
+    # Start (or restart) the service so it's immediately usable
+    if autostart_idx == 0:
+        from voiceio.service import is_running
+        action = "restart" if is_running() else "start"
+        try:
+            subprocess.run(
+                ["systemctl", "--user", action, "voiceio.service"],
+                capture_output=True, timeout=5,
+            )
+            print(f"  {GREEN}✓{RESET} {DIM}voiceio service started{RESET}")
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            pass
 
     from voiceio.config import LOG_PATH
     log_path = LOG_PATH
     start_hint = (
-        f"  It will start automatically on next login.\n"
-        f"  Or start now:\n"
-        f"    {CYAN}systemctl --user start voiceio{RESET}"
+        f"  voiceio is running and will start automatically on login."
         if autostart_idx == 0
         else f"  Start voiceio:\n    {CYAN}voiceio{RESET}"
     )

python_voiceio-0.2.1/tests/test_app_wiring.py

@@ -1,135 +0,0 @@
-"""Test that VoiceIO app wires up correctly with mocked backends."""
-from __future__ import annotations
-
-from unittest.mock import MagicMock, patch
-
-import numpy as np
-import pytest
-
-from voiceio.config import Config
-
-
-class TestVoiceIOInit:
-    """Verify VoiceIO can be constructed without real hardware."""
-
-    def test_init_with_mocked_backends(self):
-        from voiceio.backends import ProbeResult
-
-        mock_hotkey = MagicMock()
-        mock_hotkey.name = "socket"
-        mock_hotkey.probe.return_value = ProbeResult(ok=True)
-
-        mock_typer = MagicMock()
-        mock_typer.name = "clipboard"
-        mock_typer.probe.return_value = ProbeResult(ok=True)
-
-        mock_transcriber = MagicMock()
-
-        with patch("voiceio.app.hotkey_chain.select", return_value=mock_hotkey), \
-             patch("voiceio.app.typer_chain.select", return_value=mock_typer), \
-             patch("voiceio.app.Transcriber", return_value=mock_transcriber), \
-             patch("voiceio.app.plat.detect") as mock_detect:
-            mock_detect.return_value = MagicMock(display_server="wayland", desktop="gnome")
-
-            from voiceio.app import VoiceIO
-            vio = VoiceIO(Config())
-
-            assert vio._hotkey is mock_hotkey
-            assert vio._typer is mock_typer
-
-    def test_on_hotkey_toggle_cycle(self):
-        """Test on_hotkey start/stop without real audio."""
-        from voiceio.backends import ProbeResult
-
-        mock_hotkey = MagicMock()
-        mock_hotkey.name = "socket"
-
-        mock_typer = MagicMock()
-        mock_typer.name = "clipboard"
-
-        mock_transcriber = MagicMock()
-        mock_transcriber.transcribe.return_value = "hello world"
-
-        with patch("voiceio.app.hotkey_chain.select", return_value=mock_hotkey), \
-             patch("voiceio.app.typer_chain.select", return_value=mock_typer), \
-             patch("voiceio.app.Transcriber", return_value=mock_transcriber), \
-             patch("voiceio.app.plat.detect") as mock_detect:
-            mock_detect.return_value = MagicMock(display_server="wayland", desktop="gnome")
-
-            from voiceio.app import VoiceIO
-            vio = VoiceIO(Config())
-            vio.recorder._stream = MagicMock()  # skip real audio
-
-            # First toggle: start recording
-            vio.on_hotkey()
-            assert vio.recorder.is_recording
-
-            # Simulate some audio coming in
-            for _ in range(20):
-                data = np.full((1024, 1), 0.3, dtype=np.float32)
-                vio.recorder._callback(data, 1024, None, None)
-
-            # Hack: set _record_start far enough back
-            import time
-            vio._record_start = time.monotonic() - 5.0
-
-            # Second toggle: stop recording
-            vio.on_hotkey()
-            assert not vio.recorder.is_recording
-
-    def test_double_press_cancels_recording(self):
-        """Rapid double-press (< 0.5s) cancels without typing."""
-        mock_hotkey = MagicMock()
-        mock_hotkey.name = "socket"
-        mock_typer = MagicMock()
-        mock_typer.name = "clipboard"
-
-        with patch("voiceio.app.hotkey_chain.select", return_value=mock_hotkey), \
-             patch("voiceio.app.typer_chain.select", return_value=mock_typer), \
-             patch("voiceio.app.Transcriber") as mock_trans_cls, \
-             patch("voiceio.app.plat.detect") as mock_detect:
-            mock_detect.return_value = MagicMock(display_server="wayland", desktop="gnome")
-
-            from voiceio.app import VoiceIO
-            vio = VoiceIO(Config())
-            vio.recorder._stream = MagicMock()
-
-            # Start recording
-            vio.on_hotkey()
-            assert vio.recorder.is_recording
-
-            # Immediately double-press (< 0.5s) - cancels
-            vio.on_hotkey()
-            assert not vio.recorder.is_recording
-            mock_typer.type_text.assert_not_called()
-
-    def test_min_recording_duration_enforced(self):
-        """Press between cancel_window and min_recording should be ignored."""
-        import time
-        mock_hotkey = MagicMock()
-        mock_hotkey.name = "socket"
-        mock_typer = MagicMock()
-        mock_typer.name = "clipboard"
-
-        cfg = Config()
-
-        with patch("voiceio.app.hotkey_chain.select", return_value=mock_hotkey), \
-             patch("voiceio.app.typer_chain.select", return_value=mock_typer), \
-             patch("voiceio.app.Transcriber") as mock_trans_cls, \
-             patch("voiceio.app.plat.detect") as mock_detect:
-            mock_detect.return_value = MagicMock(display_server="wayland", desktop="gnome")
-
-            from voiceio.app import VoiceIO
-            vio = VoiceIO(cfg)
-            vio.recorder._stream = MagicMock()
-
-            # Start recording
-            vio.on_hotkey()
-            assert vio.recorder.is_recording
-
-            # Set record_start past cancel window but before min duration
-            vio._record_start = time.monotonic() - (cfg.output.cancel_window_secs + 0.1)
-
-            # Press again - should be ignored
-            vio.on_hotkey()
-            assert vio.recorder.is_recording  # still recording

python_voiceio-0.2.1/voiceio/__init__.py

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