plover.engine – Steno engine

The steno engine is the core of Plover; it handles communication between the machine and the translation and formatting subsystems, and manages configuration and dictionaries.

class plover.engine.StenoEngine(config, controller, keyboard_emulation)
config: Dict[str, any]

A dictionary containing configuration options.

controller: plover.oslayer.controller.Controller

An instance of Controller for managing commands sent to this Plover instance. This is provided during startup.

keyboard_emulation: plover.oslayer.keyboardcontrol.KeyboardEmulation

An instance of KeyboardEmulation provided during startup.

HOOKS: List[str]

A list of all the possible engine hooks. See Engine Hooks below for a list of valid hooks.

machine_state: str

The connection state of the current machine. One of stopped, initializing, connected or disconnected.

output: bool

True if steno output is enabled, False otherwise.

config: plover.config.Config

A Config object containing the engine’s configuration.

translator_state: plover.translation._State

A _State object containing the current state of the translator.

starting_stroke_state: StartingStrokeState

A StartingStrokeState representing the initial state of the formatter.

dictionaries: plover.steno_dictionary.StenoDictionaryCollection

A StenoDictionaryCollection of all the dictionaries Plover has loaded for the current system. This includes disabled dictionaries and dictionaries that failed to load.

_in_engine_thread() bool

Returns whether we are currently in the same thread that the engine is running on. This is useful because event listeners for machines and others are run on separate threads, and we want to be able to run engine events on the same thread as the main engine.

start()

Starts the steno engine.

quit([code=0])

Quits the steno engine, ensuring that all pending tasks are completed before exiting.

restart()

Quits and restarts the steno engine, ensuring that all pending tasks are completed.

run()

Starts the steno engine, translating any strokes that are input.

join()

Joins any sub-threads if necessary and returns an exit code.

load_config() bool

Loads the Plover configuration file and returns True if it was loaded successfully, False if not.

reset_machine()

Resets the machine state and Plover’s connection with the machine, if necessary, and loads all the configuration and dictionaries.

send_engine_command(command: str)

Runs the specified Plover command, which can be either a built-in command like set_config or one from an external plugin.

command is a string containing the command and its argument (if any), separated by a colon. For example, lookup sends the lookup command (the same as stroking {PLOVER:LOOKUP}), and run_shell:foo sends the run_shell command with the argument foo.

toggle_output()

Toggles steno mode. See output to get the current state, or set_output() to set the state to a specific value.

set_output(enabled: bool)

Enables or disables steno mode. Set enabled to True to enable steno mode, or False to disable it.

__getitem__(setting: str) any

Returns the value of the configuration property setting.

__setitem__(setting: str, value: any)

Sets the configuration property setting to value.

get_suggestions(translation: str) List[plover.suggestions.Suggestion]

Returns a list of suggestions for the specified translation.

clear_translator_state([undo=False])

Resets the translator to an empty state, as if Plover had just started up, clearing the entire translation stack. If undo is True, this also reverts all previous translations on the stack (which could include a lot of backspaces).

hook_connect(hook: str, callback: Function)

Adds callback to the list of handlers that are called when the hook hook gets triggered. Raises a KeyError if hook is not in HOOKS.

The expected signature of the callback is depends on the hook; see Engine Hooks for more information.

hook_disconnect(hook: str, callback: Function)

Removes callback from the list of handlers that are called when the hook hook is triggered. Raises a KeyError if hook is not in HOOKS, and a ValueError if callback was never added as a handler in the first place.

The following methods simply provide a way to access the underlying StenoDictionaryCollection. See the documentation there for more complete information.

lookup(translation: Tuple[str]) str

Returns the first translation for the steno outline translation using all the filters.

raw_lookup(translation: Tuple[str]) str

Like :meth:lookup, but without any of the filters.

lookup_from_all(translation: Tuple[str]) List[str]

Returns all translations for the steno outline translation using all the filters.

raw_lookup_from_all(translation: Tuple[str]) List[str]

Like :meth:lookup_from_all, but without any of the filters.

reverse_lookup(translation: str) List[Tuple[str]]

Returns the list of steno outlines that translate to translation.

casereverse_lookup(translation: str) List[Tuple[str]]

Like :meth:reverse_lookup, but performs a case-insensitive lookup.

add_dictionary_filter(dictionary_filter: Function[Tuple[str], str, bool])

Adds dictionary_filter to the list of dictionary filters. See StenoDictionaryCollection.filters for more information.

remove_dictionary_filter(dictionary_filter: Function[Tuple[str], str, bool])

Removes dictionary_filter from the list of dictionary filters.

add_translation(strokes: Tuple[str], translation: str[, dictionary_path: str = None])

Adds a steno entry mapping the steno outline strokes to translation in the dictionary at dictionary_path, if specified, or the first writable dictionary.

class plover.engine.StartingStrokeState(attach, capitalize)

An object representing the starting state of the formatter before any strokes are input.

attach: bool

Whether to delete the space before the translation when the initial stroke is translated.

capitalize: bool

Whether to capitalize the translation when the initial stroke is translated.

class plover.engine.MachineParams(type, options, keymap)

An object representing the current state of the machine.

type: str

The name of the machine. This is the same as the name of the plugin that provides the machine’s functionality. Keyboard by default.

options: Dict[str, any]

A dictionary of machine specific options. See plover.config for more information.

keymap: plover.machine.keymap.Keymap

A Keymap mapping the current system to this machine.

class plover.engine.ErroredDictionary(path, exception)

A placeholder class for a dictionary that failed to load. This is a subclass of StenoDictionary.

path: str

The path to the dictionary file.

exception: any

The exception that caused the dictionary loading to fail.

Engine Hooks

Plover uses engine hooks to allow plugins to listen to engine events. By calling engine.hook_connect and passing the name of one of the hooks below and a function, you can write handlers that are called when Plover hooks get triggered.

stroked(stroke: plover.steno.Stroke)

The user just sent a stroke.

translated(old, new)
machine_state_changed(machine_type: str, machine_state: str)

Either the machine type was changed by the user, or the connection state of the machine changed. machine_type is the name of the machine (e.g. Gemini PR), and machine_state is one of stopped, initializing, connected or disconnected.

output_changed(enabled: bool)

The user requested to either enable or disable steno output. enabled is True if output is enabled, False otherwise.

config_changed(config: Dict[str, any])

The configuration was changed, or it was loaded for the first time. config is a dictionary containing only the changed fields. Call the hook function with the StenoEngine.config to initialize your plugin based on the full configuration.

dictionaries_loaded(dictionaries: plover.steno_dictionary.StenoDictionaryCollection)

The dictionaries were loaded, either when Plover starts up or the system is changed or when the engine is reset.

send_string(s: str)

Plover just sent the string s over keyboard output.

send_backspaces(b: int)

Plover just sent backspaces over keyboard output. b is the number of backspaces sent.

send_key_combination(c: str)

Plover just sent a keyboard combination over keyboard output. c is a string representing the keyboard combination, for example Alt_L(Tab).

add_translation()

The Add Translation command was activated – open the Add Translation tool.

focus()

The Show command was activated – reopen Plover’s main window and bring it to the front.

configure()

The Configure command was activated – open the configuration window.

lookup()

The Lookup command was activated – open the Lookup tool.

suggestions()

The Suggestions command was activated – open the Suggestions tool.

quit()

The Quit command was activated – wrap up any pending tasks and quit Plover.