Compare commits

...
10 Commits
Author SHA1 Message Date
ays953 6448bf4ca2 Release v0.10.0 2026-11-13 14:31:10 +08:00
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
ays953 815dcf979d Release v0.9.1 2026-11-13 12:06:24 +08:00
ays953andClaude Opus 5.5 8e82105af9 Hold the first word on space when it also reads as Zhuyin
At the start of a composition (not right after English), a word that reads as
valid Zhuyin is no longer committed as English on space. The next word decides,
by comparing "Chinese all the way" with "English word + Chinese" using the
classifier's features: el ji3 = 高我, no su3cl3 = no 你好, up the = up the.
After English text only common one-syllable readings (up, url) are held.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 12:06:10 +08:00
ays953 9cac3467a0 Release v0.9.0 2026-11-13 11:59:53 +08:00
ays953andClaude Opus 5.5 49e0b52fd5 Add a Linux version (IBus) for Bazzite / SteamOS desktop mode
linux/autozhuyin_ibus.py is an IBus engine on top of the shared Python core:
preedit with the cursor and blue English segments, lookup table, Shift tap for
English mode, candidate clicks. install.sh puts everything in the home folder
(works on read-only systems) and an autostart entry registers the engine with
ibus-daemon and selects it. Tested with a stand-in IBus module.

