Pick suggestion from multiple dictionaries

[user202729]

For a beginner, a common problem (especially for Plover theory users / at least for me) is not knowing how to stroke a word.

So I have the idea to use some pattern-matching (perhaps use the existing rule set of Spectra Lexer) to guess what word the user want to write, and show them (plus the Plover theory's canonical stroke + some diff against user's guess) in some kind of suggestion window.

This will be left for later. For now, since I happen to have a bunch of dictionaries of different theories, I made a small script to display all the lookup result of different dictionaries in a window.

How useful is it?

I can't judge this too well, but it might not be that good because usually there are only the "shortest" or "most correct according to the theory".

The script

from typing import Dict, List, Optional
from pathlib import Path
import json
from collections import defaultdict

dictionaries_folder=Path(
??? # ............
		)

from plover_textarea.extension import get_instance

dictionaries={a.stem: json.loads(a.read_text())
	for a in dictionaries_folder.glob("*.json")
	}

window_name=":multidict_suggestion"
get_instance().write(window_name, "")

LONGEST_KEY=10 #for example. Should be sufficient

last_print: Optional[str]=None

def lookup(strokes: List[str])->None:
	global last_print
	outline="/".join(strokes)
	if last_print==outline: return

	translations=defaultdict(list)
	for path, dictionary in dictionaries.items():
		if outline in dictionary:
			translations[dictionary[outline]].append(path)

	if translations:
		last_print=outline
		for translation, paths in translations.items():
			get_instance().write(window_name,
					f"{translation!r:30} -> {paths}\n"
					)
		get_instance().write(window_name, "============\n\n")
	return

Install plover-python-dictionary and plover-textarea plugin, then add this file as a Python dictionary.

Should be an extension plugin instead, but this is easier.

Currently plover-textarea doesn't support all the strokes. You can still run Plover in a console and replace get_instance().write(window_name, with print to print on Plover's console. (if Plover runs in console, that is. I think it requires running from source?)

[user202729]

I've mostly done understanding how Spectra Lexer works.

Making a program to find possible matching words for an outline is probably not that hard.

As far as I can see Spectra Lexer doesn't support this.

• The list of rules is in rules.cson format.

• For experimenting, there are two ways

  1. In a normal Python console, type

     import spectra_lexer
     s=spectra_lexer.Spectra()

     then the variables can be accessed as s.analyzer, s.rules, etc.

  2. Run spectra_lexer console (see spectra_lexer --help for more commands. See also https://github.com/fourshade/spectra_lexer#operation )

     The variables can be accessed as analyzer, rules, etc.

• The program will parse the CoffeeScript Object Notation file and the resulting list of rules
  is in rules variable.

• Main interface: analyzer.query (StenoAnalyzer.query). Example analyzer.query("TPR", "from")

• Call chain:

     StenoAnalyzer.query
  => StenoLexer.query
  => StenoLexer._process
  => IRuleMatcher.match (virtual function)
  => PriorityRuleMatcher.match (subclass)
  => (call *Matcher.match)
  

• PriorityRuleMatcher delegates to, in order:

  (
  [DelimiterMatcher],
  [UnorderedPrefixMatcher, StrokeMatcher, WordMatcher],
  [SpecialMatcher]
  )
  

• See https://github.com/fourshade/spectra_lexer/blob/df434669a660dfbe84789d59abf55dddc4c440aa/spectra_lexer/spectra.py#L128-L170 for rules format.

• The most important matcher is prefix_matcher (UnorderedPrefixMatcher, internally uses PrefixMatcher).

  This one (most of the time) matches exactly rule.letters to an infix of the letters left,
  some letters might be dropped but they must be in order.

  So all possible inversions must be explicitly listed in the rules.

  For example TKHREUPLT -> delimit is still a complete match even though some letters are dropped.

  The match is greedy in stroke, that is, the leftmost stroke is attempted to match first
  (for example TKHREURPLT -> delimiter (not in Plover theory), -R -> er is matched
  but -PLT -> mit is not)

• Internal implementation details:

  • RTF/CRE stroke format is the usual one.
  • s-keys stroke format looks like this S/Kbg/K*bg (uppercase for left side, lowercase for right side, no hyphen) to simplify stroke matching.

[user202729]

So I wrote a script to do the task mentioned above...

As a side effect, it can also find suspicious strokes in a dictionary.

Even though I used Di's dictionary (which have much less misstrokes), there are still many.

[user202729]

Published at repository .

So for example, if you write KOPL PUL SO REU, it will suggest...

>>> compulsory : KOPL/PULS/REU | KPULS/REU | KOPL/PULS/SOEUR | KOFRP/UL/SOEUR | KOFRP/ULS/REU | KOPL/PUL/SOEUR

Or, KEU TPHES THET EUBG =>

>>> kinesthetic : KEUPB/ES/THET/EUBG | KEUPBS/THE/TEUBG | KEUPBS/THET/EUBG | KEUPB/STET/EUBG | KEUPB/STHES/EUBG

There are some known issues (see the repository's issues list)

Of course this is only useful if you're not very familiar with the Plover theory.

The best way would be to generate a dictionary programmatically (I know there has been several attempts)