Files
AutoZhuyin/linux/autozhuyin_ibus.py
T
ays953andClaude Opus 5.5 2cebf0e700 Remember picked candidates (user history)
Candidates chosen with the arrow-down list are recorded on commit as
toneless reading -> phrase with a count. The converter lifts a picked phrase just
above the best lexicon entry for that reading (more for more picks), so it
comes first next time without overriding longer phrases. Up to 2000 pairs,
least recently used evicted. Stored as user-history.json on every platform; the
Mac menu's clear item clears it too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 14:30:55 +08:00

329 lines
11 KiB
Python

#!/usr/bin/env python3
"""IBus engine for AutoZhuyin (自動注音) on Linux.
All the logic lives in autozhuyin.core (shared with Windows and the tests); this file
only translates IBus key events and draws the preedit / candidate table.
Run modes:
autozhuyin_ibus.py --ibus started by ibus-daemon (from the component XML)
autozhuyin_ibus.py [--activate] started by the user/autostart: registers the engine
itself if ibus-daemon does not know it, and with
--activate makes it the current input method
"""
import json
import os
import sys
import time
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import gi # noqa: E402
gi.require_version("IBus", "1.0")
from gi.repository import GLib, GObject, IBus # noqa: E402
import autozhuyin # noqa: E402
from autozhuyin.core.history import UserHistory # noqa: E402
from autozhuyin.core.classifier import LITERAL, Classifier, LearnedPreferences # noqa: E402
from autozhuyin.core.engine import ( # noqa: E402
BACKSPACE, DOWN, ENTER, ESCAPE, LEFT, RIGHT, SHIFT_TAP, TAB, UP, CompositionEngine,
)
from autozhuyin.core.english import EnglishModel # noqa: E402
from autozhuyin.core.lexicon import Lexicon # noqa: E402
from autozhuyin.core.shift_tap import ShiftTapDetector # noqa: E402
ENGINE_NAME = "autozhuyin"
BUS_NAME = "org.freedesktop.IBus.AutoZhuyin"
VERSION = "0.0.0"
_DATA = os.path.join(os.path.dirname(os.path.abspath(autozhuyin.__file__)), "data")
_USER_DIR = os.path.join(os.environ.get("XDG_CONFIG_HOME") or os.path.expanduser("~/.config"), "autozhuyin")
_LEARNED_FILE = os.path.join(_USER_DIR, "learned.json")
_USER_PHRASES = os.path.join(_USER_DIR, "user-phrases.txt")
_HISTORY_FILE = os.path.join(_USER_DIR, "user-history.json")
try:
with open(os.path.join(HERE, "version.txt"), encoding="utf-8") as _f:
VERSION = _f.read().strip() or VERSION
except OSError:
pass
_classifier = None
def _save_json(path, data):
try:
os.makedirs(_USER_DIR, exist_ok=True)
with open(path, "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False)
except OSError:
pass
def _load_json(path):
try:
with open(path, encoding="utf-8") as f:
return json.load(f)
except (OSError, ValueError):
return {}
def _save_learned(weights):
_save_json(_LEARNED_FILE, weights)
def _save_history(data):
_save_json(_HISTORY_FILE, data)
def shared_classifier():
"""Loads the lexicon and English model once per process."""
global _classifier
if _classifier is None:
lexicon = Lexicon.from_file(os.path.join(_DATA, "lexicon.txt"))
if os.path.exists(_USER_PHRASES):
with open(_USER_PHRASES, encoding="utf-8") as f:
lexicon.load(f)
english = EnglishModel.from_files(
os.path.join(_DATA, "english-common.txt"),
os.path.join(_DATA, "english-dict.txt"),
os.path.join(_DATA, "english-bigram.json"),
)
trained = Classifier.load_weights(os.path.join(_DATA, "classifier-weights.json"))
_classifier = Classifier(lexicon, english, LearnedPreferences(_load_json(_LEARNED_FILE), _save_learned),
trained, UserHistory(_load_json(_HISTORY_FILE), _save_history))
return _classifier
_SPECIAL = {
IBus.KEY_BackSpace: BACKSPACE, IBus.KEY_Return: ENTER, IBus.KEY_KP_Enter: ENTER,
IBus.KEY_Escape: ESCAPE, IBus.KEY_Tab: TAB,
IBus.KEY_Up: UP, IBus.KEY_Down: DOWN, IBus.KEY_Left: LEFT, IBus.KEY_Right: RIGHT,
}
_SHIFT_KEYS = (IBus.KEY_Shift_L, IBus.KEY_Shift_R)
_SHORTCUT_MASK = (IBus.ModifierType.CONTROL_MASK | IBus.ModifierType.MOD1_MASK
| IBus.ModifierType.SUPER_MASK | IBus.ModifierType.MOD4_MASK)
_LITERAL_COLOR = 0x1E64DC # blue hint for English segments
class AutoZhuyinEngine(IBus.Engine):
__gtype_name__ = "AutoZhuyinEngine"
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._setup()
def _setup(self):
if getattr(self, "engine", None) is not None:
return
self.engine = CompositionEngine(shared_classifier())
self.shift_tap = ShiftTapDetector()
self.table = IBus.LookupTable.new(self.engine.page_size, 0, True, False)
self.table.set_orientation(IBus.Orientation.VERTICAL)
self.mode_prop = IBus.Property(
key="mode", prop_type=IBus.PropType.NORMAL,
label=IBus.Text.new_from_string("中英自動"),
symbol=IBus.Text.new_from_string("自"),
tooltip=IBus.Text.new_from_string("單按 Shift 切換英文模式"),
sensitive=True, visible=True, state=IBus.PropState.UNCHECKED)
self.props = IBus.PropList()
self.props.append(self.mode_prop)
# --- keys ---
def do_process_key_event(self, keyval, keycode, state):
self._setup()
released = bool(state & IBus.ModifierType.RELEASE_MASK)
# Shift pressed and released alone: English mode (or flip the current word).
if keyval in _SHIFT_KEYS:
now = time.monotonic()
if not released:
if state & _SHORTCUT_MASK:
self.shift_tap.key_pressed()
else:
self.shift_tap.shift_down(now)
return False
if self.shift_tap.shift_up(now):
self.engine.handle(SHIFT_TAP)
self._update(None)
self._update_mode()
return False
if released:
return False
self.shift_tap.key_pressed()
# Shortcuts (Ctrl/Alt/Super) go to the app; commit any composition first.
if state & _SHORTCUT_MASK:
if self.engine.keys:
self._update(self.engine.commit_all())
return False
key = self._key(keyval, state)
if key is None:
return self._busy() # swallow other keys (Delete, Home…) while composing
if not self.engine.wants(key):
return False
handled, commit = self.engine.handle(key)
self._update(commit)
return handled
def _key(self, keyval, state):
if keyval in _SPECIAL:
return _SPECIAL[keyval]
if keyval == IBus.KEY_space:
return " "
code = IBus.keyval_to_unicode(keyval)
if not code or not code.isprintable():
return None
# Caps Lock without Shift: keep Zhuyin working by using lowercase.
if state & IBus.ModifierType.LOCK_MASK and not state & IBus.ModifierType.SHIFT_MASK:
code = code.lower()
return code
def _busy(self):
return bool(self.engine.keys or self.engine.candidates)
# --- candidate panel (mouse) ---
def do_candidate_clicked(self, index, button, state):
self.engine.select_candidate(self.engine.page_start + index)
self._update(None)
def do_page_up(self):
return self._move_candidate(-self.engine.page_size)
def do_page_down(self):
return self._move_candidate(self.engine.page_size)
def do_cursor_up(self):
return self._move_candidate(-1)
def do_cursor_down(self):
return self._move_candidate(1)
def _move_candidate(self, delta):
if not self.engine.candidates:
return False
e = self.engine
e.candidate_index = max(0, min(len(e.candidates) - 1, e.candidate_index + delta))
self._update(None)
return True
# --- lifecycle ---
def do_focus_in(self):
self._setup()
self.register_properties(self.props)
self._update_mode()
def do_focus_out(self):
self._setup()
# PreeditFocusMode.COMMIT: IBus commits the shown text itself on focus out.
self.engine.reset()
self.hide_lookup_table()
def do_reset(self):
self._setup()
self.engine.reset()
self.hide_preedit_text()
self.hide_lookup_table()
def do_disable(self):
self.do_reset()
# --- drawing ---
def _update(self, commit):
if commit:
self.commit_text(IBus.Text.new_from_string(commit))
pieces = self.engine.marked_pieces
text = "".join(t for t, _ in pieces)
if text:
ibus_text = IBus.Text.new_from_string(text)
attrs = IBus.AttrList()
attrs.append(IBus.attr_underline_new(IBus.AttrUnderline.SINGLE, 0, len(text)))
pos = 0
for piece, mode in pieces:
if mode == LITERAL and piece:
attrs.append(IBus.attr_foreground_new(_LITERAL_COLOR, pos, pos + len(piece)))
pos += len(piece)
ibus_text.set_attributes(attrs)
self.update_preedit_text_with_mode(ibus_text, self.engine.cursor_offset, True,
IBus.PreeditFocusMode.COMMIT)
else:
self.hide_preedit_text()
if self.engine.candidates:
self.table.clear()
for _, candidate in self.engine.candidates:
self.table.append_candidate(IBus.Text.new_from_string(candidate))
self.table.set_cursor_pos(self.engine.candidate_index)
self.update_lookup_table(self.table, True)
else:
self.hide_lookup_table()
def _update_mode(self):
english = self.engine.english_mode
self.mode_prop.set_label(IBus.Text.new_from_string("英文" if english else "中英自動"))
self.mode_prop.set_symbol(IBus.Text.new_from_string("英" if english else "自"))
self.update_property(self.mode_prop)
# --- process setup ---
def make_component(exec_path):
component = IBus.Component(
name=BUS_NAME, description="自動注音 AutoZhuyin", version=VERSION,
license="Private", author="AutoZhuyin", homepage="",
command_line=f"{sys.executable} {exec_path} --ibus", textdomain="")
icon = os.path.join(HERE, "icon.png")
component.add_engine(IBus.EngineDesc(
name=ENGINE_NAME, longname="自動注音", description="大千注音+英文,自動判斷中英",
language="zh_TW", license="Private", author="AutoZhuyin",
icon=icon if os.path.exists(icon) else "", layout="us", symbol="自", rank=0))
return component
def main(argv):
IBus.init()
bus = IBus.Bus()
loop = GLib.MainLoop()
started_by_ibus = "--ibus" in argv
activate = "--activate" in argv
factory = None
def on_connected(*_):
nonlocal factory
factory = IBus.Factory.new(bus.get_connection())
factory.add_engine(ENGINE_NAME, GObject.type_from_name("AutoZhuyinEngine"))
if started_by_ibus:
bus.request_name(BUS_NAME, 0)
else:
known = any(e.get_name() == ENGINE_NAME for e in bus.list_engines())
if not known:
bus.register_component(make_component(os.path.abspath(__file__)))
if activate:
bus.set_global_engine(ENGINE_NAME)
def on_disconnected(*_):
if started_by_ibus:
loop.quit()
# Otherwise wait: IBus.Bus reconnects (and emits "connected") when ibus-daemon restarts.
bus.connect("connected", on_connected)
bus.connect("disconnected", on_disconnected)
shared_classifier() # load data before the first key
if bus.is_connected():
on_connected()
elif started_by_ibus:
print("autozhuyin: cannot connect to ibus-daemon", file=sys.stderr)
return 1
loop.run()
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))