Also fixes Windows: wants() did not claim the backtick, so backtick + punctuation
never reached the engine under PIME.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 11:59:40 +08:00
ays953 fcc0f9d2db Release v0.8.0 2026-11-13 09:56:18 +08:00
ays953andClaude Opus 5.5 31d9991e16 Insert and delete syllables at the composition cursor
The ← → cursor is now an editing position (key index), not just a candidate
stop. It can move to the start; typing Zhuyin there composes a syllable at the
cursor and splices it in on its tone key; Backspace removes the character before
the cursor. Picked phrases before the edit point are kept.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 09:56:06 +08:00
ays953 6b4ec39dc1 Release v0.7.1 2026-11-11 17:01:37 +08:00
ays953andClaude Opus 5.5 955b0ca5c3 Ship third-party notices with both installers
THIRD_PARTY_LICENSES.txt carries McBopomofo's full MIT notice (required when the
converted lexicon is distributed) plus notes on the public-domain word list and
PIME. It goes into AutoZhuyin.app/Contents/Resources and the Windows zip.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 17:01:26 +08:00
28 changed files with 1719 additions and 144 deletions
+48 -12
View File
@@ -1,6 +1,6 @@
# 自動注音 AutoZhuyin
給繁體中文使用者的輸入法(macOS、Windows):**不用按切換鍵**,直接用大千注音鍵盤打字,輸入法會自動判斷你打的是注音還是英文。
給繁體中文使用者的輸入法(macOS、Windows、Linux):**不用按切換鍵**,直接用大千注音鍵盤打字,輸入法會自動判斷你打的是注音還是英文。
```
按鍵: ji3 hello world su3cl3␣
@@ -16,6 +16,8 @@
- **注音順序打錯也能修正**:`ㄧㄒㄠˇ`、`ㄒㄠㄧˇ` 都會變成 `ㄒㄧㄠˇ`(小)
- **可省略聲調**:`jiap7`(ㄨㄛ ㄇㄣ˙)一樣能打出「我們」
- **候選字**:用 ← → 把游標移到要改的字後面,按 ↓ 選字;選過的會固定下來
- **記住選字**:從候選字選過的字詞會被記住,下次打同樣的讀音會優先出現(選越多次越優先)
- **中間補字、刪字**:游標移到前面後直接打注音,會插在游標處;Backspace 刪掉游標前的那個字
- **全形標點**:中文語境下 `?` `!` `<` 自動變成 `?` `!` `,`;任何時候按 `` ` `` 再按標點鍵,一定得到全形標點(例如 `` `< `` = `,`)
- **完整詞庫**:約 17 萬筆,來自小麥注音 McBopomofo(MIT 授權)
@@ -44,6 +46,16 @@ PKG 會裝到 `/Library/Input Methods/`,系統上所有使用者都能用。
SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安裝:以系統管理員身分執行 `uninstall.bat`。
### Linux(Bazzite、SteamOS 桌面模式、Fedora…)
需求:系統內建 IBus 輸入法框架(Bazzite、Fedora 預設就有)。只在桌面模式可用,Steam 遊戲模式不支援系統輸入法。
1. 解壓縮 `AutoZhuyin-Linux-<版本>.tar.gz`,在終端機進到資料夾執行 `./install.sh`。不需要 sudo,只會裝在家目錄(`~/.local/share/autozhuyin`),所以唯讀系統也能用。
2. KDE(Bazzite / SteamOS 預設):系統設定 → 鍵盤 → 虛擬鍵盤,選 **IBus Wayland** → 套用,登出再登入。GNOME 不用設定。
3. 之後每次登入會自動切換到自動注音(`~/.config/autostart/autozhuyin.desktop`)。
暫時改回一般鍵盤:`ibus engine xkb:us::eng`;切回:`ibus engine autozhuyin`;移除:`./uninstall.sh`。
## 按鍵
| 按鍵 | 作用 |
@@ -51,7 +63,7 @@ SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安
| 空白 | 注音:一聲;音節已完成時送出中文。英文:送出單字加空白 |
| Enter | 送出目前組字 |
| **Tab** | 判斷錯了?按 Tab 把整段翻轉成另一種語言,輸入法會**記住**這次修正 |
| ← → | 在組字區移動游標,選要改哪個字 |
| ← → | 在組字區移動游標(可移到最前面)。游標在中間時:直接打注音會**插入**新字,Backspace 刪掉游標前的字,↓ 選游標前的字 |
| ↓ | 開啟游標前那個字或詞的候選字(游標預設在最後),數字鍵 1–9 選字,Esc 關閉 |
| Esc | 取消組字 |
| **單按 Shift** | 沒在打字時:切換**英文模式**,按鍵直接送出、保持小寫、沒有底線,一直維持到再單按一次 Shift 才回到中英自動判斷。打到一半時:同 Tab,整段翻轉 |
@@ -86,13 +98,15 @@ SmartScreen 出現警告時,按「其他資訊 → 仍要執行」。解除安
## 個人資料
| | macOS | Windows |
|---|---|---|
| 學習紀錄(Tab 修正) | `UserDefaults`(`com.autozhuyin.inputmethod.AutoZhuyin`) | `%APPDATA%\PIME\autozhuyin\learned.json` |
| 自訂詞 | `~/Library/Application Support/AutoZhuyin/user-phrases.txt` | `%APPDATA%\PIME\autozhuyin\user-phrases.txt` |
| | macOS | Windows | Linux |
|---|---|---|---|
| 學習紀錄(Tab 修正) | `UserDefaults`(`com.autozhuyin.inputmethod.AutoZhuyin`) | `%APPDATA%\PIME\autozhuyin\learned.json` | `~/.config/autozhuyin/learned.json` |
| 選字紀錄 | `~/Library/Application Support/AutoZhuyin/user-history.json` | `%APPDATA%\PIME\autozhuyin\user-history.json` | `~/.config/autozhuyin/user-history.json` |
| 自訂詞 | `~/Library/Application Support/AutoZhuyin/user-phrases.txt` | `%APPDATA%\PIME\autozhuyin\user-phrases.txt` | `~/.config/autozhuyin/user-phrases.txt` |
自訂詞的格式和 `lexicon.txt` 一樣,每行一個詞:`ㄗˋ-ㄉㄨㄥˋ-ㄓㄨˋ-ㄧㄣ 自動注音 -4`(讀音、詞、分數;分數越大越優先)。
Mac 版可以在輸入法選單選「清除學習紀錄」。
選字紀錄最多保留 2000 筆,太久沒用的會先淘汰。被選過的字只會排到同讀音第一順位,不會蓋過整個詞組(例如選過「添」之後,ㄊㄧㄢ 單打會出「添」,但「今天」還是「今天」)。
Mac 版可以在輸入法選單選「清除學習紀錄」(中英判斷和選字紀錄一起清除);Windows、Linux 刪除上面的檔案即可。
## 開發
@@ -125,6 +139,18 @@ scripts/package-windows.sh # 產生 build/AutoZhuyin-Wi
- `windows/autozhuyin/data/` 是產生出來的,不進版本控制。
- 版本號在 `windows/autozhuyin/ime.json`。
### Linux
Linux 版是 IBus 輸入法(`linux/autozhuyin_ibus.py`),直接使用 Windows 版的 Python 核心(`windows/autozhuyin/core/`)和資料。
```bash
python3 -m unittest discover -s linux/tests # 用假的 IBus 模組測試外殼
scripts/package-linux.sh # 產生 build/AutoZhuyin-Linux-<版本>.tar.gz(會先跑測試)
```
- 安裝在使用者目錄,不寫入 `/usr`:開機時由 autostart 啟動 `autozhuyin_ibus.py --activate`,它會把引擎動態註冊給 ibus-daemon 並切換過去。
- 也支援由 ibus-daemon 啟動(`--ibus`,配合 `/usr/share/ibus/component` 的 XML),之後要做 RPM 時可以用。
> 修改核心邏輯時,Swift(`Sources/AutoZhuyinCore/`)和 Python(`windows/autozhuyin/core/`)兩邊都要改,並在兩邊的測試加上相同案例。
### 訓練判斷權重
@@ -178,12 +204,12 @@ scripts/release.sh minor --push # 同時 push commit 和 tag
`release.sh` 會自動:
1. 遞增版本號(`Resources/Info.plist` 的版本與 build 號、`windows/autozhuyin/ime.json`)
2. 跑 Swift 和 Python 全部測試
3. 產生 `build/AutoZhuyin-<版本>.pkg` 和 `build/AutoZhuyin-Windows-<版本>.zip`
3. 產生 `build/AutoZhuyin-<版本>.pkg`、`build/AutoZhuyin-Windows-<版本>.zip`、`build/AutoZhuyin-Linux-<版本>.tar.gz`
4. commit「Release v<版本>」並打上 `v<版本>` tag
任何一步失敗都會把版本號改回去。只想改版本號不打包:`scripts/bump-version.sh [patch|minor|major]`。
最後在 Gitea 用這個 tag 建立 Release,附上 `build/` 裡的 `.pkg` 和 `.zip`。
最後在 Gitea 用這個 tag 建立 Release,附上 `build/` 裡的 `.pkg`、`.zip` 和 `.tar.gz`。
## 專案結構
@@ -211,14 +237,20 @@ windows/
installer/ install.bat、uninstall.bat、給使用者的 README.txt
tests/ Python 測試
tools/ 產生資料檔、圖示
linux/
autozhuyin_ibus.py IBus 外殼(共用 windows/autozhuyin/core)
installer/ install.sh、uninstall.sh、給使用者的 README.txt
tests/ 用假 IBus 模組的外殼測試
training/ 合成資料、訓練權重、Swift/Python 一致性測試資料
THIRD_PARTY_LICENSES.txt 第三方授權聲明(會打包進兩個安裝檔)
```
## 已知限制
- Windows 版還沒在實機上測試過。
- Windows 版、Linux 版還沒在實機上測試過。
- Linux 版只支援 IBus。KDE 上有些 Flatpak 程式(例如 Flatpak 版 Chrome)在 IBus Wayland 下可能打不出字。
- 聲調鍵打在注音符號中間(例如 `uv3l`)無法自動修正。
- 很短的字串本質上就有歧義。像 `up`(也是 ㄧㄣ 因)這種常用的,按空白後會先保留,看下一個詞再決定(`up jo4` = 因為、`up the` = up the);其他判斷錯的可以按 Tab 修正,修正後會記住。
- 很短的字串本質上就有歧義。開頭第一個詞如果也能讀成注音,按空白後會先保留(顯示成英文),看下一個詞再決定:`up jo4` = 因為、`el ji3` = 高我、`no su3cl3` = no 你好、`up the` = up the。接在英文後面時只保留 `up`(因)這種很常見的讀音,不會拖慢打英文。還是判斷錯的話按 Tab 修正,修正後會記住。
- 安裝檔沒有簽章(macOS 沒有 Developer ID,Windows 沒有程式碼簽章憑證)。
## 下一步(Roadmap)
@@ -226,11 +258,13 @@ training/ 合成資料、訓練權重、Swift/Python 一致
- [x] 匯入完整詞庫
- [x] 注音順序錯誤修正
- [x] Windows 版
- [x] Linux 版(IBus)
- [ ] Linux Fcitx5 版(KDE 上相容性較好)
- [x] 用資料訓練判斷權重(合成資料)
- [ ] 加入真實打字資料一起訓練
- [ ] 已送出的英文單字若判斷錯誤,可以「事後翻轉」
- [ ] 用 Core ML 小模型取代手調分數,參考整句語境
- [ ] 使用者詞頻學習(選過的候選字優先)
- [x] 使用者詞頻學習(選過的候選字優先)
- [ ] 偏好設定視窗
## 致謝與授權
@@ -238,3 +272,5 @@ training/ 合成資料、訓練權重、Swift/Python 一致
- 詞庫資料:[小麥注音 McBopomofo](https://github.com/openvanilla/McBopomofo)(MIT License)
- Windows 輸入法框架:[PIME](https://github.com/EasyIME/PIME)(LGPL 2.1,使用者自行安裝,本專案不包含其程式碼)
- 英文字典:Webster's Second International Dictionary(公有領域,macOS 的 `/usr/share/dict/words`)
完整的第三方授權聲明(含小麥注音 MIT 授權全文)見 [THIRD_PARTY_LICENSES.txt](THIRD_PARTY_LICENSES.txt),Mac 版放在 `AutoZhuyin.app/Contents/Resources/`,Windows 版放在 zip 根目錄和安裝後的 `autozhuyin` 資料夾。
+2 -2
View File
@@ -15,9 +15,9 @@
<key>CFBundlePackageType</key>
<string>APPL</string>
<key>CFBundleShortVersionString</key>
<string>0.7.0</string>
<string>0.10.0</string>
<key>CFBundleVersion</key>
<string>12</string>
<string>17</string>
<key>InputMethodConnectionName</key>
<string>com.autozhuyin.inputmethod.AutoZhuyin_Connection</string>
<key>InputMethodServerControllerClass</key>
+16 -4
View File
@@ -9,6 +9,11 @@ enum Shared {
static let learnedKey = "LearnedPreferences"
/// ~/Library/Application Support/AutoZhuyin (user phrases, picked-candidate history).
static let supportDir: URL? = FileManager.default
.urls(for: .applicationSupportDirectory, in: .userDomainMask).first?
.appendingPathComponent("AutoZhuyin")
static let classifier: Classifier = {
let bundle = Bundle.main
let start = Date()
@@ -18,9 +23,9 @@ enum Shared {
lexicon.load(data: data)
}
// Optional user phrases: ~/Library/Application Support/AutoZhuyin/user-phrases.txt
if let support = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first {
let userFile = support.appendingPathComponent("AutoZhuyin/user-phrases.txt")
if let text = try? String(contentsOf: userFile, encoding: .utf8) { lexicon.load(text) }
if let userFile = supportDir?.appendingPathComponent("user-phrases.txt"),
let text = try? String(contentsOf: userFile, encoding: .utf8) {
lexicon.load(text)
}
let english = EnglishModel(commonWordsURL: bundle.url(forResource: "english-common", withExtension: "txt"),
dictionaryURL: bundle.url(forResource: "english-dict", withExtension: "txt"),
@@ -29,11 +34,17 @@ enum Shared {
let learned = LearnedPreferences(weights: saved) { weights in
UserDefaults.standard.set(weights, forKey: learnedKey)
}
let historyFile = supportDir?.appendingPathComponent("user-history.json")
let history = UserHistory(data: historyFile.map(UserHistory.load(from:)) ?? [:]) { data in
guard let url = historyFile, let json = try? JSONEncoder().encode(data) else { return }
try? FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
try? json.write(to: url, options: .atomic)
}
let trained = Features.loadWeights(from: bundle.url(forResource: "classifier-weights", withExtension: "json"))
NSLog("AutoZhuyin: data loaded in %.0f ms", Date().timeIntervalSince(start) * 1000)
// Only needed for untoned syllables; build it off the startup path.
DispatchQueue.global(qos: .utility).async { lexicon.prepareTonelessIndex() }
return Classifier(lexicon: lexicon, english: english, learned: learned, weights: trained)
return Classifier(lexicon: lexicon, english: english, learned: learned, weights: trained, history: history)
}()
}
@@ -177,5 +188,6 @@ final class InputController: IMKInputController {
@objc private func clearLearned(_ sender: Any?) {
Shared.classifier.learned.clear()
Shared.classifier.history.clear()
}
}
+4 -1
View File
@@ -55,14 +55,17 @@ public final class Classifier {
public let lexicon: Lexicon
public let english: EnglishModel
public let learned: LearnedPreferences
/// Picked candidates (shared by every engine using this classifier).
public let history: UserHistory
/// Feature weights: the hand-tuned defaults overlaid with trained ones.
public private(set) var weights: FeatureVector
public init(lexicon: Lexicon, english: EnglishModel, learned: LearnedPreferences = LearnedPreferences(),
weights: FeatureVector = [:]) {
weights: FeatureVector = [:], history: UserHistory = UserHistory()) {
self.lexicon = lexicon
self.english = english
self.learned = learned
self.history = history
self.weights = Features.defaultWeights.merging(weights) { _, new in new }
}
+219 -45
View File
@@ -45,15 +45,18 @@ public final class CompositionEngine {
private var fixed: [Int: [Range<Int>: String]] = [:]
public private(set) var candidates: [Candidate] = []
private var candidateSegmentStart = 0
/// Composition cursor for choosing candidates: index into `cursorStops`, nil = at the end.
/// ← → move it; ↓ shows candidates for the phrase ending at the cursor.
/// Composition cursor: a key index into `keys` (nil = at the end). ← → move it between
/// syllables; ↓ shows candidates for the phrase before it; typing there inserts a
/// syllable (kept in `inserting` until its tone key, then spliced into `keys`).
private var cursor: Int?
private var inserting: [Character] = []
public var candidateIndex = 0
public var isShowingCandidates: Bool { !candidates.isEmpty }
/// Index of a held space: an English word that is also a common one-syllable Chinese
/// reading ("up " = ㄧㄣ 因) is not committed on space; the next word decides
/// ("up jo4" = 因為, "up the" = up the).
/// Index of a held space: the first word of a composition that also reads as Zhuyin is
/// not committed as English on space; the next word decides ("up jo4" = 因為,
/// "up the" = up the, "no su3" = no 你). Right after English text only common
/// one-syllable readings are held (up = 因, url = 教), so English typing isn't delayed.
private var held: Int?
/// "`" was typed: if the next key is in `symbols` it gives that full-width symbol
/// whatever the context; anything else makes it a plain backtick (so ``` still works).
@@ -68,7 +71,7 @@ public final class CompositionEngine {
public init(classifier: Classifier) {
self.classifier = classifier
self.converter = Converter(lexicon: classifier.lexicon)
self.converter = Converter(lexicon: classifier.lexicon, history: classifier.history)
}
// MARK: - Derived state
@@ -92,19 +95,38 @@ public final class CompositionEngine {
let rest = classifier.segment(Array(keys[base...]), finishing: finishing, previous: nil).map {
Segment(range: ($0.range.lowerBound + base)..<($0.range.upperBound + base), mode: $0.mode)
}
if let first = rest.first, first.mode == .zhuyin {
if let first = rest.first, first.mode == .zhuyin,
heldReadsAsChinese(keys, held: h, end: first.range.upperBound, finishing: finishing) {
return [Segment(range: 0..<first.range.upperBound, mode: .zhuyin)] + rest.dropFirst()
}
return [Segment(range: 0..<base, mode: .literal)] + rest
}
/// Chinese all the way to `end` vs. the held English word followed by Chinese.
private func heldReadsAsChinese(_ keys: [Character], held h: Int, end: Int, finishing: Bool) -> Bool {
let c = classifier, w = classifier.weights, ctx = context
let isLast = end == keys.count
guard let zhWhole = c.segmentFeatures(Array(keys[..<end]), isLast: isLast, afterOther: false,
finishing: finishing, previous: ctx).0 else { return false }
guard let word = c.segmentFeatures(Array(keys[..<h]), isLast: false, afterOther: false,
finishing: true, previous: ctx).1,
let zhRest = c.segmentFeatures(Array(keys[(h + 1)..<end]), isLast: isLast, afterOther: true,
finishing: finishing, previous: nil).0 else { return true }
return Features.dot(w, zhWhole) >= Features.dot(w, word) + Features.dot(w, zhRest)
}
/// Whether keys + space also read as a common Chinese syllable (see `held`).
private func isAmbiguousWord(_ keys: [Character]) -> Bool {
guard keys.allSatisfy({ $0.isASCII && $0.isLetter }) else { return false }
let p = ZhuyinParser.parse(keys + [" "])
guard p.pending == nil, p.syllables.count == 1 else { return false }
guard let best = classifier.lexicon.entries(for: p.syllables.map(\.syllable)).first else { return false }
return best.score >= CompositionEngine.holdMinScore
guard p.pending == nil, !p.syllables.isEmpty, p.strayTones == 0, p.foreignKeys == 0 else { return false }
var best: [Double] = []
for ps in p.syllables {
guard let e = classifier.lexicon.entries(for: [ps.syllable]).first else { return false }
best.append(e.score)
}
if context != .literal { return true } // first word: hold anything that reads as Zhuyin
return best.count == 1 && best[0] >= CompositionEngine.holdMinScore
}
/// Current split of the buffer into Zhuyin / literal runs.
@@ -117,14 +139,35 @@ public final class CompositionEngine {
public var markedText: String { markedPieces.map(\.text).joined() }
public var markedPieces: [MarkedPiece] {
let segs = segments
var pieces = segs.enumerated().map { i, seg in
MarkedPiece(text: render(seg, final: i < segs.count - 1), mode: seg.mode)
var pieces = segmentPieces
if !inserting.isEmpty {
// Show the syllable being inserted at the cursor.
var at = baseCursorOffset, out: [MarkedPiece] = [], done = false
for piece in pieces {
if !done && at <= piece.text.count {
let i = piece.text.index(piece.text.startIndex, offsetBy: at)
out.append(MarkedPiece(text: String(piece.text[..<i]), mode: piece.mode))
out.append(MarkedPiece(text: insertingText, mode: .zhuyin))
out.append(MarkedPiece(text: String(piece.text[i...]), mode: piece.mode))
done = true
} else {
out.append(piece)
at -= piece.text.count
}
}
pieces = out.filter { !$0.text.isEmpty }
}
if pendingBacktick { pieces.append(MarkedPiece(text: "`", mode: .literal)) }
return pieces
}
private var segmentPieces: [MarkedPiece] {
let segs = segments
return segs.enumerated().map { i, seg in
MarkedPiece(text: render(seg, final: i < segs.count - 1), mode: seg.mode)
}
}
/// Text for one segment. A non-final Zhuyin segment shows its unfinished syllable as Bopomofo.
private func render(_ seg: Segment, final: Bool) -> String {
guard seg.mode == .zhuyin else { return String(keys[seg.range]) }
@@ -148,43 +191,151 @@ public final class CompositionEngine {
// MARK: - Cursor
/// A place the cursor can stop: after the `local`-th syllable of Zhuyin segment `segIndex`.
/// Absolute key index after each syllable of a Zhuyin segment.
private func syllableEnds(_ seg: Segment) -> [Int] {
ZhuyinParser.parse(Array(keys[seg.range])).syllables.map { seg.range.lowerBound + $0.keyRange.upperBound }
}
/// Key indices the cursor can stop at: the start, after every Zhuyin syllable, and at
/// every segment boundary.
private var cursorPositions: [Int] {
var out: Set<Int> = [0, keys.count]
for seg in segments {
out.insert(seg.range.upperBound)
if seg.mode == .zhuyin { out.formUnion(syllableEnds(seg)) }
}
return out.sorted()
}
/// A place to open candidates: after the `local`-th syllable of Zhuyin segment `segIndex`.
private struct CursorStop { let segIndex: Int; let local: Int }
private var cursorStops: [CursorStop] {
private func stop(at pos: Int) -> CursorStop? {
let segs = segments
var out: [CursorStop] = []
for (i, seg) in segs.enumerated() where seg.mode == .zhuyin {
for (i, seg) in segs.enumerated() where seg.mode == .zhuyin
&& seg.range.lowerBound < pos && pos <= seg.range.upperBound {
let n = convertibleSyllables(seg, final: i < segs.count - 1).syllables.count
for k in stride(from: 1, through: n, by: 1) { out.append(CursorStop(segIndex: i, local: k)) }
let local = syllableEnds(seg).filter { $0 <= pos }.count
return local > 0 ? CursorStop(segIndex: i, local: min(local, n)) : nil
}
return out
return nil
}
/// Where ↓ opens candidates: before the cursor, or the last syllable.
private var candidateStop: CursorStop? {
if let c = cursor { return stop(at: c) }
let segs = segments
for i in segs.indices.reversed() where segs[i].mode == .zhuyin {
let n = convertibleSyllables(segs[i], final: i < segs.count - 1).syllables.count
if n > 0 { return CursorStop(segIndex: i, local: n) }
}
return nil
}
/// Cursor position in the rendered segments (without the syllable being inserted).
private var baseCursorOffset: Int {
let pieces = segmentPieces
guard let c = cursor else { return pieces.reduce(0) { $0 + $1.text.count } }
let segs = segments
for (i, seg) in segs.enumerated() where seg.range.lowerBound < c && c <= seg.range.upperBound {
var offset = pieces[..<i].reduce(0) { $0 + $1.text.count }
if seg.mode == .literal { return offset + c - seg.range.lowerBound }
let local = stop(at: c)?.local ?? 0
for conv in conversion(of: seg, final: i < segs.count - 1).segments {
if conv.range.upperBound <= local {
offset += conv.text.count
} else if conv.range.lowerBound < local {
offset += min(local - conv.range.lowerBound, conv.text.count)
}
}
return offset
}
return 0
}
/// Cursor position in `markedText`, in Characters.
public var cursorOffset: Int {
let pieces = markedPieces
let total = pieces.reduce(0) { $0 + $1.text.count }
let stops = cursorStops
guard let c = cursor, stops.indices.contains(c) else { return total }
let stop = stops[c]
var offset = pieces[..<stop.segIndex].reduce(0) { $0 + $1.text.count }
let segs = segments
for conv in conversion(of: segs[stop.segIndex], final: stop.segIndex < segs.count - 1).segments {
if conv.range.upperBound <= stop.local {
offset += conv.text.count
} else if conv.range.lowerBound < stop.local {
offset += min(stop.local - conv.range.lowerBound, conv.text.count)
}
}
return offset
public var cursorOffset: Int { baseCursorOffset + insertingText.count }
private var insertingText: String {
inserting.isEmpty ? "" : ZhuyinParser.parse(inserting).syllables.map(\.syllable.reading).joined()
}
private func moveCursor(by delta: Int) {
let stops = cursorStops
guard !stops.isEmpty else { return }
let next = (cursor ?? stops.count - 1) + delta
cursor = next >= stops.count - 1 ? nil : max(0, next)
inserting = []
let stops = cursorPositions
let here = cursor ?? keys.count
let next = delta < 0 ? (stops.last { $0 < here } ?? here) : (stops.first { $0 > here } ?? here)
cursor = next >= keys.count ? nil : next
}
// MARK: - Editing in the middle
/// Keeps picked phrases that end at or before key index `pos` (they don't move).
private func trimFixed(at pos: Int) {
var kept: [Int: [Range<Int>: String]] = [:]
for seg in segments where seg.mode == .zhuyin {
guard let picks = fixed[seg.range.lowerBound] else { continue }
if seg.range.upperBound <= pos {
kept[seg.range.lowerBound] = picks
} else if seg.range.lowerBound < pos {
let ends = syllableEnds(seg)
let here = picks.filter { $0.key.upperBound <= ends.count && ends[$0.key.upperBound - 1] <= pos }
if !here.isEmpty { kept[seg.range.lowerBound] = here }
}
}
fixed = kept
}
/// Inserts keys at the cursor and moves the cursor after them.
private func splice(_ newKeys: [Character]) {
guard let pos = cursor else { keys += newKeys; return }
trimFixed(at: pos)
keys.insert(contentsOf: newKeys, at: pos)
if let h = held, h >= pos { held = h + newKeys.count }
let next = pos + newKeys.count
cursor = next >= keys.count ? nil : next
}
/// Backspace in the middle: removes the syllable (or literal key) before the cursor.
private func deleteBeforeCursor(_ pos: Int) {
var start = pos - 1
for seg in segments where seg.mode == .zhuyin && seg.range.lowerBound < pos && pos <= seg.range.upperBound {
for ps in ZhuyinParser.parse(Array(keys[seg.range])).syllables
where seg.range.lowerBound + ps.keyRange.upperBound == pos {
start = seg.range.lowerBound + ps.keyRange.lowerBound
}
}
trimFixed(at: start)
keys.removeSubrange(start..<pos)
if let h = held {
if h >= start && h < pos { held = nil } else if h >= pos { held = h - (pos - start) }
}
cursor = start
if keys.isEmpty { reset() }
}
/// Typing with the cursor in the middle: compose one syllable, splice it in on its tone.
private func insertKey(_ c: Character) -> KeyResult {
if c == " " {
if inserting.isEmpty { return KeyResult(handled: true, commit: commitCurrent()) }
splice(inserting + [" "])
inserting = []
return .consumed
}
inserting.append(c)
let p = ZhuyinParser.parse(inserting)
if p.strayTones > 0 || p.foreignKeys > 0 {
inserting.removeLast() // a tone with nothing to attach to
} else if p.syllables.count == 1, p.syllables[0].toned {
splice(inserting)
inserting = []
} else if p.syllables.count > 1 {
// A new syllable started without a tone: splice the first one as it is.
let first = p.syllables[0].keyRange.upperBound
splice(Array(inserting[..<first]))
inserting = Array(inserting[first...])
}
return .consumed
}
// MARK: - Key handling
@@ -192,13 +343,20 @@ public final class CompositionEngine {
public func handle(_ key: KeyInput) -> KeyResult {
if isShowingCandidates { return handleCandidateKey(key) }
if pendingBacktick { return afterBacktick(key) }
if !inserting.isEmpty && (key == .backspace || key == .escape) {
if key == .backspace { inserting.removeLast() } else { inserting = [] }
return .consumed
}
switch key {
case .character(let c):
return handleCharacter(c)
case .backspace:
guard !keys.isEmpty else { return .passThrough }
cursor = nil
if let c = cursor {
if c > 0 { deleteBeforeCursor(c) }
return .consumed
}
keys.removeLast()
if let h = held, keys.count <= h { held = nil }
fixed = fixed.filter { $0.key < keys.count }
@@ -206,6 +364,7 @@ public final class CompositionEngine {
return .consumed
case .enter:
guard !keys.isEmpty else { return .passThrough }
if !inserting.isEmpty { splice(inserting); inserting = [] }
return KeyResult(handled: true, commit: commitCurrent())
case .escape:
guard !keys.isEmpty else { return .passThrough }
@@ -227,7 +386,7 @@ public final class CompositionEngine {
return .consumed
case .down:
guard !keys.isEmpty else { return .passThrough }
openCandidates()
if inserting.isEmpty { openCandidates() }
return .consumed
case .left:
guard !keys.isEmpty else { return .passThrough }
@@ -248,7 +407,11 @@ public final class CompositionEngine {
}
private func handleCharacter(_ c: Character) -> KeyResult {
cursor = nil // typing always continues at the end
if cursor != nil, !keys.isEmpty, c == " " || DachenLayout.isZhuyinKey(c) {
return insertKey(c)
}
if !inserting.isEmpty { splice(inserting); inserting = [] }
cursor = nil // anything else continues at the end
// English mode: every key goes to the app as typed.
if isEnglishMode && keys.isEmpty { return .passThrough }
if c == "`" {
@@ -329,9 +492,7 @@ public final class CompositionEngine {
/// Opens candidates for the phrase ending at the cursor (default: the last syllable).
private func openCandidates() {
let stops = cursorStops
guard !stops.isEmpty else { return }
let stop = stops[min(cursor ?? stops.count - 1, stops.count - 1)]
guard let stop = candidateStop else { return }
let segs = segments
let seg = segs[stop.segIndex]
let syl = convertibleSyllables(seg, final: stop.segIndex < segs.count - 1).syllables
@@ -376,6 +537,7 @@ public final class CompositionEngine {
private func commitCurrent(_ given: [Segment]? = nil) -> String {
let segs = given ?? segments
let text = segs.map { render($0, final: true) }.joined()
rememberPicks(segs)
if let forced = forcedMode {
classifier.learned.record(String(keys), as: forced)
}
@@ -385,6 +547,17 @@ public final class CompositionEngine {
return text
}
/// Candidates the user picked are remembered and come first next time.
private func rememberPicks(_ segs: [Segment]) {
for seg in segs where seg.mode == .zhuyin {
guard let picks = fixed[seg.range.lowerBound], !picks.isEmpty else { continue }
let syl = convertibleSyllables(seg, final: true).syllables
for (range, text) in picks where range.upperBound <= syl.count {
classifier.history.record(Array(syl[range]), phrase: text)
}
}
}
/// Commits whatever is composed (e.g. the app lost focus). Returns "" when empty.
public func commitAll() -> String {
keys.isEmpty ? "" : commitCurrent()
@@ -392,6 +565,7 @@ public final class CompositionEngine {
public func reset() {
keys = []
inserting = []
held = nil
pendingBacktick = false
cursor = nil
+13 -3
View File
@@ -13,12 +13,22 @@ public struct Candidate: Equatable {
/// Turns a syllable sequence into the most likely Chinese text (Viterbi over the lexicon).
public struct Converter {
public let lexicon: Lexicon
/// Picked candidates come first.
public let history: UserHistory?
/// Score used when a syllable has no lexicon entry; the Bopomofo itself is emitted.
static let unknownScore = -30.0
/// Penalty for matching an untoned syllable against all tones.
static let tonelessPenalty = -1.5
public init(lexicon: Lexicon) { self.lexicon = lexicon }
public init(lexicon: Lexicon, history: UserHistory? = nil) {
self.lexicon = lexicon
self.history = history
}
private func entries(_ syllables: [Syllable]) -> [LexiconEntry] {
let e = lexicon.entries(for: syllables)
return history?.adjust(syllables, e) ?? e
}
/// - Parameter fixed: user-chosen phrases by syllable range; they are always kept.
public func convert(_ syllables: [Syllable], fixed: [Range<Int>: String] = [:]) -> [ConvertedSegment] {
@@ -57,7 +67,7 @@ public struct Converter {
if fixed.keys.contains(where: { $0.overlaps(range) }) { return [] }
let slice = Array(syllables[range])
var result = lexicon.entries(for: slice).map { entry -> (String, Double) in
var result = entries(slice).map { entry -> (String, Double) in
let penalty = slice.contains { $0.tone == nil } ? Converter.tonelessPenalty : 0
return (entry.phrase, entry.score + penalty)
}
@@ -74,7 +84,7 @@ public struct Converter {
var seen = Set<String>()
for len in stride(from: min(lexicon.maxPhraseLength, end), through: 1, by: -1) {
let range = (end - len)..<end
for entry in lexicon.entries(for: Array(syllables[range])) where !seen.contains(entry.phrase) {
for entry in entries(Array(syllables[range])) where !seen.contains(entry.phrase) {
seen.insert(entry.phrase)
out.append(Candidate(range: range, text: entry.phrase))
}
+79
View File
@@ -0,0 +1,79 @@
import Foundation
/// Remembers the candidates the user picked, so they come first next time.
///
/// Keys are toneless readings ("ㄊㄧㄢ", "ㄐㄧㄣ-ㄊㄧㄢ"); a picked phrase is boosted only
/// where the lexicon has it for the reading being converted, so a toneless key is safe.
/// Stored as JSON: {reading: {phrase: [count, last use]}} (same format on every platform).
public final class UserHistory {
public typealias Data = [String: [String: [Int]]]
/// (reading, phrase) pairs kept; the least recently used go first.
public var maxEntries = 2000
static let maxCount = 10
public private(set) var data: Data = [:]
private var clock = 0
private let onChange: (Data) -> Void
public init(data: Data = [:], onChange: @escaping (Data) -> Void = { _ in }) {
self.onChange = onChange
for (reading, phrases) in data {
for (phrase, value) in phrases where value.count >= 2 {
self.data[reading, default: [:]][phrase] = [value[0], value[1]]
clock = max(clock, value[1])
}
}
}
/// Loads the JSON file written through `onChange`; empty if missing or unreadable.
public static func load(from url: URL) -> Data {
guard let raw = try? Foundation.Data(contentsOf: url),
let data = try? JSONDecoder().decode(Data.self, from: raw) else { return [:] }
return data
}
static func key(_ syllables: [Syllable]) -> String {
syllables.map(\.toneless).joined(separator: "-")
}
public func record(_ syllables: [Syllable], phrase: String) {
guard !syllables.isEmpty, !phrase.isEmpty else { return }
clock += 1
let key = UserHistory.key(syllables)
let count = data[key]?[phrase]?.first ?? 0
data[key, default: [:]][phrase] = [min(UserHistory.maxCount, count + 1), clock]
evict()
onChange(data)
}
private func evict() {
var pairs: [(used: Int, reading: String, phrase: String)] = []
for (r, phrases) in data { for (p, v) in phrases { pairs.append((v[1], r, p)) } }
guard pairs.count > maxEntries else { return }
pairs.sort { $0.used < $1.used }
for pair in pairs.prefix(pairs.count - maxEntries) {
data[pair.reading]?[pair.phrase] = nil
if data[pair.reading]?.isEmpty == true { data[pair.reading] = nil }
}
}
public func clear() {
data = [:]
onChange(data)
}
/// Lexicon entries with picked phrases moved to the top: just above the best entry,
/// more so the more often they were picked.
func adjust(_ syllables: [Syllable], _ entries: [LexiconEntry]) -> [LexiconEntry] {
guard let picked = data[UserHistory.key(syllables)], let top = entries.first?.score else { return entries }
var out = entries.map { e -> LexiconEntry in
guard let count = picked[e.phrase]?.first else { return e }
return LexiconEntry(phrase: e.phrase, score: max(e.score, top + 0.01 + 0.1 * Double(count)))
}
// Stable sort (keep lexicon order among equal scores), like Python's sort.
out = out.enumerated().sorted { $0.element.score != $1.element.score
? $0.element.score > $1.element.score : $0.offset < $1.offset }.map(\.element)
return out
}
}
+50
View File
@@ -0,0 +1,50 @@
自動注音 AutoZhuyin — 第三方授權聲明 / Third-party notices
==========================================================
本軟體包含或使用下列第三方資料。
This software includes or uses the following third-party material.
1. 小麥注音 McBopomofo — 詞庫資料 (lexicon data)
------------------------------------------------
https://github.com/openvanilla/McBopomofo
lexicon.txt is converted from McBopomofo's data files (BPMFBase.txt,
BPMFMappings.txt, phrase.occ) by scripts/convert-mcbopomofo.py. No McBopomofo
program code is included.
MIT License
Copyright (c) 2011-2026 Mengjuei Hsieh et al.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
2. Webster's Second International Dictionary — 英文字典 (English word list)
--------------------------------------------------------------------------
english-dict.txt is filtered from /usr/share/dict/words (Webster's Second
International Dictionary, 1934), which is in the public domain.
3. PIME — Windows 輸入法框架 (input method framework)
----------------------------------------------------
https://github.com/EasyIME/PIME — GNU LGPL 2.1
The Windows version runs as a module inside PIME, which users install
separately. No PIME code is included in this software.
@@ -369,7 +369,8 @@ final class CursorTests: XCTestCase {
func type(_ s: String, into e: CompositionEngine) -> String {
var out = ""
for c in s {
let key: KeyInput = c == "←" ? .left : c == "→" ? .right : c == "↓" ? .down : c == "\n" ? .enter : .character(c)
let key: KeyInput = c == "←" ? .left : c == "→" ? .right : c == "↓" ? .down : c == "\n" ? .enter
: c == "\u{8}" ? .backspace : .character(c)
let r = e.handle(key)
if let t = r.commit { out += t } else if !r.handled { out.append(c) }
}
@@ -383,7 +384,7 @@ final class CursorTests: XCTestCase {
_ = type("←", into: e)
XCTAssertEqual(e.cursorOffset, 3)
_ = type("←←←←", into: e)
XCTAssertEqual(e.cursorOffset, 1) // stops after the first character
XCTAssertEqual(e.cursorOffset, 0) // stops at the start
_ = type("→→→→", into: e)
XCTAssertEqual(e.cursorOffset, 4)
}
@@ -399,12 +400,48 @@ final class CursorTests: XCTestCase {
XCTAssertEqual(type("\n", into: e), "今添天氣")
}
func testTypingReturnsCursorToEnd() {
func testPunctuationCommitsFromTheMiddle() {
let e = engine()
_ = type("rup wu0 ←", into: e)
XCTAssertEqual(e.cursorOffset, 1)
_ = type("wu0 ", into: e)
XCTAssertEqual(e.cursorOffset, e.markedText.count)
_ = type("?", into: e)
XCTAssertEqual(e.markedText, "")
}
func testInsertSyllable() {
let e = engine()
_ = type("rup fu4←wu", into: e)
XCTAssertEqual(e.markedText, "今ㄊㄧ氣")
XCTAssertEqual(e.cursorOffset, 3)
_ = type("0 ", into: e)
XCTAssertEqual(e.markedText, "今天氣")
XCTAssertEqual(e.cursorOffset, 2)
XCTAssertEqual(type("\n", into: e), "今天氣")
}
func testInsertAtStart() {
XCTAssertEqual(type("su3cl3←←ji3\n", into: engine()), "我你好")
}
func testBackspaceDeletesCharacterBeforeCursor() {
let e = engine()
_ = type("rup wu0 wu0 fu4←←\u{8}", into: e)
XCTAssertEqual(e.markedText, "今天氣")
XCTAssertEqual(e.cursorOffset, 1)
}
func testBackspaceInsideInsertedSyllable() {
let e = engine()
_ = type("rup fu4←wu\u{8}", into: e)
XCTAssertEqual(e.markedText, "今ㄊ氣")
}
func testKeepsPickedPhraseBeforeCursor() {
let e = engine()
_ = type("rup wu0 ↓", into: e)
e.selectCandidate(e.candidates.firstIndex { $0.text == "添" }!)
_ = type("fu4←wu0 ", into: e) // insert 天 between 添 and 氣
XCTAssertEqual(String(e.markedText.prefix(3)), "今添天")
}
func testCandidatesForChineseBeforeEnglish() {
@@ -422,8 +459,10 @@ final class FirstToneAfterEnglishTests: XCTestCase {
let e = CompositionEngine(classifier: Classifier(lexicon: sharedLexicon, english: sharedEnglish, weights: sharedWeights))
var out = ""
for c in "hello " + keys + " " { if let t = e.handle(.character(c)).commit { out += t } }
XCTAssertEqual(out, "hello ", keys)
XCTAssertEqual(e.markedText.count, 1, keys) // still composing one Chinese character
out += e.handle(.enter).commit ?? ""
XCTAssertEqual(String(out.prefix(6)), "hello ", keys)
XCTAssertEqual(out.count, 7, keys) // one Chinese character after it
XCTAssertFalse(out.last!.isASCII, keys)
}
}
}
@@ -500,6 +539,106 @@ final class BacktickSymbolTests: XCTestCase {
}
}
final class FirstWordHoldTests: XCTestCase {
func makeEngine() -> CompositionEngine {
CompositionEngine(classifier: Classifier(lexicon: sharedLexicon, english: sharedEnglish, weights: sharedWeights))
}
func type(_ s: String, into e: CompositionEngine) -> String {
var out = ""
for c in s {
let r = e.handle(c == "\n" ? .enter : .character(c))
if let t = r.commit { out += t } else if !r.handled { out.append(c) }
}
return out
}
/// The first word is not committed as English on space if it also reads as Zhuyin.
func testNextWordDecides() {
let cases = ["el ji3 ": "高我", "no su3cl3 ": "no 你好", "ok ji3 ": "ok 我",
"i love you ": "i love you ", "up the ": "up the "]
for (keys, want) in cases {
XCTAssertEqual(type(keys, into: makeEngine()), want, keys)
}
}
func testNotHeldAfterEnglish() {
let e = makeEngine()
XCTAssertEqual(type("hello world ", into: e), "hello world ")
XCTAssertEqual(type("so ", into: e), "so ") // right after English: commits at once
}
}
final class UserHistoryTests: XCTestCase {
var saved: [UserHistory.Data] = []
var classifier: Classifier!
override func setUp() {
saved = []
classifier = Classifier(lexicon: sharedLexicon, english: sharedEnglish, weights: sharedWeights,
history: UserHistory { [unowned self] in self.saved.append($0) })
}
func type(_ s: String, into e: CompositionEngine) -> String {
var out = ""
for c in s {
let key: KeyInput = c == "↓" ? .down : c == "\n" ? .enter : .character(c)
let r = e.handle(key)
if let t = r.commit { out += t } else if !r.handled { out.append(c) }
}
return out
}
@discardableResult
func pick(_ keys: String, _ phrase: String) -> String {
let e = CompositionEngine(classifier: classifier)
_ = type(keys + "↓", into: e)
e.selectCandidate(e.candidates.firstIndex { $0.text == phrase }!)
return type("\n", into: e)
}
func testPickedCandidateComesFirst() {
XCTAssertEqual(type("wu0 \n", into: CompositionEngine(classifier: classifier)), "天")
XCTAssertEqual(pick("wu0 ", "添"), "添")
XCTAssertEqual(type("wu0 \n", into: CompositionEngine(classifier: classifier)), "添")
let e = CompositionEngine(classifier: classifier)
_ = type("wu0 ↓", into: e)
XCTAssertEqual(e.candidates.first?.text, "添")
XCTAssertEqual(saved.last, ["ㄊㄧㄢ": ["添": [1, 1]]])
}
func testPhrasesStillWin() {
pick("wu0 ", "添")
XCTAssertEqual(type("rup wu0 \n", into: CompositionEngine(classifier: classifier)), "今天")
}
func testMostPickedWins() {
pick("wu0 ", "添")
pick("wu0 ", "添")
pick("wu0 ", "天")
XCTAssertEqual(type("wu0 \n", into: CompositionEngine(classifier: classifier)), "添")
}
func testRoundTripAndClear() throws {
pick("wu0 ", "添")
let json = try JSONEncoder().encode(saved.last!)
let h = UserHistory(data: try JSONDecoder().decode(UserHistory.Data.self, from: json))
XCTAssertEqual(h.data, ["ㄊㄧㄢ": ["添": [1, 1]]])
h.record(ZhuyinParser.parse(Array("wu0 ")).syllables.map(\.syllable), phrase: "天")
XCTAssertEqual(h.data["ㄊㄧㄢ"]?["天"], [1, 2])
h.clear()
XCTAssertTrue(h.data.isEmpty)
}
func testEvictsLeastRecent() {
let h = UserHistory()
h.maxEntries = 2
let syl = ZhuyinParser.parse(Array("wu0 ")).syllables.map(\.syllable)
for p in ["天", "添", "田"] { h.record(syl, phrase: p) }
XCTAssertEqual(Set(h.data["ㄊㄧㄢ"]!.keys), ["添", "田"])
}
}
final class StartupTimingTests: XCTestCase {
func testStartupTiming() throws {
var t = Date()
+328
View File
@@ -0,0 +1,328 @@
#!/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:]))
+59
View File
@@ -0,0 +1,59 @@
自動注音 AutoZhuyin(Linux 測試版,IBus)
=========================================
用大千注音鍵盤直接打字,不用切換中英文,輸入法會自動判斷你打的是注音還是英文。
按鍵: ji3 hello world su3cl3 (最後按空白)
輸出: 我hello world 你好
適用:Bazzite、SteamOS 桌面模式、Fedora 等有 IBus 的系統(KDE 或 GNOME)。
只在桌面模式可用;Steam 遊戲模式不支援系統輸入法。
安裝
----
1. 解壓縮,在終端機(Konsole)進到這個資料夾,執行:
./install.sh
不需要 sudo,檔案只會裝在你的家目錄(~/.local/share/autozhuyin)。
2. KDE(Bazzite / SteamOS 預設):
系統設定 → 鍵盤 → 虛擬鍵盤,選「IBus Wayland」→ 套用,然後登出再登入。
GNOME:IBus 是內建的,不用另外設定。
3. 之後每次登入都會自動切換到自動注音。
使用方式
--------
空白 注音:一聲;音節打完時送出中文。英文:送出單字加空白
Enter 送出目前組字
Tab 判斷錯了?按 Tab 在中/英之間翻轉,輸入法會記住這次修正
← → 在組字區移動游標;游標在中間時直接打注音會插入新字,
Backspace 刪掉游標前的字
↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字;
選過的字會被記住,下次優先出現
Esc 取消組字
單按 Shift 切換英文模式(按鍵直接送出),再單按一次回到中英自動判斷
Shift+字母 打大寫字母(也會強制英文)
` + 標點 強制全形標點,例如 `< 或 `, = , `. = 。 `/ = ? `; = ;
注音符號的順序打錯也沒關係,例如 ㄧㄒㄠˇ 會自動變成 ㄒㄧㄠˇ(小)。
切換與移除
----------
暫時改回一般鍵盤: ibus engine xkb:us::eng
切回自動注音: ibus engine autozhuyin
移除: ./uninstall.sh
個人資料(學習紀錄、自訂詞)在 ~/.config/autozhuyin/:
learned.json 按 Tab 修正的學習紀錄
user-history.json 選字紀錄(選過的候選字)
user-phrases.txt 自訂詞,一行一個,例如:ㄗˋ-ㄉㄨㄥˋ 自動 -1
有問題時
--------
在終端機手動執行看看錯誤訊息:
/usr/bin/python3 ~/.local/share/autozhuyin/autozhuyin_ibus.py --activate
把畫面上的訊息回報給我。
+63
View File
@@ -0,0 +1,63 @@
#!/bin/bash
# Installs AutoZhuyin (自動注音) for the current user as an IBus input method.
# Nothing outside your home folder is touched, so it works on read-only systems
# (Bazzite, SteamOS, Fedora Atomic). No sudo needed.
set -euo pipefail
cd "$(dirname "$0")"
DEST="${XDG_DATA_HOME:-$HOME/.local/share}/autozhuyin"
AUTOSTART="${XDG_CONFIG_HOME:-$HOME/.config}/autostart"
PY=/usr/bin/python3
echo "== 自動注音 AutoZhuyin 安裝 =="
# 1. IBus and its Python bindings must come with the system.
if ! command -v ibus >/dev/null 2>&1; then
echo "找不到 IBus(ibus 指令)。這個系統沒有內建 IBus,自動注音目前只支援 IBus。" >&2
exit 1
fi
if ! "$PY" -c 'import gi; gi.require_version("IBus", "1.0"); from gi.repository import IBus' 2>/dev/null; then
echo "系統的 Python 缺少 IBus 模組(python3-gobject / IBus-1.0 typelib)。" >&2
exit 1
fi
# 2. Copy the program.
pkill -f "autozhuyin/autozhuyin_ibus.py" 2>/dev/null || true
rm -rf "$DEST"
mkdir -p "$DEST"
cp -R autozhuyin autozhuyin_ibus.py version.txt "$DEST/"
[ -f icon.png ] && cp icon.png "$DEST/"
[ -f THIRD_PARTY_LICENSES.txt ] && cp THIRD_PARTY_LICENSES.txt "$DEST/"
chmod +x "$DEST/autozhuyin_ibus.py"
# 3. Start with the desktop session: registers the engine with IBus and selects it.
mkdir -p "$AUTOSTART"
cat > "$AUTOSTART/autozhuyin.desktop" <<DESKTOP
[Desktop Entry]
Type=Application
Name=自動注音 AutoZhuyin
Comment=Registers the AutoZhuyin input method with IBus
Exec=$PY $DEST/autozhuyin_ibus.py --activate
Icon=$DEST/icon.png
X-GNOME-Autostart-enabled=true
X-KDE-autostart-phase=2
NoDisplay=true
DESKTOP
# 4. Start it now as well.
if pgrep -x ibus-daemon >/dev/null 2>&1; then
nohup "$PY" "$DEST/autozhuyin_ibus.py" --activate >/dev/null 2>&1 &
sleep 1
echo "已啟動並切換到自動注音。"
else
echo "IBus 目前沒有在執行,請照下面的步驟啟用 IBus 後登出再登入。"
fi
cat <<'MSG'
安裝完成。
- KDE(Bazzite / SteamOS 桌面模式):系統設定 → 鍵盤 → 虛擬鍵盤,選「IBus Wayland」,
按套用後登出再登入。之後每次登入都會自動切換到自動注音。
- 想暫時改回一般鍵盤:ibus engine xkb:us::eng ;切回自動注音:ibus engine autozhuyin
- 移除:執行 uninstall.sh
MSG
+14
View File
@@ -0,0 +1,14 @@
#!/bin/bash
# Removes AutoZhuyin (自動注音) for the current user. Your learned corrections and
# user phrases in ~/.config/autozhuyin are kept (delete that folder to remove them).
set -uo pipefail
DEST="${XDG_DATA_HOME:-$HOME/.local/share}/autozhuyin"
AUTOSTART="${XDG_CONFIG_HOME:-$HOME/.config}/autostart/autozhuyin.desktop"
if command -v ibus >/dev/null 2>&1 && [ "$(ibus engine 2>/dev/null)" = "autozhuyin" ]; then
ibus engine xkb:us::eng 2>/dev/null
fi
pkill -f "autozhuyin/autozhuyin_ibus.py" 2>/dev/null
rm -rf "$DEST" "$AUTOSTART"
echo "已移除自動注音。學習紀錄留在 ~/.config/autozhuyin,不需要可以自行刪除。"
+183
View File
@@ -0,0 +1,183 @@
"""Drives autozhuyin_ibus.AutoZhuyinEngine through a minimal stand-in for
gi.repository.IBus, to catch wrapper bugs without Linux. Run from the repo root:
python3 -m unittest discover -s linux/tests
"""
import os
import sys
import types
import unittest
LINUX = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
import tempfile # noqa: E402
os.environ["XDG_CONFIG_HOME"] = tempfile.mkdtemp(prefix="autozhuyin-test-") # learned / history files
sys.path.insert(0, os.path.join(os.path.dirname(LINUX), "windows")) # autozhuyin package
sys.path.insert(0, LINUX)
# --- stand-in for gi / IBus (only what the wrapper uses) ---
class Flag(int):
def __or__(self, o): return Flag(int(self) | int(o))
def __and__(self, o): return Flag(int(self) & int(o))
IBus = types.SimpleNamespace()
for i, name in enumerate(["BackSpace", "Return", "KP_Enter", "Escape", "Tab", "Up", "Down", "Left",
"Right", "space", "Shift_L", "Shift_R", "Delete"]):
setattr(IBus, "KEY_" + name, 0xff00 + i)
IBus.KEY_space = 0x20
IBus.ModifierType = types.SimpleNamespace(
SHIFT_MASK=Flag(1), LOCK_MASK=Flag(2), CONTROL_MASK=Flag(4), MOD1_MASK=Flag(8),
SUPER_MASK=Flag(1 << 26), MOD4_MASK=Flag(64), RELEASE_MASK=Flag(1 << 30))
IBus.keyval_to_unicode = lambda k: chr(k) if 0x20 <= k < 0x7f else "\x00"
class Text:
def __init__(self, s): self.text, self.attrs = s, None
@staticmethod
def new_from_string(s): return Text(s)
def set_attributes(self, a): self.attrs = a
class AttrList(list):
pass
class LookupTable:
def __init__(self): self.items, self.cursor = [], 0
@staticmethod
def new(*a): return LookupTable()
def set_orientation(self, o): pass
def clear(self): self.items = []
def append_candidate(self, t): self.items.append(t.text)
def set_cursor_pos(self, p): self.cursor = p
class Property:
def __init__(self, **kw): self.label = kw["label"].text
def set_label(self, t): self.label = t.text
def set_symbol(self, t): pass
class Engine:
def __init__(self, *a, **kw):
self.committed, self.preedit, self.cursor, self.shown = "", "", 0, None
self.preedit_attrs = None
def commit_text(self, t): self.committed += t.text
def update_preedit_text_with_mode(self, t, cursor, visible, mode):
self.preedit, self.cursor, self.preedit_attrs = t.text, cursor, t.attrs
def hide_preedit_text(self): self.preedit = ""
def update_lookup_table(self, table, visible): self.shown = list(table.items)
def hide_lookup_table(self): self.shown = None
def register_properties(self, p): pass
def update_property(self, p): self.mode_label = p.label
IBus.Text, IBus.AttrList, IBus.LookupTable, IBus.Property, IBus.Engine = Text, AttrList, LookupTable, Property, Engine
IBus.PropList = lambda: types.SimpleNamespace(append=lambda p: None)
IBus.attr_underline_new = lambda kind, a, b: ("underline", a, b)
IBus.attr_foreground_new = lambda color, a, b: ("color", a, b)
IBus.AttrUnderline = types.SimpleNamespace(SINGLE=1)
IBus.Orientation = types.SimpleNamespace(VERTICAL=1)
IBus.PropType = types.SimpleNamespace(NORMAL=0)
IBus.PropState = types.SimpleNamespace(UNCHECKED=0)
IBus.PreeditFocusMode = types.SimpleNamespace(COMMIT=1)
gi = types.ModuleType("gi")
gi.require_version = lambda *a: None
repo = types.ModuleType("gi.repository")
repo.IBus, repo.GLib, repo.GObject = IBus, types.SimpleNamespace(), types.SimpleNamespace()
gi.repository = repo
sys.modules["gi"], sys.modules["gi.repository"] = gi, repo
import autozhuyin_ibus # noqa: E402
M = IBus.ModifierType
def press(e, keys):
"""Types keys; returns the list of 'handled' results."""
names = {"\n": IBus.KEY_Return, "\b": IBus.KEY_BackSpace, "\t": IBus.KEY_Tab, "←": IBus.KEY_Left,
"→": IBus.KEY_Right, "↓": IBus.KEY_Down, " ": IBus.KEY_space}
out = []
for c in keys:
kv = names.get(c, ord(c))
out.append(e.do_process_key_event(kv, 0, Flag(0)))
e.do_process_key_event(kv, 0, M.RELEASE_MASK)
return out
class IBusEngineTests(unittest.TestCase):
def setUp(self):
autozhuyin_ibus.shared_classifier().history.clear()
autozhuyin_ibus.shared_classifier().learned.clear()
self.e = autozhuyin_ibus.AutoZhuyinEngine()
def test_mixed_sentence(self):
press(self.e, "ji3 hello world su3cl3 ")
self.assertEqual(self.e.committed, "我hello world 你好")
self.assertEqual(self.e.preedit, "")
def test_preedit_marks_english_blue(self):
press(self.e, "ji3hello")
self.assertEqual(self.e.preedit, "我hello")
self.assertIn(("color", 1, 6), self.e.preedit_attrs)
self.assertEqual(self.e.cursor, 6)
def test_space_passes_through_when_idle(self):
self.assertEqual(press(self.e, " "), [False])
def test_candidates_and_click(self):
press(self.e, "su3↓")
self.assertTrue(self.e.shown)
second = self.e.shown[1]
self.e.do_candidate_clicked(1, 1, 0)
self.assertIsNone(self.e.shown)
press(self.e, "\n")
self.assertEqual(self.e.committed, second)
def test_shift_tap_toggles_english(self):
self.e.do_process_key_event(IBus.KEY_Shift_L, 0, Flag(0))
self.e.do_process_key_event(IBus.KEY_Shift_L, 0, M.SHIFT_MASK | M.RELEASE_MASK)
self.assertEqual(self.e.mode_label, "英文")
self.assertEqual(press(self.e, "a"), [False]) # goes to the app as typed
def test_shift_as_modifier_is_not_a_tap(self):
self.e.do_process_key_event(IBus.KEY_Shift_L, 0, Flag(0))
self.e.do_process_key_event(ord("A"), 0, M.SHIFT_MASK)
self.e.do_process_key_event(IBus.KEY_Shift_L, 0, M.SHIFT_MASK | M.RELEASE_MASK)
self.assertFalse(self.e.engine.english_mode)
def test_ctrl_shortcut_commits_and_passes(self):
press(self.e, "su3")
self.assertFalse(self.e.do_process_key_event(ord("c"), 0, M.CONTROL_MASK))
self.assertEqual(self.e.committed, "你")
def test_backtick_symbol(self):
press(self.e, "`<")
self.assertEqual(self.e.committed, ",")
def test_insert_in_middle(self):
press(self.e, "rup fu4←wu0 \n")
self.assertEqual(self.e.committed, "今天氣")
def test_picked_candidate_saved(self):
press(self.e, "su3↓")
second = self.e.shown[1]
self.e.do_candidate_clicked(1, 1, 0)
press(self.e, "\n")
path = os.path.join(os.environ["XDG_CONFIG_HOME"], "autozhuyin", "user-history.json")
with open(path, encoding="utf-8") as f:
self.assertIn(second, f.read())
press(self.e, "su3 \n")
self.assertTrue(self.e.committed.endswith(second))
def test_focus_out_resets(self):
press(self.e, "su3")
self.e.do_focus_out()
self.assertEqual(self.e.engine.keys, [])
if __name__ == "__main__":
unittest.main()
+1
View File
@@ -19,6 +19,7 @@ mkdir -p "$APP/Contents/MacOS" "$APP/Contents/Resources"
cp "$BIN" "$APP/Contents/MacOS/AutoZhuyin"
cp Resources/Info.plist "$APP/Contents/Info.plist"
cp Resources/lexicon.txt Resources/english-common.txt Resources/classifier-weights.json "$APP/Contents/Resources/"
cp THIRD_PARTY_LICENSES.txt "$APP/Contents/Resources/"
# Precomputed English dictionary and bigram table (shared with the Windows build).
python3 -I windows/tools/build_data.py >/dev/null
cp windows/autozhuyin/data/english-dict.txt windows/autozhuyin/data/english-bigram.json "$APP/Contents/Resources/"
+31
View File
@@ -0,0 +1,31 @@
#!/bin/bash
# Builds build/AutoZhuyin-Linux-<version>.tar.gz: the IBus engine, the shared Python
# core and data, and install/uninstall scripts (per-user install, no root needed).
set -euo pipefail
cd "$(dirname "$0")/.."
VERSION="$(python3 -I -c 'import json,sys; print(json.load(open(sys.argv[1]))["version"])' windows/autozhuyin/ime.json)"
NAME="AutoZhuyin-Linux-$VERSION"
OUT="build/$NAME"
python3 -I windows/tools/build_data.py
(cd windows && python3 -m unittest discover -q tests)
python3 -m unittest discover -q -s linux/tests
if [ ! -f build/icon.tiff ]; then
DEVELOPER_DIR="${DEVELOPER_DIR:-/Applications/Xcode.app/Contents/Developer}" xcrun swift scripts/make-icon.swift build/icon.tiff
fi
rm -rf "$OUT" "$OUT.tar.gz"
mkdir -p "$OUT/autozhuyin"
rsync -a --exclude __pycache__ --exclude '*.pyc' \
windows/autozhuyin/__init__.py windows/autozhuyin/core windows/autozhuyin/data "$OUT/autozhuyin/"
cp linux/autozhuyin_ibus.py linux/installer/install.sh linux/installer/uninstall.sh linux/installer/README.txt \
THIRD_PARTY_LICENSES.txt "$OUT/"
echo "$VERSION" > "$OUT/version.txt"
sips -s format png -z 64 64 build/icon.tiff --out "$OUT/icon.png" >/dev/null
chmod +x "$OUT/install.sh" "$OUT/uninstall.sh" "$OUT/autozhuyin_ibus.py"
# Plain ustar without macOS extended attributes, so GNU tar doesn't warn.
(cd build && COPYFILE_DISABLE=1 tar --no-xattrs --format ustar -czf "$NAME.tar.gz" "$NAME")
echo "Built build/$NAME.tar.gz"
+3
View File
@@ -26,6 +26,9 @@ rsync -a --exclude __pycache__ --exclude '*.pyc' windows/autozhuyin "$OUT/"
for f in install.bat uninstall.bat README.txt; do
sed 's/$/\r/' "windows/installer/$f" > "$OUT/$f"
done
# Third-party notices: next to the installer and inside the installed folder.
sed 's/$/\r/' THIRD_PARTY_LICENSES.txt > "$OUT/THIRD_PARTY_LICENSES.txt"
cp "$OUT/THIRD_PARTY_LICENSES.txt" "$OUT/autozhuyin/"
(cd build && zip -qr -X "$NAME.zip" "$NAME")
echo "Built build/$NAME.zip"
+5 -3
View File
@@ -1,5 +1,5 @@
#!/bin/bash
# One-step release: bump the version, run all tests, build both installers, then
# One-step release: bump the version, run all tests, build all installers, then
# commit the version change and tag it.
#
# Usage: scripts/release.sh [patch|minor|major] [--push] (default: patch)
@@ -38,14 +38,16 @@ xcrun swift test -q 2>&1 | tail -3
echo "==> Packaging (runs the Python tests too)"
scripts/package.sh >/dev/null
scripts/package-windows.sh >/dev/null
scripts/package-linux.sh >/dev/null
trap - ERR
git add Resources/Info.plist windows/autozhuyin/ime.json
git commit -q -m "Release v$VERSION"
git tag -a "v$VERSION" -m "AutoZhuyin v$VERSION"
echo "==> Tagged v$VERSION"
ls -lh "build/AutoZhuyin-$VERSION.pkg" "build/AutoZhuyin-Windows-$VERSION.zip"
shasum -a 256 "build/AutoZhuyin-$VERSION.pkg" "build/AutoZhuyin-Windows-$VERSION.zip"
FILES=("build/AutoZhuyin-$VERSION.pkg" "build/AutoZhuyin-Windows-$VERSION.zip" "build/AutoZhuyin-Linux-$VERSION.tar.gz")
ls -lh "${FILES[@]}"
shasum -a 256 "${FILES[@]}"
if [ "$PUSH" = 1 ]; then
git push origin HEAD "v$VERSION"
@@ -0,0 +1 @@
{"ㄋㄧ": {"妳": [1, 1]}}
+23 -10
View File
@@ -11,6 +11,7 @@ import time
from keycodes import * # noqa: F401,F403 (VK_* constants, provided by PIME)
from textService import TextService
from .core.history import UserHistory
from .core.classifier import Classifier, LearnedPreferences
from .core.engine import BACKSPACE, DOWN, ENTER, ESCAPE, LEFT, RIGHT, SHIFT_TAP, TAB, UP, CompositionEngine
from .core.english import EnglishModel
@@ -22,19 +23,36 @@ _DATA = os.path.join(_HERE, "data")
_USER_DIR = os.path.join(os.environ.get("APPDATA", _HERE), "PIME", "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")
_classifier = None
def _save_learned(weights):
def _save_json(path, data):
try:
os.makedirs(_USER_DIR, exist_ok=True)
with open(_LEARNED_FILE, "w", encoding="utf-8") as f:
json.dump(weights, f, ensure_ascii=False)
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 PIME server process."""
global _classifier
@@ -48,14 +66,9 @@ def _shared_classifier():
os.path.join(_DATA, "english-dict.txt"),
os.path.join(_DATA, "english-bigram.json"),
)
weights = {}
try:
with open(_LEARNED_FILE, encoding="utf-8") as f:
weights = json.load(f)
except (OSError, ValueError):
pass
trained = Classifier.load_weights(os.path.join(_DATA, "classifier-weights.json"))
_classifier = Classifier(lexicon, english, LearnedPreferences(weights, _save_learned), trained)
_classifier = Classifier(lexicon, english, LearnedPreferences(_load_json(_LEARNED_FILE), _save_learned),
trained, UserHistory(_load_json(_HISTORY_FILE), _save_history))
return _classifier
+3 -1
View File
@@ -1,6 +1,7 @@
"""Zhuyin-vs-literal classifier with learned corrections. Port of Classifier.swift."""
import json
from .history import UserHistory
from .features import DEFAULT_WEIGHTS, dot, literal_features, zhuyin_features
ZHUYIN = "zhuyin"
@@ -31,10 +32,11 @@ class LearnedPreferences:
class Classifier:
def __init__(self, lexicon, english, learned=None, weights=None):
def __init__(self, lexicon, english, learned=None, weights=None, history=None):
self.lexicon = lexicon
self.english = english
self.learned = learned or LearnedPreferences()
self.history = history or UserHistory() # picked candidates (shared by all engines)
self.weights = dict(DEFAULT_WEIGHTS)
if weights:
self.weights.update(weights)
+233 -42
View File
@@ -8,6 +8,7 @@ import time
from . import bopomofo
from .classifier import LITERAL, ZHUYIN
from .features import dot
from .lexicon import Converter
BACKSPACE, ENTER, ESCAPE, TAB = "<backspace>", "<enter>", "<escape>", "<tab>"
@@ -20,8 +21,10 @@ FULLWIDTH = {
"{": "『", "}": "』", "[": "「", "]": "」", "~": "~", "_": "——",
}
# An English word that is also a common one-syllable Chinese reading ("up " = ㄧㄣ 因)
# is not committed on space; the next word decides ("up jo4" = 因為, "up the" = up the).
# The first word of a composition that also reads as Zhuyin is not committed as English
# on space; the next word decides ("up jo4" = 因為, "up the" = up the, "no su3" = no 你).
# Right after English text only common one-syllable readings are held (up = 因, url = 教),
# so normal English typing is not delayed.
HOLD_MIN_SCORE = -3.5
# "`" then one of these keys always gives the full-width symbol, whatever the context.
@@ -43,7 +46,7 @@ class CompositionEngine:
def __init__(self, classifier, now=time.monotonic):
self.classifier = classifier
self.converter = Converter(classifier.lexicon)
self.converter = Converter(classifier.lexicon, classifier.history)
self.now = now
self.keys = []
self.forced_mode = None
@@ -55,8 +58,11 @@ class CompositionEngine:
self.candidates = []
self.candidate_index = 0
self._candidate_segment_start = 0
# Composition cursor for choosing candidates: index into _cursor_stops(), None = end.
# Composition cursor: a key index into self.keys (None = at the end). ← → move it
# between syllables; ↓ opens candidates for the phrase before it; typing there
# inserts a syllable (kept in self.inserting until its tone key, then spliced in).
self.cursor = None
self.inserting = []
# Index of a held space (see HOLD_MIN_SCORE), or None.
self.held = None
self._previous_mode = None
@@ -91,19 +97,39 @@ class CompositionEngine:
rest = keys[held + 1:]
base = held + 1
rest_segs = [(a + base, b + base, m) for a, b, m in self.classifier.segment(rest, finishing, None)]
if rest_segs and rest_segs[0][2] == ZHUYIN:
if rest_segs and rest_segs[0][2] == ZHUYIN and self._held_reads_as_chinese(keys, held, rest_segs[0][1], finishing):
return [(0, rest_segs[0][1], ZHUYIN)] + rest_segs[1:]
return [(0, base, LITERAL)] + rest_segs
def _held_reads_as_chinese(self, keys, held, end, finishing):
"""Chinese all the way to `end` vs. the held English word followed by Chinese."""
c, w, ctx = self.classifier, self.classifier.weights, self.context
is_last = end == len(keys)
zh_whole = c.segment_features(keys[:end], is_last, False, finishing, ctx)[0]
word = c.segment_features(keys[:held], False, False, True, ctx)[1]
zh_rest = c.segment_features(keys[held + 1:end], is_last, True, finishing, None)[0]
if zh_whole is None:
return False
if word is None or zh_rest is None:
return True
return dot(w, zh_whole) >= dot(w, word) + dot(w, zh_rest)
def _is_ambiguous_word(self, keys):
"""Whether keys + space also read as a common Chinese syllable (see HOLD_MIN_SCORE)."""
if not all(k.isascii() and k.isalpha() for k in keys):
return False
p = bopomofo.parse(list(keys) + [" "])
if p.pending is not None or len(p.syllables) != 1:
if p.pending is not None or not p.syllables or p.stray_tones or p.foreign_keys:
return False
entries = self.classifier.lexicon.entries([s.syllable for s in p.syllables])
return bool(entries) and entries[0][1] >= HOLD_MIN_SCORE
best = []
for ps in p.syllables:
entries = self.classifier.lexicon.entries([ps.syllable])
if not entries:
return False
best.append(entries[0][1])
if self.context != LITERAL:
return True # first word: hold anything that reads as Zhuyin
return len(best) == 1 and best[0] >= HOLD_MIN_SCORE
@property
def segments(self):
@@ -144,48 +170,180 @@ class CompositionEngine:
# --- cursor ---
def _cursor_stops(self):
"""[(segment index, syllables before the stop)] for every Zhuyin syllable."""
segs = self.segments
out = []
for i, seg in enumerate(segs):
def _syllable_ends(self, seg):
"""Absolute key index after each syllable of a Zhuyin segment."""
return [seg[0] + ps.end for ps in bopomofo.parse(self.keys[seg[0]:seg[1]]).syllables]
def _cursor_positions(self):
"""Key indices the cursor can stop at: the start, after every Zhuyin syllable,
and at every segment boundary."""
out = {0, len(self.keys)}
for seg in self.segments:
out.add(seg[1])
if seg[2] == ZHUYIN:
out.update(self._syllable_ends(seg))
return sorted(out)
def _stop_at(self, pos):
"""(segment index, syllables before pos) for the Zhuyin segment pos is in."""
segs = self.segments
for i, seg in enumerate(segs):
if seg[2] == ZHUYIN and seg[0] < pos <= seg[1]:
n = len(self._convertible(seg, i < len(segs) - 1)[0])
out.extend((i, k) for k in range(1, n + 1))
return out
local = sum(1 for e in self._syllable_ends(seg) if e <= pos)
return (i, min(local, n)) if local else None
return None
def _candidate_stop(self):
"""Where ↓ opens candidates: before the cursor, or the last syllable."""
if self.cursor is not None:
return self._stop_at(self.cursor)
segs = self.segments
for i in range(len(segs) - 1, -1, -1):
if segs[i][2] == ZHUYIN:
n = len(self._convertible(segs[i], i < len(segs) - 1)[0])
if n:
return i, n
return None
def _base_cursor_offset(self):
"""Cursor position in the rendered segments (without the syllable being inserted)."""
pieces = self._segment_pieces()
if self.cursor is None:
return sum(len(t) for t, _ in pieces)
segs = self.segments
for i, seg in enumerate(segs):
if not seg[0] < self.cursor <= seg[1]:
continue
offset = sum(len(t) for t, _ in pieces[:i])
if seg[2] == LITERAL:
return offset + self.cursor - seg[0]
stop = self._stop_at(self.cursor)
local = stop[1] if stop else 0
for (a, b), text in self._conversion(seg, i < len(segs) - 1)[0]:
if b <= local:
offset += len(text)
elif a < local:
offset += min(local - a, len(text))
return offset
return 0
@property
def cursor_offset(self):
"""Cursor position in marked_text (characters)."""
pieces = self.marked_pieces
stops = self._cursor_stops()
if self.cursor is None or not 0 <= self.cursor < len(stops):
return sum(len(t) for t, _ in pieces)
seg_index, local = stops[self.cursor]
offset = sum(len(t) for t, _ in pieces[:seg_index])
segs = self.segments
for (a, b), text in self._conversion(segs[seg_index], seg_index < len(segs) - 1)[0]:
if b <= local:
offset += len(text)
elif a < local:
offset += min(local - a, len(text))
return offset
return self._base_cursor_offset() + len(self._inserting_text())
def _move_cursor(self, delta):
stops = self._cursor_stops()
if not stops:
return
nxt = (len(stops) - 1 if self.cursor is None else self.cursor) + delta
self.cursor = None if nxt >= len(stops) - 1 else max(0, nxt)
self.inserting = []
stops = self._cursor_positions()
here = len(self.keys) if self.cursor is None else self.cursor
if delta < 0:
before = [p for p in stops if p < here]
nxt = before[-1] if before else here
else:
after = [p for p in stops if p > here]
nxt = after[0] if after else here
self.cursor = None if nxt >= len(self.keys) else nxt
def _inserting_text(self):
if not self.inserting:
return ""
return "".join(ps.syllable.reading for ps in bopomofo.parse(self.inserting).syllables)
# --- editing in the middle ---
def _trim_fixed(self, pos):
"""Keeps picked phrases that end at or before key index pos (they don't move)."""
kept = {}
for seg in self.segments:
picks = self.fixed.get(seg[0])
if not picks or seg[2] != ZHUYIN:
continue
if seg[1] <= pos:
kept[seg[0]] = picks
elif seg[0] < pos:
ends = self._syllable_ends(seg)
here = {r: t for r, t in picks.items() if r[1] <= len(ends) and ends[r[1] - 1] <= pos}
if here:
kept[seg[0]] = here
self.fixed = kept
def _splice(self, new_keys):
"""Inserts keys at the cursor and moves the cursor after them."""
pos = self.cursor
self._trim_fixed(pos)
self.keys[pos:pos] = new_keys
if self.held is not None and self.held >= pos:
self.held += len(new_keys)
self.cursor = pos + len(new_keys)
if self.cursor >= len(self.keys):
self.cursor = None
def _delete_before_cursor(self):
"""Backspace in the middle: removes the syllable (or literal key) before the cursor."""
pos = self.cursor
start = pos - 1
for seg in self.segments:
if seg[2] == ZHUYIN and seg[0] < pos <= seg[1]:
for ps in bopomofo.parse(self.keys[seg[0]:seg[1]]).syllables:
if seg[0] + ps.end == pos:
start = seg[0] + ps.start
self._trim_fixed(start)
del self.keys[start:pos]
if self.held is not None:
if start <= self.held < pos:
self.held = None
elif self.held >= pos:
self.held -= pos - start
self.cursor = start
if not self.keys:
self.reset()
def _insert_key(self, c):
"""Typing with the cursor in the middle: compose one syllable, splice it in on its tone."""
if c == " ":
if not self.inserting:
return True, self._commit()
self._splice(self.inserting + [" "])
self.inserting = []
return CONSUMED
self.inserting.append(c)
p = bopomofo.parse(self.inserting)
if p.stray_tones or p.foreign_keys:
self.inserting.pop() # a tone with nothing to attach to
return CONSUMED
if p.syllables and p.syllables[-1].toned and len(p.syllables) == 1:
self._splice(self.inserting)
self.inserting = []
elif len(p.syllables) > 1:
# A new syllable started without a tone: splice the first one as it is.
first = p.syllables[0].end
self._splice(self.inserting[:first])
self.inserting = self.inserting[first:]
return CONSUMED
@property
def marked_pieces(self):
segs = self.segments
pieces = [(self._render(s, i < len(segs) - 1), s[2]) for i, s in enumerate(segs)]
pieces = self._segment_pieces()
if self.inserting:
# Show the syllable being inserted at the cursor.
at, out, done = self._base_cursor_offset(), [], False
for text, mode in pieces:
if not done and at <= len(text):
out += [(text[:at], mode), (self._inserting_text(), ZHUYIN), (text[at:], mode)]
done = True
else:
out.append((text, mode))
at -= len(text)
pieces = [(t, m) for t, m in out if t]
if self.backtick:
pieces.append((BACKTICK, LITERAL))
return pieces
def _segment_pieces(self):
segs = self.segments
return [(self._render(s, i < len(segs) - 1), s[2]) for i, s in enumerate(segs)]
@property
def marked_text(self):
return "".join(t for t, _ in self.marked_pieces)
@@ -198,12 +356,14 @@ class CompositionEngine:
def wants(self, key):
"""Whether handle(key) would consume the key, without changing state."""
if self.candidates or key == SHIFT_TAP or self.backtick:
if self.candidates or key == SHIFT_TAP or self.backtick or self.inserting:
return True
if self.english_mode and not self.keys:
return False # English mode: everything goes to the app as typed
if key in SPECIAL_KEYS:
return bool(self.keys)
if key == BACKTICK:
return True
if self.keys:
return True
if key == " ":
@@ -217,10 +377,19 @@ class CompositionEngine:
return self._handle_candidate_key(key)
if self.backtick:
return self._after_backtick(key)
if self.inserting and key in (BACKSPACE, ESCAPE):
if key == BACKSPACE:
self.inserting.pop()
else:
self.inserting = []
return CONSUMED
if key == BACKSPACE:
if not self.keys:
return PASS
self.cursor = None
if self.cursor is not None:
if self.cursor > 0:
self._delete_before_cursor()
return CONSUMED
self.keys.pop()
if self.held is not None and len(self.keys) <= self.held:
self.held = None
@@ -232,6 +401,9 @@ class CompositionEngine:
if key == ENTER:
if not self.keys:
return PASS
if self.inserting:
self._splice(self.inserting)
self.inserting = []
return True, self._commit()
if key == ESCAPE:
if not self.keys:
@@ -255,7 +427,8 @@ class CompositionEngine:
if key == DOWN:
if not self.keys:
return PASS
self._open_candidates()
if not self.inserting:
self._open_candidates()
return CONSUMED
if key in (LEFT, RIGHT):
if not self.keys:
@@ -286,7 +459,12 @@ class CompositionEngine:
return bopomofo.parse(self.keys[start:end])
def _handle_character(self, c):
self.cursor = None # typing always continues at the end
if self.cursor is not None and self.keys and (c == " " or bopomofo.is_zhuyin_key(c)):
return self._insert_key(c)
if self.inserting:
self._splice(self.inserting)
self.inserting = []
self.cursor = None # anything else continues at the end
if self.english_mode and not self.keys:
return PASS # English mode: every key goes to the app as typed
if c == BACKTICK:
@@ -330,10 +508,10 @@ class CompositionEngine:
def _open_candidates(self):
"""Candidates for the phrase ending at the cursor (default: the last syllable)."""
stops = self._cursor_stops()
if not stops:
stop = self._candidate_stop()
if stop is None:
return
seg_index, local = stops[min(len(stops) - 1 if self.cursor is None else self.cursor, len(stops) - 1)]
seg_index, local = stop
segs = self.segments
seg = segs[seg_index]
syl = self._convertible(seg, seg_index < len(segs) - 1)[0]
@@ -374,6 +552,7 @@ class CompositionEngine:
def _commit(self, segs=None):
segs = segs if segs is not None else self.segments
text = "".join(self._render(s, True) for s in segs)
self._remember_picks(segs)
if self.forced_mode:
self.classifier.learned.record("".join(self.keys), self.forced_mode)
self._previous_mode = segs[-1][2] if segs else None
@@ -381,11 +560,23 @@ class CompositionEngine:
self.reset()
return text
def _remember_picks(self, segs):
"""Candidates the user picked are remembered and come first next time."""
for i, seg in enumerate(segs):
picks = self.fixed.get(seg[0])
if seg[2] != ZHUYIN or not picks:
continue
syl = self._convertible(seg, True)[0]
for (a, b), text in picks.items():
if b <= len(syl):
self.classifier.history.record(syl[a:b], text)
def commit_all(self):
return self._commit() if self.keys else ""
def reset(self):
self.keys = []
self.inserting = []
self.held = None
self.backtick = False
self.cursor = None
+65
View File
@@ -0,0 +1,65 @@
"""Remembers the candidates the user picked. Port of UserHistory.swift.
Keys are toneless readings ("ㄊㄧㄢ", "ㄐㄧㄣ-ㄊㄧㄢ"); a picked phrase is boosted only
where the lexicon has it for the reading being converted, so a toneless key is safe.
"""
class UserHistory:
max_entries = 2000 # (reading, phrase) pairs kept; the least recently used go first
max_count = 10
def __init__(self, data=None, on_change=None):
# reading -> {phrase: [count, last use]}
self.data = {}
self.on_change = on_change or (lambda data: None)
self._clock = 0
for reading, phrases in (data or {}).items():
if not isinstance(phrases, dict):
continue
for phrase, value in phrases.items():
try:
count, used = int(value[0]), int(value[1])
except (TypeError, ValueError, IndexError):
continue
self.data.setdefault(reading, {})[phrase] = [count, used]
self._clock = max(self._clock, used)
@staticmethod
def key(syllables):
return "-".join(s.toneless for s in syllables)
def record(self, syllables, phrase):
if not syllables or not phrase:
return
self._clock += 1
entry = self.data.setdefault(self.key(syllables), {}).setdefault(phrase, [0, 0])
entry[0] = min(self.max_count, entry[0] + 1)
entry[1] = self._clock
self._evict()
self.on_change(self.data)
def _evict(self):
pairs = [(v[1], r, p) for r, ps in self.data.items() for p, v in ps.items()]
if len(pairs) <= self.max_entries:
return
pairs.sort()
for _, r, p in pairs[:len(pairs) - self.max_entries]:
del self.data[r][p]
if not self.data[r]:
del self.data[r]
def clear(self):
self.data = {}
self.on_change(self.data)
def adjust(self, syllables, entries):
"""Lexicon entries [(phrase, score)] with picked phrases moved to the top: just above
the best entry, more so the more often they were picked. Returns a new list."""
picked = self.data.get(self.key(syllables))
if not picked or not entries:
return entries
top = entries[0][1]
out = [(p, max(s, top + 0.01 + 0.1 * picked[p][0]) if p in picked else s) for p, s in entries]
out.sort(key=lambda e: -e[1])
return out
+8 -3
View File
@@ -84,8 +84,13 @@ TONELESS_PENALTY = -1.5
class Converter:
def __init__(self, lexicon):
def __init__(self, lexicon, history=None):
self.lexicon = lexicon
self.history = history # UserHistory: picked candidates come first
def _entries(self, syllables):
entries = self.lexicon.entries(syllables)
return self.history.adjust(syllables, entries) if self.history else entries
def _options(self, syllables, i, j, fixed):
if (i, j) in fixed:
@@ -94,7 +99,7 @@ class Converter:
return []
sl = syllables[i:j]
penalty = TONELESS_PENALTY if any(s.tone is None for s in sl) else 0.0
out = [(p, s + penalty) for p, s in self.lexicon.entries(sl)]
out = [(p, s + penalty) for p, s in self._entries(sl)]
if not out and j - i == 1:
out = [(sl[0].reading, UNKNOWN_SCORE)]
return out
@@ -132,7 +137,7 @@ class Converter:
out, seen = [], set()
for length in range(min(self.lexicon.max_phrase_length, end), 0, -1):
i = end - length
for phrase, _ in self.lexicon.entries(syllables[i:end]):
for phrase, _ in self._entries(syllables[i:end]):
if phrase not in seen:
seen.add(phrase)
out.append(((i, end), phrase))
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "自動注音 AutoZhuyin",
"version": "0.7.0",
"version": "0.10.0",
"guid": "{3895C6E3-6D40-4B4B-B4EA-CEEC75382D23}",
"locale": "zh-Hant-TW",
"fallbackLocale": "zh-TW",
+4 -2
View File
@@ -26,8 +26,10 @@
空白 注音:一聲;音節打完時送出中文。英文:送出單字加空白
Enter 送出目前組字
Tab 判斷錯了?按 Tab 在中/英之間翻轉,輸入法會記住這次修正
← → 在組字區移動游標,選要改哪個字
↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字
← → 在組字區移動游標,選要改哪個字;游標在中間時直接打注音
會插入新字,Backspace 刪掉游標前的字
↓ 開啟游標前那個字或詞的候選字,按數字鍵 1–9 選字;
選過的字會被記住,下次優先出現
Esc 取消組字
單按 Shift 切換英文模式(按鍵直接送出、保持小寫、沒有底線),
再單按一次回到中英自動判斷,會出現「英文」/「中英自動」小提示;
+105 -7
View File
@@ -15,6 +15,7 @@ from autozhuyin.core.engine import DOWN, ENTER, LEFT, RIGHT, SHIFT_TAP, TAB, BAC
from autozhuyin.core.shift_tap import ShiftTapDetector # noqa: E402
from autozhuyin.core.english import EnglishModel # noqa: E402
from autozhuyin.core.lexicon import Converter, Lexicon # noqa: E402
from autozhuyin.core.history import UserHistory # noqa: E402
DATA = os.path.join(os.path.dirname(HERE), "autozhuyin", "data")
_start = time.time()
@@ -42,7 +43,7 @@ def make_engine():
def type_keys(s, e):
out = ""
for c in s:
key = {"\n": ENTER, "\t": TAB, "⇧": SHIFT_TAP, "←": LEFT, "→": RIGHT, "↓": DOWN}.get(c, c)
key = {"\n": ENTER, "\t": TAB, "⇧": SHIFT_TAP, "←": LEFT, "→": RIGHT, "↓": DOWN, "\b": BACKSPACE}.get(c, c)
handled, commit = e.handle(key)
if commit is not None:
out += commit
@@ -246,7 +247,7 @@ class CursorTests(unittest.TestCase):
type_keys("←", e)
self.assertEqual(e.cursor_offset, 3)
type_keys("←←←←", e)
self.assertEqual(e.cursor_offset, 1)
self.assertEqual(e.cursor_offset, 0)
type_keys("→→→→", e)
self.assertEqual(e.cursor_offset, 4)
@@ -258,12 +259,45 @@ class CursorTests(unittest.TestCase):
e.select_candidate([t for _, t in e.candidates].index("添"))
self.assertEqual(type_keys("\n", e), "今添天氣")
def test_typing_returns_cursor_to_end(self):
def test_english_returns_cursor_to_end(self):
e = make_engine()
type_keys("rup wu0 ←", e)
self.assertEqual(e.cursor_offset, 1)
type_keys("wu0 ", e)
self.assertEqual(e.cursor_offset, len(e.marked_text))
type_keys("?", e)
self.assertEqual(e.marked_text, "")
class InsertInMiddleTests(unittest.TestCase):
def test_insert_syllable(self):
e = make_engine()
type_keys("rup fu4←wu", e)
self.assertEqual(e.marked_text, "今ㄊㄧ氣")
self.assertEqual(e.cursor_offset, 3)
type_keys("0 ", e)
self.assertEqual(e.marked_text, "今天氣")
self.assertEqual(e.cursor_offset, 2)
self.assertEqual(type_keys("\n", e), "今天氣")
def test_insert_at_start(self):
self.assertEqual(type_keys("su3cl3←←ji3\n", make_engine()), "我你好")
def test_backspace_deletes_character_before_cursor(self):
e = make_engine()
type_keys("rup wu0 wu0 fu4←←\b", e)
self.assertEqual(e.marked_text, "今天氣")
self.assertEqual(e.cursor_offset, 1)
def test_backspace_inside_inserted_syllable(self):
e = make_engine()
type_keys("rup fu4←wu\b", e)
self.assertEqual(e.marked_text, "今ㄊ氣")
def test_keeps_picked_phrase_before_cursor(self):
e = make_engine()
type_keys("rup wu0 ↓", e)
e.select_candidate([t for _, t in e.candidates].index("添"))
type_keys("fu4←wu0 ", e) # insert 天 between 添 and 氣
self.assertEqual(e.marked_text[:3], "今添天")
def test_candidates_for_chinese_before_english(self):
e = make_engine()
@@ -275,8 +309,10 @@ class FirstToneAfterEnglishTests(unittest.TestCase):
def test_first_tone_after_english(self):
for keys in ["ru", "t", "gj", "vup", "tj", "el"]:
e = make_engine()
self.assertEqual(type_keys("hello " + keys + " ", e), "hello ", keys)
self.assertEqual(len(e.marked_text), 1, keys)
out = type_keys("hello " + keys + " \n", e)
self.assertEqual(out[:6], "hello ", keys)
self.assertEqual(len(out), 7, keys) # one Chinese character after it
self.assertFalse(out[6].isascii(), keys)
class HeldWordTests(unittest.TestCase):
@@ -315,5 +351,67 @@ class BacktickSymbolTests(unittest.TestCase):
self.assertEqual(e.marked_text, "你")
class FirstWordHoldTests(unittest.TestCase):
"""The first word is not committed as English on space if it also reads as Zhuyin."""
def test_next_word_decides(self):
cases = {"el ji3 ": "高我", "no su3cl3 ": "no 你好", "ok ji3 ": "ok 我",
"i love you ": "i love you ", "up the ": "up the "}
for keys, want in cases.items():
self.assertEqual(type_keys(keys, make_engine()), want, keys)
def test_not_held_after_english(self):
e = make_engine()
self.assertEqual(type_keys("hello world ", e), "hello world ")
self.assertEqual(type_keys("so ", e), "so ") # right after English: commits at once
class UserHistoryTests(unittest.TestCase):
def setUp(self):
self.saved = []
self.c = Classifier(LEX, ENG, weights=WEIGHTS, history=UserHistory(on_change=self.saved.append))
def pick(self, keys, phrase):
e = CompositionEngine(self.c)
type_keys(keys + "↓", e)
e.select_candidate([t for _, t in e.candidates].index(phrase))
return type_keys("\n", e)
def test_picked_candidate_comes_first(self):
self.assertEqual(type_keys("wu0 \n", CompositionEngine(self.c)), "天")
self.assertEqual(self.pick("wu0 ", "添"), "添")
self.assertEqual(type_keys("wu0 \n", CompositionEngine(self.c)), "添")
e = CompositionEngine(self.c)
type_keys("wu0 ↓", e)
self.assertEqual(e.candidates[0][1], "添")
self.assertEqual(self.saved[-1], {"ㄊㄧㄢ": {"添": [1, 1]}})
def test_phrases_still_win(self):
self.pick("wu0 ", "添")
self.assertEqual(type_keys("rup wu0 \n", CompositionEngine(self.c)), "今天")
def test_most_picked_wins(self):
self.pick("wu0 ", "添")
self.pick("wu0 ", "添")
self.pick("wu0 ", "天")
self.assertEqual(type_keys("wu0 \n", CompositionEngine(self.c)), "添")
def test_round_trip_and_clear(self):
self.pick("wu0 ", "添")
h = UserHistory(self.saved[-1])
self.assertEqual(h.data, {"ㄊㄧㄢ": {"添": [1, 1]}})
h.record([bopomofo.parse(list("wu0 ")).syllables[0].syllable], "天")
self.assertEqual(h.data["ㄊㄧㄢ"]["天"], [1, 2])
h.clear()
self.assertEqual(h.data, {})
def test_evicts_least_recent(self):
h = UserHistory()
h.max_entries = 2
syl = [bopomofo.parse(list("wu0 ")).syllables[0].syllable]
for p in ["天", "添", "田"]:
h.record(syl, p)
self.assertEqual(set(h.data["ㄊㄧㄢ"]), {"添", "田"})
if __name__ == "__main__":
unittest.main()
+12 -1
View File
@@ -6,6 +6,9 @@ import types
import unittest
HERE = os.path.dirname(os.path.abspath(__file__))
import tempfile # noqa: E402
os.environ["APPDATA"] = tempfile.mkdtemp(prefix="autozhuyin-test-") # learned / history files
sys.path.insert(0, os.path.dirname(HERE))
# --- stand-ins for PIME modules (only what the wrapper uses) ---
@@ -46,7 +49,7 @@ class FakeTextService:
textService.TextService = FakeTextService
sys.modules["textService"] = textService
from autozhuyin.autozhuyin_ime import AutoZhuyinTextService # noqa: E402
from autozhuyin.autozhuyin_ime import AutoZhuyinTextService, _shared_classifier # noqa: E402
VK = {"\n": 0x0D, "\t": 0x09, " ": 0x20, "\b": 0x08, "↓": 0x28}
@@ -99,12 +102,18 @@ def type_text(svc, text):
class WrapperTests(unittest.TestCase):
def setUp(self):
_shared_classifier().history.clear()
_shared_classifier().learned.clear()
self.svc = AutoZhuyinTextService(client=None)
self.svc.onActivate()
def test_mixed_sentence(self):
self.assertEqual(type_text(self.svc, "ji3 hello world su3cl3 "), "我hello world 你好")
def test_backtick_symbol(self):
self.assertEqual(type_text(self.svc, "`<"), ",")
self.assertEqual(type_text(self.svc, "ji3`."), "我。")
def test_composition_shown(self):
type_text(self.svc, "su3c")
self.assertEqual(self.svc.reply["compositionString"], "你ㄏ")
@@ -138,6 +147,8 @@ class WrapperTests(unittest.TestCase):
class ShiftTapWrapperTests(unittest.TestCase):
def setUp(self):
_shared_classifier().history.clear()
_shared_classifier().learned.clear()
self.svc = AutoZhuyinTextService(client=None)
self.svc.onActivate()