python-voiceio 0.9.10__tar.gz → 0.9.11__tar.gz

{python_voiceio-0.9.10/python_voiceio.egg-info → python_voiceio-0.9.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.9.10
+Version: 0.9.11
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.9.10 → python_voiceio-0.9.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "0.9.10"
+version = "0.9.11"
 description = "Voice dictation for Linux. Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"

{python_voiceio-0.9.10 → python_voiceio-0.9.11/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.9.10
+Version: 0.9.11
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.9.10 → python_voiceio-0.9.11}/python_voiceio.egg-info/SOURCES.txt

@@ -26,8 +26,10 @@ tests/test_fallback.py
 tests/test_health.py
 tests/test_hints.py
 tests/test_history.py
+tests/test_ibus_engine_limits.py
 tests/test_ibus_pending.py
 tests/test_ibus_ping.py
+tests/test_ibus_textlimit.py
 tests/test_ibus_typer.py
 tests/test_llm.py
 tests/test_llm_api.py
@@ -99,6 +101,7 @@ voiceio/hotkeys/socket_backend.py
 voiceio/ibus/__init__.py
 voiceio/ibus/engine.py
 voiceio/ibus/pending.py
+voiceio/ibus/textlimit.py
 voiceio/models/__init__.py
 voiceio/models/silero_vad.onnx
 voiceio/sounds/__init__.py

python_voiceio-0.9.11/tests/test_ibus_engine_limits.py

@@ -0,0 +1,129 @@
+"""Regression guard: the engine must never hand IBus an oversized string.
+
+``test_ibus_textlimit`` proves the limiter itself is correct. This pins the
+engine to actually routing through it, so the crash cannot come back via an
+edit that bypasses the limiter. A stub stands in for the IBus GObject bindings,
+which are a system package and are not installed in the test venv.
+"""
+from __future__ import annotations
+
+import importlib
+import sys
+import types
+
+import pytest
+
+from voiceio.ibus.textlimit import MAX_TEXT_BYTES
+
+
+class _Text:
+    """Stand-in for IBus.Text that just remembers its string."""
+
+    def __init__(self, string: str):
+        self.string = string
+
+    @staticmethod
+    def new_from_string(string: str) -> "_Text":
+        return _Text(string)
+
+    def append_attribute(self, *args) -> None:
+        pass
+
+
+class _Recorder:
+    """Stands in for ``self``, recording what the engine sends to IBus."""
+
+    def __init__(self):
+        self.committed: list[str] = []
+        self.preedits: list[str] = []
+        self.hides = 0
+
+    def hide_preedit_text(self) -> None:
+        self.hides += 1
+
+    def commit_text(self, text: _Text) -> None:
+        self.committed.append(text.string)
+
+    def update_preedit_text(self, text: _Text, cursor: int, visible: bool) -> None:
+        self.preedits.append(text.string)
+
+
+@pytest.fixture
+def engine(monkeypatch):
+    ibus = types.SimpleNamespace(
+        Engine=type("Engine", (), {}),
+        Factory=type("Factory", (), {}),
+        Text=_Text,
+        AttrType=types.SimpleNamespace(UNDERLINE=1),
+        AttrUnderline=types.SimpleNamespace(SINGLE=1),
+    )
+    repository = types.ModuleType("gi.repository")
+    repository.IBus = ibus
+    repository.GLib = types.SimpleNamespace()
+    repository.GObject = types.SimpleNamespace()
+    gi = types.ModuleType("gi")
+    gi.require_version = lambda *a, **k: None
+    gi.repository = repository
+
+    monkeypatch.setitem(sys.modules, "gi", gi)
+    monkeypatch.setitem(sys.modules, "gi.repository", repository)
+    sys.modules.pop("voiceio.ibus.engine", None)
+    module = importlib.import_module("voiceio.ibus.engine")
+    yield module.VoiceIOEngine
+    sys.modules.pop("voiceio.ibus.engine", None)
+
+
+@pytest.fixture
+def long_note() -> str:
+    """A transcript the size of the ones that crashed Ghostty and Obsidian."""
+    return " ".join(f"word{i}" for i in range(900))
+
+
+def _nbytes(text: str) -> int:
+    return len(text.encode("utf-8"))
+
+
+def test_commit_chunks_stay_under_the_limit(engine, long_note):
+    rec = _Recorder()
+    engine.commit(rec, long_note)
+    assert len(rec.committed) > 1
+    assert all(_nbytes(c) <= MAX_TEXT_BYTES for c in rec.committed)
+
+
+def test_commit_delivers_the_whole_note(engine, long_note):
+    rec = _Recorder()
+    engine.commit(rec, long_note)
+    assert "".join(rec.committed) == long_note
+
+
+def test_commit_hides_preedit_first(engine, long_note):
+    rec = _Recorder()
+    engine.commit(rec, long_note)
+    assert rec.hides == 1
+
+
+def test_empty_commit_sends_nothing(engine):
+    rec = _Recorder()
+    engine.commit(rec, "")
+    assert rec.committed == []
+    assert rec.hides == 1
+
+
+def test_preedit_stays_under_the_limit(engine, long_note):
+    rec = _Recorder()
+    engine.preedit(rec, long_note)
+    assert len(rec.preedits) == 1
+    assert _nbytes(rec.preedits[0]) <= MAX_TEXT_BYTES
+
+
+def test_short_preedit_is_shown_verbatim(engine):
+    rec = _Recorder()
+    engine.preedit(rec, "hello there")
+    assert rec.preedits == ["hello there"]
+
+
+def test_empty_preedit_hides_instead(engine):
+    rec = _Recorder()
+    engine.preedit(rec, "")
+    assert rec.preedits == []
+    assert rec.hides == 1

python_voiceio-0.9.11/tests/test_ibus_textlimit.py

@@ -0,0 +1,94 @@
+"""Tests for the IBus text size limits.
+
+The bug these guard against: a preedit or commit string above libwayland's
+4096-byte per-message buffer makes the compositor drop the focused
+application's connection, killing it mid-dictation.
+"""
+from __future__ import annotations
+
+import pytest
+
+from voiceio.ibus.textlimit import (
+    MAX_TEXT_BYTES,
+    TRUNCATION_MARK,
+    split_utf8,
+    tail_utf8,
+)
+
+# The real 4096-byte ceiling every chunk has to clear, with room for the
+# neighbouring events GNOME Shell may pack into the same buffer flush.
+WAYLAND_BUFFER_BYTES = 4096
+
+
+def _nbytes(text: str) -> int:
+    return len(text.encode("utf-8"))
+
+
+@pytest.fixture
+def long_note() -> str:
+    """A transcript the size of the ones that crashed Ghostty and Obsidian."""
+    return " ".join(f"word{i}" for i in range(900))
+
+
+def test_short_text_is_one_chunk():
+    assert split_utf8("hello there") == ["hello there"]
+
+
+def test_empty_text_yields_no_chunks():
+    assert split_utf8("") == []
+
+
+def test_chunks_rejoin_to_the_original(long_note):
+    assert "".join(split_utf8(long_note)) == long_note
+
+
+def test_every_chunk_fits_the_wayland_buffer(long_note):
+    chunks = split_utf8(long_note)
+    assert len(chunks) > 1
+    assert all(_nbytes(c) <= MAX_TEXT_BYTES for c in chunks)
+    assert all(_nbytes(c) < WAYLAND_BUFFER_BYTES for c in chunks)
+
+
+def test_multibyte_characters_are_never_cut_in_half():
+    # No spaces, so splitting has to fall back to character boundaries.
+    text = "é€𝄞" * 2000
+    chunks = split_utf8(text)
+    assert "".join(chunks) == text
+    assert all(_nbytes(c) <= MAX_TEXT_BYTES for c in chunks)
+
+
+def test_splits_prefer_word_boundaries(long_note):
+    # Every chunk but the last should end at a space, so commits do not land
+    # mid-word in editors that treat each commit as a unit.
+    chunks = split_utf8(long_note)
+    assert all(c.endswith(" ") for c in chunks[:-1])
+
+
+def test_a_run_without_spaces_still_splits():
+    text = "x" * (MAX_TEXT_BYTES * 3)
+    chunks = split_utf8(text)
+    assert "".join(chunks) == text
+    assert all(_nbytes(c) <= MAX_TEXT_BYTES for c in chunks)
+
+
+def test_short_preedit_is_untouched():
+    assert tail_utf8("hello there") == "hello there"
+
+
+def test_long_preedit_is_bounded_and_marked(long_note):
+    shown = tail_utf8(long_note)
+    assert _nbytes(shown) <= MAX_TEXT_BYTES
+    assert shown.startswith(TRUNCATION_MARK)
+
+
+def test_preedit_keeps_the_most_recent_words(long_note):
+    # The tail is what the speaker is saying right now — that is the half worth
+    # showing when the preview has to be trimmed.
+    assert tail_utf8(long_note).endswith(long_note[-200:])
+
+
+def test_preedit_tail_survives_multibyte_text():
+    text = "é" * 4000
+    shown = tail_utf8(text)
+    assert _nbytes(shown) <= MAX_TEXT_BYTES
+    assert shown == TRUNCATION_MARK + "é" * ((MAX_TEXT_BYTES - _nbytes(TRUNCATION_MARK)) // 2)

python_voiceio-0.9.11/voiceio/__init__.py

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

{python_voiceio-0.9.10 → python_voiceio-0.9.11}/voiceio/ibus/engine.py

@@ -30,6 +30,7 @@ from voiceio.ibus import (
     acquire_singleton_lock,
 )
 from voiceio.ibus.pending import PendingBuffer
+from voiceio.ibus.textlimit import split_utf8, tail_utf8
 
 log = logging.getLogger(__name__)
 
@@ -38,6 +39,11 @@ log = logging.getLogger(__name__)
 _lock_fd: int | None = None
 ENGINE_NAME = "voiceio"
 COMPONENT_NAME = "org.voiceio.ibus"
+# A datagram longer than the buffer we hand recvfrom() is truncated silently,
+# which would inject half a dictation with no error anywhere. Sized above the
+# largest datagram a sender can produce (SO_SNDBUF, ~208K by default) so that
+# cannot happen.
+RECV_BYTES = 262144
 
 
 class VoiceIOEngine(IBus.Engine):
@@ -69,24 +75,25 @@ class VoiceIOEngine(IBus.Engine):
             return False
 
     def preedit(self, text: str) -> None:
-        """Show text as preedit (underlined preview)."""
+        """Show text as preedit (underlined preview), tail-first once long."""
         if not text:
             self.hide_preedit_text()
             return
-        ibus_text = IBus.Text.new_from_string(text)
+        shown = tail_utf8(text)
+        ibus_text = IBus.Text.new_from_string(shown)
         ibus_text.append_attribute(
             IBus.AttrType.UNDERLINE,
             IBus.AttrUnderline.SINGLE,
             0,
-            len(text),
+            len(shown),
         )
-        self.update_preedit_text(ibus_text, len(text), True)
+        self.update_preedit_text(ibus_text, len(shown), 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))
+        for chunk in split_utf8(text):
+            self.commit_text(IBus.Text.new_from_string(chunk))
 
     def clear(self) -> None:
         """Clear preedit without committing."""
@@ -150,7 +157,7 @@ def _socket_listener(mainloop: GLib.MainLoop) -> None:
 
     while mainloop.is_running():
         try:
-            data, addr = sock.recvfrom(65536)
+            data, addr = sock.recvfrom(RECV_BYTES)
         except socket.timeout:
             continue
         except OSError:

python_voiceio-0.9.11/voiceio/ibus/textlimit.py

@@ -0,0 +1,66 @@
+"""Size limits for text handed to IBus.
+
+libwayland gives every client connection a fixed 4096-byte message buffer.
+GNOME Shell relays our preedit and commit strings to the focused application as
+single ``zwp_text_input_v3`` events, so a string that does not fit makes the
+compositor tear down that application's connection — it dies mid-dictation,
+whatever it happens to be. Shell can pack several events into one flush, so the
+budget here leaves real headroom rather than sitting just under 4096.
+
+Kept free of any ``gi`` dependency so it can be unit-tested without the IBus
+GObject bindings installed.
+"""
+from __future__ import annotations
+
+MAX_TEXT_BYTES = 2048
+TRUNCATION_MARK = "… "
+
+
+def _is_continuation(byte: int) -> bool:
+    return byte & 0xC0 == 0x80
+
+
+def split_utf8(text: str, limit: int = MAX_TEXT_BYTES) -> list[str]:
+    """Split ``text`` into chunks of at most ``limit`` UTF-8 bytes.
+
+    The chunks concatenate back to exactly ``text``, so committing them in order
+    is indistinguishable to the target application from a single commit. A split
+    lands on a space when one falls in the back half of the chunk, and on a
+    character boundary otherwise, so no multi-byte character is ever cut in half.
+    """
+    data = text.encode("utf-8")
+    if len(data) <= limit:
+        return [text] if text else []
+
+    chunks: list[str] = []
+    start = 0
+    while start < len(data):
+        end = min(start + limit, len(data))
+        if end < len(data):
+            space = data.rfind(b" ", start + limit // 2, end)
+            if space != -1:
+                end = space + 1
+            else:
+                while end > start and _is_continuation(data[end]):
+                    end -= 1
+        chunks.append(data[start:end].decode("utf-8"))
+        start = end
+    return chunks
+
+
+def tail_utf8(text: str, limit: int = MAX_TEXT_BYTES) -> str:
+    """Return the trailing ``limit`` UTF-8 bytes of ``text``, marked if trimmed.
+
+    The preedit preview is one replaceable string rather than an append, so it
+    cannot be chunked the way a commit can — it has to be bounded instead. Only
+    the preview is shortened; the full text still reaches the application when
+    the dictation commits.
+    """
+    data = text.encode("utf-8")
+    if len(data) <= limit:
+        return text
+
+    start = len(data) - (limit - len(TRUNCATION_MARK.encode("utf-8")))
+    while start < len(data) and _is_continuation(data[start]):
+        start += 1
+    return TRUNCATION_MARK + data[start:].decode("utf-8")

python_voiceio-0.9.10/voiceio/__init__.py

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