def __init__(self, config, keyboard_emulation):
self._config = config
self._is_running = False
self._queue = Queue()
self._lock = threading.RLock()
self._machine = None
self._machine_state = None
self._machine_params = MachineParams(None, None, None)
self._formatter = Formatter()
self._formatter.set_output(self)
self._formatter.add_listener(self._on_translated)
self._translator = Translator()
self._translator.add_listener(log.translation)
self._translator.add_listener(self._formatter.format)
self._dictionaries = self._translator.get_dictionary()
self._dictionaries_manager = DictionaryLoadingManager()
self._running_state = self._translator.get_state()
self._suggestions = Suggestions(self._dictionaries)
self._keyboard_emulation = keyboard_emulation
self._hooks = {hook: [] for hook in self.HOOKS}
def __init__(self, config, keyboard_emulation):
self._config = config
self._is_running = False
self._queue = Queue()
self._lock = threading.RLock()
self._machine = None
self._machine_state = None
self._machine_params = MachineParams(None, None, None)
self._formatter = Formatter()
self._formatter.set_output(self)
self._formatter.add_listener(self._on_translated)
self._translator = Translator()
self._translator.add_listener(log.translation)
self._translator.add_listener(self._formatter.format)
self._dictionaries = self._translator.get_dictionary()
self._dictionaries_manager = DictionaryLoadingManager()
self._running_state = self._translator.get_state()
self._suggestions = Suggestions(self._dictionaries)
self._keyboard_emulation = keyboard_emulation
self._hooks = {hook: [] for hook in self.HOOKS}
class StenoEngine(object):
HOOKS = '''
stroked
translated
machine_state_changed
output_changed
config_changed
send_string
send_backspaces
send_key_combination
add_translation
focus
configure
lookup
quit
'''.split()
def __init__(self, config, keyboard_emulation):
self._config = config
self._is_running = False
self._queue = Queue()
self._lock = threading.RLock()
self._machine = None
self._machine_state = None
self._machine_params = MachineParams(None, None, None)
self._formatter = Formatter()
self._formatter.set_output(self)
self._formatter.add_listener(self._on_translated)
self._translator = Translator()
self._translator.add_listener(log.translation)
self._translator.add_listener(self._formatter.format)
self._dictionaries = self._translator.get_dictionary()
self._dictionaries_manager = DictionaryLoadingManager()
self._running_state = self._translator.get_state()
self._suggestions = Suggestions(self._dictionaries)
self._keyboard_emulation = keyboard_emulation
self._hooks = {hook: [] for hook in self.HOOKS}
def __enter__(self):
self._lock.__enter__()
return self
def __exit__(self, exc_type, exc_value, traceback):
self._lock.__exit__(exc_type, exc_value, traceback)
def _in_engine_thread(self):
raise NotImplementedError()
def _same_thread_hook(self, func, *args, **kwargs):
if self._in_engine_thread():
func(*args, **kwargs)
else:
self._queue.put((func, args, kwargs))
def run(self):
while True:
func, args, kwargs = self._queue.get()
try:
with self._lock:
if func(*args, **kwargs):
break
except Exception:
log.error('engine %s failed', func.__name__[1:], exc_info=True)
def _stop(self):
if self._machine is not None:
self._machine.stop_capture()
self._machine = None
def _start(self):
self._set_output(self._config.get_auto_start())
copy_default_dictionaries(self._config)
self._update(full=True)
def _update(self, config_update=None, full=False, reset_machine=False):
original_config = self._config.as_dict()
# Update configuration.
if config_update is not None:
self._config.update(**config_update)
config = self._config.as_dict()
else:
config = original_config
# Create configuration update.
if full:
config_update = config
else:
config_update = {
option: value
for option, value in config.items()
if value != original_config[option]
}
if 'machine_type' in config_update:
for opt in (
'machine_specific_options',
'system_keymap',
):
config_update[opt] = config[opt]
# Update logging.
log.set_stroke_filename(config['log_file_name'])
log.enable_stroke_logging(config['enable_stroke_logging'])
log.enable_translation_logging(config['enable_translation_logging'])
# Update output.
self._formatter.set_space_placement(config['space_placement'])
self._formatter.start_attached = config['start_attached']
self._formatter.start_capitalized = config['start_capitalized']
self._translator.set_min_undo_length(config['undo_levels'])
# Update machine.
update_keymap = False
start_machine = False
machine_params = MachineParams(config['machine_type'],
config['machine_specific_options'],
config['system_keymap'])
if reset_machine or machine_params != self._machine_params:
if self._machine is not None:
self._machine.stop_capture()
self._machine = None
machine_type = config['machine_type']
machine_options = config['machine_specific_options']
try:
machine_class = machine_registry.get(machine_type)
except NoSuchMachineException as e:
raise InvalidConfigurationError(str(e))
self._machine = machine_class(machine_options)
self._machine.set_suppression(self._is_running)
self._machine.add_state_callback(self._machine_state_callback)
self._machine.add_stroke_callback(self._machine_stroke_callback)
self._machine_params = machine_params
update_keymap = True
start_machine = True
elif self._machine is not None:
update_keymap = 'system_keymap' in config_update
if update_keymap:
machine_keymap = config['system_keymap']
if machine_keymap is not None:
self._machine.set_keymap(machine_keymap)
if start_machine:
self._machine.start_capture()
# Update dictionaries.
dictionaries_files = config['dictionary_file_names']
dictionaries = self._dictionaries_manager.load(dictionaries_files)
self._dictionaries.set_dicts(dictionaries)
# Trigger `config_changed` hook.
if config_update:
self._trigger_hook('config_changed', config_update)
def _quit(self):
self._stop()
return True
def _toggle_output(self):
self._set_output(not self._is_running)
def _set_output(self, enabled):
if enabled == self._is_running:
return
self._is_running = enabled
if enabled:
self._translator.set_state(self._running_state)
else:
self._translator.clear_state()
if self._machine is not None:
self._machine.set_suppression(enabled)
self._trigger_hook('output_changed', enabled)
def _machine_state_callback(self, machine_state):
self._same_thread_hook(self._on_machine_state_changed, machine_state)
def _machine_stroke_callback(self, steno_keys):
self._same_thread_hook(self._on_stroked, steno_keys)
@with_lock
def _on_machine_state_changed(self, machine_state):
assert machine_state is not None
self._machine_state = machine_state
machine_type = self._config.get_machine_type()
self._trigger_hook('machine_state_changed', machine_type,
machine_state)
def _consume_engine_command(self, command):
# The first commands can be used whether plover has output enabled or not.
if command == 'RESUME':
self._set_output(True)
return True
elif command == 'TOGGLE':
self._toggle_output()
return True
elif command == 'QUIT':
self._trigger_hook('quit')
return True
if not self._is_running:
return False
# These commands can only be run when plover has output enabled.
if command == 'SUSPEND':
self._set_output(False)
elif command == 'CONFIGURE':
self._trigger_hook('configure')
elif command == 'FOCUS':
self._trigger_hook('focus')
elif command == 'ADD_TRANSLATION':
self._trigger_hook('add_translation')
elif command == 'LOOKUP':
self._trigger_hook('lookup')
return False
def _on_stroked(self, steno_keys):
stroke = Stroke(steno_keys)
log.stroke(stroke)
self._translator.translate(stroke)
self._trigger_hook('stroked', stroke)
def _on_translated(self, old, new):
if not self._is_running:
return
self._trigger_hook('translated', old, new)
def send_backspaces(self, b):
if not self._is_running:
return
self._keyboard_emulation.send_backspaces(b)
self._trigger_hook('send_backspaces', b)
def send_string(self, s):
if not self._is_running:
return
self._keyboard_emulation.send_string(s)
self._trigger_hook('send_string', s)
def send_key_combination(self, c):
if not self._is_running:
return
self._keyboard_emulation.send_key_combination(c)
self._trigger_hook('send_key_combination', c)
def send_engine_command(self, command):
suppress = not self._is_running
suppress &= self._consume_engine_command(command)
if suppress:
self._machine.suppress_last_stroke(
self._keyboard_emulation.send_backspaces)
def toggle_output(self):
self._same_thread_hook(self._toggle_output)
def set_output(self, enabled):
self._same_thread_hook(self._set_output, enabled)
@property
@with_lock
def machine_state(self):
return self._machine_state
@property
@with_lock
def output(self):
return self._is_running
@output.setter
def output(self, enabled):
self._same_thread_hook(self._set_output, enabled)
@property
@with_lock
def config(self):
return self._config.as_dict()
@config.setter
@with_lock
def config(self, update):
self._same_thread_hook(self._update, config_update=update)
def reset_machine(self):
self._same_thread_hook(self._update, reset_machine=True)
def load_config(self):
try:
with open(self._config.target_file, 'rb') as f:
self._config.load(f)
except Exception:
log.error('loading configuration failed, reseting to default',
exc_info=True)
self._config.clear()
return False
return True
def start(self):
self._same_thread_hook(self._start)
def quit(self):
self._same_thread_hook(self._quit)
@property
@with_lock
def machines(self):
return sorted(machine_registry.get_all_names())
@with_lock
def machine_specific_options(self, machine_type):
return self._config.get_machine_specific_options(machine_type)
@with_lock
def system_keymap(self, machine_type):
return self._config.get_system_keymap(machine_type)
@with_lock
def lookup(self, translation):
return self._dictionaries.lookup(translation)
@with_lock
def raw_lookup(self, translation):
return self._dictionaries.raw_lookup(translation)
@with_lock
def reverse_lookup(self, translation):
matches = self._dictionaries.reverse_lookup(translation)
return [] if matches is None else matches
@with_lock
def casereverse_lookup(self, translation):
matches = self._dictionaries.casereverse_lookup(translation)
return set() if matches is None else matches
@with_lock
def add_dictionary_filter(self, dictionary_filter):
self._dictionaries.add_filter(dictionary_filter)
@with_lock
def remove_dictionary_filter(self, dictionary_filter):
self._dictionaries.remove_filter(dictionary_filter)
@with_lock
def get_suggestions(self, translation):
return self._suggestions.find(translation)
@property
@with_lock
def translator_state(self):
return self._translator.get_state()
@translator_state.setter
@with_lock
def translator_state(self, state):
self._translator.set_state(state)
@with_lock
def clear_translator_state(self, undo=False):
if undo:
state = self._translator.get_state()
self._formatter.format(state.translations, (), None)
self._translator.clear_state()
@property
@with_lock
def starting_stroke_state(self):
return StartingStrokeState(self._formatter.start_attached,
self._formatter.start_capitalized)
@starting_stroke_state.setter
@with_lock
def starting_stroke_state(self, state):
self._formatter.start_attached = state.attach
self._formatter.start_capitalized = state.capitalize
@with_lock
def add_translation(self, strokes, translation, dictionary=None):
if dictionary is None:
dictionary = self._dictionaries.dicts[0].get_path()
self._dictionaries.set(strokes, translation, dictionary=dictionary)
self._dictionaries.save(path_list=(dictionary, ))
@property
@with_lock
def dictionaries(self):
return self._dictionaries
# Hooks.
def _trigger_hook(self, hook, *args, **kwargs):
for callback in self._hooks[hook]:
try:
callback(*args, **kwargs)
except Exception:
log.error('hook %r callback %r failed',
hook,
callback,
exc_info=True)
@with_lock
def hook_connect(self, hook, callback):
self._hooks[hook].append(callback)
@with_lock
def hook_disconnect(self, hook, callback):
self._hooks[hook].remove(callback)
def get_suggestions(self, translation, **kwargs):
return Suggestions(self._dictionaries).find(translation, **kwargs)
class StenoEngine(object):
HOOKS = """
stroked
translated
machine_state_changed
output_changed
config_changed
send_string
send_backspaces
send_key_combination
add_translation
focus
configure
lookup
quit
""".split()
def __init__(self, config, keyboard_emulation):
self._config = config
self._is_running = False
self._queue = Queue()
self._lock = threading.RLock()
self._machine = None
self._machine_state = None
self._machine_params = MachineParams(None, None, None)
self._formatter = Formatter()
self._formatter.set_output(self)
self._formatter.add_listener(self._on_translated)
self._translator = Translator()
self._translator.add_listener(log.translation)
self._translator.add_listener(self._formatter.format)
self._dictionaries = self._translator.get_dictionary()
self._dictionaries_manager = DictionaryLoadingManager()
self._running_state = self._translator.get_state()
self._suggestions = Suggestions(self._dictionaries)
self._keyboard_emulation = keyboard_emulation
self._hooks = {hook: [] for hook in self.HOOKS}
def __enter__(self):
self._lock.__enter__()
return self
def __exit__(self, exc_type, exc_value, traceback):
self._lock.__exit__(exc_type, exc_value, traceback)
def _in_engine_thread(self):
raise NotImplementedError()
def _same_thread_hook(self, func, *args, **kwargs):
if self._in_engine_thread():
func(*args, **kwargs)
else:
self._queue.put((func, args, kwargs))
def run(self):
while True:
func, args, kwargs = self._queue.get()
try:
with self._lock:
if func(*args, **kwargs):
break
except Exception:
log.error("engine %s failed", func.__name__[1:], exc_info=True)
def _stop(self):
if self._machine is not None:
self._machine.stop_capture()
self._machine = None
def _start(self):
self._set_output(self._config.get_auto_start())
self._update(full=True)
def _update(self, config_update=None, full=False, reset_machine=False):
original_config = self._config.as_dict()
# Update configuration.
if config_update is not None:
self._config.update(**config_update)
config = self._config.as_dict()
else:
config = original_config
# Create configuration update.
if full:
config_update = config
else:
config_update = {option: value for option, value in config.items() if value != original_config[option]}
if "machine_type" in config_update:
for opt in ("machine_specific_options", "system_keymap"):
config_update[opt] = config[opt]
# Update logging.
log.set_stroke_filename(config["log_file_name"])
log.enable_stroke_logging(config["enable_stroke_logging"])
log.enable_translation_logging(config["enable_translation_logging"])
# Update output.
self._formatter.set_space_placement(config["space_placement"])
self._formatter.start_attached = config["start_attached"]
self._formatter.start_capitalized = config["start_capitalized"]
self._translator.set_min_undo_length(config["undo_levels"])
# Update system.
system_name = config["system_name"]
if system.NAME != system_name:
log.info("loading system: %s", system_name)
system.setup(system_name)
# Update machine.
update_keymap = False
start_machine = False
machine_params = MachineParams(
config["machine_type"], config["machine_specific_options"], config["system_keymap"]
)
if reset_machine or machine_params != self._machine_params:
if self._machine is not None:
self._machine.stop_capture()
self._machine = None
machine_type = config["machine_type"]
machine_options = config["machine_specific_options"]
try:
machine_class = registry.get_plugin("machine", machine_type).resolve()
except Exception as e:
raise InvalidConfigurationError(str(e))
log.info("setting machine: %s", machine_type)
self._machine = machine_class(machine_options)
self._machine.set_suppression(self._is_running)
self._machine.add_state_callback(self._machine_state_callback)
self._machine.add_stroke_callback(self._machine_stroke_callback)
self._machine_params = machine_params
update_keymap = True
start_machine = True
elif self._machine is not None:
update_keymap = "system_keymap" in config_update
if update_keymap:
machine_keymap = config["system_keymap"]
if machine_keymap is not None:
self._machine.set_keymap(machine_keymap)
if start_machine:
self._machine.start_capture()
# Update dictionaries.
dictionaries_files = config["dictionary_file_names"]
copy_default_dictionaries(dictionaries_files)
dictionaries = self._dictionaries_manager.load(dictionaries_files)
self._dictionaries.set_dicts(dictionaries)
# Trigger `config_changed` hook.
if config_update:
self._trigger_hook("config_changed", config_update)
def _quit(self):
self._stop()
return True
def _toggle_output(self):
self._set_output(not self._is_running)
def _set_output(self, enabled):
if enabled == self._is_running:
return
self._is_running = enabled
if enabled:
self._translator.set_state(self._running_state)
else:
self._translator.clear_state()
if self._machine is not None:
self._machine.set_suppression(enabled)
self._trigger_hook("output_changed", enabled)
def _machine_state_callback(self, machine_state):
self._same_thread_hook(self._on_machine_state_changed, machine_state)
def _machine_stroke_callback(self, steno_keys):
self._same_thread_hook(self._on_stroked, steno_keys)
@with_lock
def _on_machine_state_changed(self, machine_state):
assert machine_state is not None
self._machine_state = machine_state
machine_type = self._config.get_machine_type()
self._trigger_hook("machine_state_changed", machine_type, machine_state)
def _consume_engine_command(self, command):
# The first commands can be used whether plover has output enabled or not.
if command == "RESUME":
self._set_output(True)
return True
elif command == "TOGGLE":
self._toggle_output()
return True
elif command == "QUIT":
self._trigger_hook("quit")
return True
if not self._is_running:
return False
# These commands can only be run when plover has output enabled.
if command == "SUSPEND":
self._set_output(False)
elif command == "CONFIGURE":
self._trigger_hook("configure")
elif command == "FOCUS":
self._trigger_hook("focus")
elif command == "ADD_TRANSLATION":
self._trigger_hook("add_translation")
elif command == "LOOKUP":
self._trigger_hook("lookup")
else:
command_args = command.split(":", 2)
command_fn = registry.get_plugin("command", command_args[0]).resolve()
command_fn(self, command_args[1] if len(command_args) == 2 else "")
return False
def _on_stroked(self, steno_keys):
stroke = Stroke(steno_keys)
log.stroke(stroke)
self._translator.translate(stroke)
self._trigger_hook("stroked", stroke)
def _on_translated(self, old, new):
if not self._is_running:
return
self._trigger_hook("translated", old, new)
def send_backspaces(self, b):
if not self._is_running:
return
self._keyboard_emulation.send_backspaces(b)
self._trigger_hook("send_backspaces", b)
def send_string(self, s):
if not self._is_running:
return
self._keyboard_emulation.send_string(s)
self._trigger_hook("send_string", s)
def send_key_combination(self, c):
if not self._is_running:
return
self._keyboard_emulation.send_key_combination(c)
self._trigger_hook("send_key_combination", c)
def send_engine_command(self, command):
suppress = not self._is_running
suppress &= self._consume_engine_command(command)
if suppress:
self._machine.suppress_last_stroke(self._keyboard_emulation.send_backspaces)
def toggle_output(self):
self._same_thread_hook(self._toggle_output)
def set_output(self, enabled):
self._same_thread_hook(self._set_output, enabled)
@property
@with_lock
def machine_state(self):
return self._machine_state
@property
@with_lock
def output(self):
return self._is_running
@output.setter
def output(self, enabled):
self._same_thread_hook(self._set_output, enabled)
@property
@with_lock
def config(self):
return self._config.as_dict()
@config.setter
def config(self, update):
self._same_thread_hook(self._update, config_update=update)
def reset_machine(self):
self._same_thread_hook(self._update, reset_machine=True)
def load_config(self):
try:
with open(self._config.target_file, "rb") as f:
self._config.load(f)
except Exception:
log.error("loading configuration failed, reseting to default", exc_info=True)
self._config.clear()
return False
return True
def start(self):
self._same_thread_hook(self._start)
def quit(self):
self._same_thread_hook(self._quit)
@with_lock
def list_plugins(self, plugin_type):
return sorted(registry.list_plugins(plugin_type))
@with_lock
def machine_specific_options(self, machine_type):
return self._config.get_machine_specific_options(machine_type)
@with_lock
def system_keymap(self, machine_type, system_name):
return self._config.get_system_keymap(machine_type, system_name)
@with_lock
def lookup(self, translation):
return self._dictionaries.lookup(translation)
@with_lock
def raw_lookup(self, translation):
return self._dictionaries.raw_lookup(translation)
@with_lock
def reverse_lookup(self, translation):
matches = self._dictionaries.reverse_lookup(translation)
return [] if matches is None else matches
@with_lock
def casereverse_lookup(self, translation):
matches = self._dictionaries.casereverse_lookup(translation)
return set() if matches is None else matches
@with_lock
def add_dictionary_filter(self, dictionary_filter):
self._dictionaries.add_filter(dictionary_filter)
@with_lock
def remove_dictionary_filter(self, dictionary_filter):
self._dictionaries.remove_filter(dictionary_filter)
@with_lock
def get_suggestions(self, translation):
return self._suggestions.find(translation)
@property
@with_lock
def translator_state(self):
return self._translator.get_state()
@translator_state.setter
@with_lock
def translator_state(self, state):
self._translator.set_state(state)
@with_lock
def clear_translator_state(self, undo=False):
if undo:
state = self._translator.get_state()
self._formatter.format(state.translations, (), None)
self._translator.clear_state()
@property
@with_lock
def starting_stroke_state(self):
return StartingStrokeState(self._formatter.start_attached, self._formatter.start_capitalized)
@starting_stroke_state.setter
@with_lock
def starting_stroke_state(self, state):
self._formatter.start_attached = state.attach
self._formatter.start_capitalized = state.capitalize
@with_lock
def add_translation(self, strokes, translation, dictionary=None):
if dictionary is None:
dictionary = self._dictionaries.dicts[0].get_path()
self._dictionaries.set(strokes, translation, dictionary=dictionary)
self._dictionaries.save(path_list=(dictionary,))
@property
@with_lock
def dictionaries(self):
return self._dictionaries
# Hooks.
def _trigger_hook(self, hook, *args, **kwargs):
for callback in self._hooks[hook]:
try:
callback(*args, **kwargs)
except Exception:
log.error("hook %r callback %r failed", hook, callback, exc_info=True)
@with_lock
def hook_connect(self, hook, callback):
self._hooks[hook].append(callback)
@with_lock
def hook_disconnect(self, hook, callback):
self._hooks[hook].remove(callback)
def set_dictionaries(self, file_names):
dictionary = self.translator.get_dictionary()
dicts = dict_manager.load(file_names)
dictionary.set_dicts(dicts)
self.suggestions = Suggestions(dictionary)
class StenoEngine(object):
"""Top-level class for using a stenotype machine for text input.
This class combines all the non-GUI pieces needed to use a stenotype machine
as a general purpose text entry device. The pipeline consists of the
following elements:
machine: An instance of the Stenotype class from one of the submodules of
plover.machine. This object is responsible for monitoring a particular type
of hardware for stenotype output and passing that output on to the
translator.
translator: An instance of the plover.steno.Translator class. This object
converts raw steno keys into strokes and strokes into translations. The
translation objects are then passed on to the formatter.
formatter: An instance of the plover.formatting.Formatter class. This object
converts translation objects into printable text that can be displayed to
the user. Orthographic and lexical rules, such as capitalization at the
beginning of a sentence and pluralizing a word, are taken care of here. The
formatted text is then passed on to the output.
output: An instance of plover.oslayer.keyboardcontrol.KeyboardEmulation
class plus a hook to the application allows output to the screen and control
of the app with steno strokes.
In addition to the above pieces, a logger records timestamped strokes and
translations.
"""
def __init__(self, thread_hook=same_thread_hook):
"""Creates and configures a single steno pipeline."""
self.subscribers = []
self.stroke_listeners = []
self.is_running = False
self.machine = None
self.machine_class = None
self.machine_options = None
self.machine_mappings = None
self.suggestions = None
self.thread_hook = thread_hook
self.translator = translation.Translator()
self.formatter = formatting.Formatter()
self.translator.add_listener(log.translation)
self.translator.add_listener(self.formatter.format)
self.full_output = SimpleNamespace()
self.command_only_output = SimpleNamespace()
self.running_state = self.translator.get_state()
self.set_is_running(False)
def set_machine(self, machine_class,
machine_options=None,
machine_mappings=None,
reset_machine=False):
if (not reset_machine and
self.machine_class == machine_class and
self.machine_options == machine_options and
self.machine_mappings == machine_mappings):
return
if self.machine is not None:
log.debug('stopping machine: %s', self.machine_class.__name__)
self.machine.remove_state_callback(self._machine_state_callback)
self.machine.remove_stroke_callback(
self._translator_machine_callback)
self.machine.remove_stroke_callback(log.stroke)
self.machine.stop_capture()
self.machine_class = None
self.machine_options = None
self.machine_mappings = None
self.machine = None
if machine_class is not None:
log.debug('starting machine: %s', machine_class.__name__)
machine = machine_class(machine_options)
if machine_mappings is not None:
machine.set_mappings(machine_mappings)
machine.add_state_callback(self._machine_state_callback)
machine.add_stroke_callback(log.stroke)
machine.add_stroke_callback(self._translator_machine_callback)
self.machine = machine
self.machine_class = machine_class
self.machine_options = machine_options
self.machine_mappings = machine_mappings
self.machine.start_capture()
is_running = self.is_running
else:
is_running = False
self.set_is_running(is_running)
def set_dictionaries(self, file_names):
dictionary = self.translator.get_dictionary()
dicts = dict_manager.load(file_names)
dictionary.set_dicts(dicts)
self.suggestions = Suggestions(dictionary)
def get_dictionary(self):
return self.translator.get_dictionary()
def get_suggestions(self, translation):
return self.suggestions.find(translation)
def set_is_running(self, value):
if value != self.is_running:
log.debug('%s output', 'enabling' if value else 'disabling')
self.is_running = value
if self.is_running:
self.translator.set_state(self.running_state)
self.formatter.set_output(self.full_output)
else:
self.translator.clear_state()
self.formatter.set_output(self.command_only_output)
if self.machine is not None:
self.machine.set_suppression(self.is_running)
for callback in self.subscribers:
callback(None)
def set_output(self, o):
self.full_output.send_backspaces = o.send_backspaces
self.full_output.send_string = o.send_string
self.full_output.send_key_combination = o.send_key_combination
self.full_output.send_engine_command = o.send_engine_command
self.command_only_output.send_engine_command = o.send_engine_command
def destroy(self):
"""Halts the stenography capture-translate-format-display pipeline.
Calling this method causes all worker threads involved to terminate.
This method should be called at least once if the start method had been
previously called. Calling this method more than once or before the
start method has been called has no effect.
"""
if self.machine:
self.machine.stop_capture()
self.is_running = False
def add_callback(self, callback):
"""Subscribes a function to receive changes of the is_running state.
Arguments:
callback -- A function that takes no arguments.
"""
self.subscribers.append(callback)
def set_log_file_name(self, filename):
"""Set the file name for log output."""
log.set_stroke_filename(filename)
def enable_stroke_logging(self, b):
"""Turn stroke logging on or off."""
log.enable_stroke_logging(b)
def set_space_placement(self, s):
"""Set whether spaces will be inserted before the output or after the output."""
self.formatter.set_space_placement(s)
def set_starting_stroke_state(self, capitalize=False, attach=False):
self.formatter.start_attached = attach
self.formatter.start_capitalized = capitalize
def set_undo_levels(self, levels):
"""Set the maximum number of changes that can be undone."""
self.translator.set_min_undo_length(levels)
def enable_translation_logging(self, b):
"""Turn translation logging on or off."""
log.enable_translation_logging(b)
def add_stroke_listener(self, listener):
self.stroke_listeners.append(listener)
def remove_stroke_listener(self, listener):
self.stroke_listeners.remove(listener)
def _translate_stroke(self, s):
stroke = steno.Stroke(s)
self.translator.translate(stroke)
for listener in self.stroke_listeners:
listener(stroke)
def _translator_machine_callback(self, s):
self.thread_hook(self._translate_stroke, s)
def _notify_listeners(self, s):
for callback in self.subscribers:
callback(s)
def _machine_state_callback(self, s):
self.thread_hook(self._notify_listeners, s)
class StenoEngine(object):
HOOKS = '''
stroked
translated
machine_state_changed
output_changed
config_changed
send_string
send_backspaces
send_key_combination
add_translation
focus
configure
lookup
quit
'''.split()
def __init__(self, config, keyboard_emulation):
self._config = config
self._is_running = False
self._queue = Queue()
self._lock = threading.RLock()
self._machine = None
self._machine_state = None
self._machine_params = MachineParams(None, None, None)
self._formatter = Formatter()
self._formatter.set_output(self)
self._formatter.add_listener(self._on_translated)
self._translator = Translator()
self._translator.add_listener(log.translation)
self._translator.add_listener(self._formatter.format)
self._dictionaries = self._translator.get_dictionary()
self._dictionaries_manager = DictionaryLoadingManager()
self._running_state = self._translator.get_state()
self._suggestions = Suggestions(self._dictionaries)
self._keyboard_emulation = keyboard_emulation
self._hooks = { hook: [] for hook in self.HOOKS }
def __enter__(self):
self._lock.__enter__()
return self
def __exit__(self, exc_type, exc_value, traceback):
self._lock.__exit__(exc_type, exc_value, traceback)
def _in_engine_thread(self):
raise NotImplementedError()
def _same_thread_hook(self, func, *args, **kwargs):
if self._in_engine_thread():
func(*args, **kwargs)
else:
self._queue.put((func, args, kwargs))
def run(self):
while True:
func, args, kwargs = self._queue.get()
try:
with self._lock:
if func(*args, **kwargs):
break
except Exception:
log.error('engine %s failed', func.__name__[1:], exc_info=True)
def _stop(self):
if self._machine is not None:
self._machine.stop_capture()
self._machine = None
def _start(self):
self._set_output(self._config.get_auto_start())
copy_default_dictionaries(self._config)
self._update(full=True)
def _update(self, config_update=None, full=False, reset_machine=False):
original_config = self._config.as_dict()
# Update configuration.
if config_update is not None:
self._config.update(**config_update)
config = self._config.as_dict()
else:
config = original_config
# Create configuration update.
if full:
config_update = config
else:
config_update = {
option: value
for option, value in config.items()
if value != original_config[option]
}
if 'machine_type' in config_update:
for opt in (
'machine_specific_options',
'system_keymap',
):
config_update[opt] = config[opt]
# Update logging.
log.set_stroke_filename(config['log_file_name'])
log.enable_stroke_logging(config['enable_stroke_logging'])
log.enable_translation_logging(config['enable_translation_logging'])
# Update output.
self._formatter.set_space_placement(config['space_placement'])
self._formatter.start_attached = config['start_attached']
self._formatter.start_capitalized = config['start_capitalized']
self._translator.set_min_undo_length(config['undo_levels'])
# Update machine.
update_keymap = False
start_machine = False
machine_params = MachineParams(config['machine_type'],
config['machine_specific_options'],
config['system_keymap'])
if reset_machine or machine_params != self._machine_params:
if self._machine is not None:
self._machine.stop_capture()
self._machine = None
machine_type = config['machine_type']
machine_options = config['machine_specific_options']
try:
machine_class = machine_registry.get(machine_type)
except NoSuchMachineException as e:
raise InvalidConfigurationError(str(e))
self._machine = machine_class(machine_options)
self._machine.set_suppression(self._is_running)
self._machine.add_state_callback(self._machine_state_callback)
self._machine.add_stroke_callback(self._machine_stroke_callback)
self._machine_params = machine_params
update_keymap = True
start_machine = True
elif self._machine is not None:
update_keymap = 'system_keymap' in config_update
if update_keymap:
machine_keymap = config['system_keymap']
if machine_keymap is not None:
self._machine.set_keymap(machine_keymap)
if start_machine:
self._machine.start_capture()
# Update dictionaries.
dictionaries_files = config['dictionary_file_names']
dictionaries = self._dictionaries_manager.load(dictionaries_files)
self._dictionaries.set_dicts(dictionaries)
# Trigger `config_changed` hook.
if config_update:
self._trigger_hook('config_changed', config_update)
def _quit(self):
self._stop()
return True
def _toggle_output(self):
self._set_output(not self._is_running)
def _set_output(self, enabled):
if enabled == self._is_running:
return
self._is_running = enabled
if enabled:
self._translator.set_state(self._running_state)
else:
self._translator.clear_state()
if self._machine is not None:
self._machine.set_suppression(enabled)
self._trigger_hook('output_changed', enabled)
def _machine_state_callback(self, machine_state):
self._same_thread_hook(self._on_machine_state_changed, machine_state)
def _machine_stroke_callback(self, steno_keys):
self._same_thread_hook(self._on_stroked, steno_keys)
@with_lock
def _on_machine_state_changed(self, machine_state):
assert machine_state is not None
self._machine_state = machine_state
machine_type = self._config.get_machine_type()
self._trigger_hook('machine_state_changed', machine_type, machine_state)
def _consume_engine_command(self, command):
# The first commands can be used whether plover has output enabled or not.
if command == 'RESUME':
self._set_output(True)
return True
elif command == 'TOGGLE':
self._toggle_output()
return True
elif command == 'QUIT':
self._trigger_hook('quit')
return True
if not self._is_running:
return False
# These commands can only be run when plover has output enabled.
if command == 'SUSPEND':
self._set_output(False)
elif command == 'CONFIGURE':
self._trigger_hook('configure')
elif command == 'FOCUS':
self._trigger_hook('focus')
elif command == 'ADD_TRANSLATION':
self._trigger_hook('add_translation')
elif command == 'LOOKUP':
self._trigger_hook('lookup')
return False
def _on_stroked(self, steno_keys):
stroke = Stroke(steno_keys)
log.stroke(stroke)
self._translator.translate(stroke)
self._trigger_hook('stroked', stroke)
def _on_translated(self, old, new):
if not self._is_running:
return
self._trigger_hook('translated', old, new)
def send_backspaces(self, b):
if not self._is_running:
return
self._keyboard_emulation.send_backspaces(b)
self._trigger_hook('send_backspaces', b)
def send_string(self, s):
if not self._is_running:
return
self._keyboard_emulation.send_string(s)
self._trigger_hook('send_string', s)
def send_key_combination(self, c):
if not self._is_running:
return
self._keyboard_emulation.send_key_combination(c)
self._trigger_hook('send_key_combination', c)
def send_engine_command(self, command):
suppress = not self._is_running
suppress &= self._consume_engine_command(command)
if suppress:
self._machine.suppress_last_stroke(self._keyboard_emulation.send_backspaces)
def toggle_output(self):
self._same_thread_hook(self._toggle_output)
def set_output(self, enabled):
self._same_thread_hook(self._set_output, enabled)
@property
@with_lock
def machine_state(self):
return self._machine_state
@property
@with_lock
def output(self):
return self._is_running
@output.setter
def output(self, enabled):
self._same_thread_hook(self._set_output, enabled)
@property
@with_lock
def config(self):
return self._config.as_dict()
@config.setter
@with_lock
def config(self, update):
self._same_thread_hook(self._update, config_update=update)
def reset_machine(self):
self._same_thread_hook(self._update, reset_machine=True)
def load_config(self):
try:
with open(self._config.target_file, 'rb') as f:
self._config.load(f)
except Exception:
log.error('loading configuration failed, reseting to default', exc_info=True)
self._config.clear()
return False
return True
def start(self):
self._same_thread_hook(self._start)
def quit(self):
self._same_thread_hook(self._quit)
@property
@with_lock
def machines(self):
return sorted(machine_registry.get_all_names())
@with_lock
def machine_specific_options(self, machine_type):
return self._config.get_machine_specific_options(machine_type)
@with_lock
def system_keymap(self, machine_type):
return self._config.get_system_keymap(machine_type)
@with_lock
def lookup(self, translation):
return self._dictionaries.lookup(translation)
@with_lock
def raw_lookup(self, translation):
return self._dictionaries.raw_lookup(translation)
@with_lock
def reverse_lookup(self, translation):
matches = self._dictionaries.reverse_lookup(translation)
return [] if matches is None else matches
@with_lock
def casereverse_lookup(self, translation):
matches = self._dictionaries.casereverse_lookup(translation)
return set() if matches is None else matches
@with_lock
def add_dictionary_filter(self, dictionary_filter):
self._dictionaries.add_filter(dictionary_filter)
@with_lock
def remove_dictionary_filter(self, dictionary_filter):
self._dictionaries.remove_filter(dictionary_filter)
@with_lock
def get_suggestions(self, translation):
return self._suggestions.find(translation)
@property
@with_lock
def translator_state(self):
return self._translator.get_state()
@translator_state.setter
@with_lock
def translator_state(self, state):
self._translator.set_state(state)
@with_lock
def clear_translator_state(self, undo=False):
if undo:
state = self._translator.get_state()
self._formatter.format(state.translations, (), None)
self._translator.clear_state()
@property
@with_lock
def starting_stroke_state(self):
return StartingStrokeState(self._formatter.start_attached,
self._formatter.start_capitalized)
@starting_stroke_state.setter
@with_lock
def starting_stroke_state(self, state):
self._formatter.start_attached = state.attach
self._formatter.start_capitalized = state.capitalize
@with_lock
def add_translation(self, strokes, translation, dictionary=None):
if dictionary is None:
dictionary = self._dictionaries.dicts[0].get_path()
self._dictionaries.set(strokes, translation,
dictionary=dictionary)
self._dictionaries.save(path_list=(dictionary,))
@property
@with_lock
def dictionaries(self):
return self._dictionaries
# Hooks.
def _trigger_hook(self, hook, *args, **kwargs):
for callback in self._hooks[hook]:
try:
callback(*args, **kwargs)
except Exception:
log.error('hook %r callback %r failed',
hook, callback,
exc_info=True)
@with_lock
def hook_connect(self, hook, callback):
self._hooks[hook].append(callback)
@with_lock
def hook_disconnect(self, hook, callback):
self._hooks[hook].remove(callback)
class StenoEngine(object):
"""Top-level class for using a stenotype machine for text input.
This class combines all the non-GUI pieces needed to use a stenotype machine
as a general purpose text entry device. The pipeline consists of the
following elements:
machine: An instance of the Stenotype class from one of the submodules of
plover.machine. This object is responsible for monitoring a particular type
of hardware for stenotype output and passing that output on to the
translator.
translator: An instance of the plover.steno.Translator class. This object
converts raw steno keys into strokes and strokes into translations. The
translation objects are then passed on to the formatter.
formatter: An instance of the plover.formatting.Formatter class. This object
converts translation objects into printable text that can be displayed to
the user. Orthographic and lexical rules, such as capitalization at the
beginning of a sentence and pluralizing a word, are taken care of here. The
formatted text is then passed on to the output.
output: An instance of plover.oslayer.keyboardcontrol.KeyboardEmulation
class plus a hook to the application allows output to the screen and control
of the app with steno strokes.
In addition to the above pieces, a logger records timestamped strokes and
translations.
"""
def __init__(self, thread_hook=same_thread_hook):
"""Creates and configures a single steno pipeline."""
self.subscribers = []
self.stroke_listeners = []
self.is_running = False
self.machine = None
self.machine_class = None
self.machine_options = None
self.machine_mappings = None
self.suggestions = None
self.thread_hook = thread_hook
self.translator = translation.Translator()
self.formatter = formatting.Formatter()
self.translator.add_listener(log.translation)
self.translator.add_listener(self.formatter.format)
self.full_output = SimpleNamespace()
self.command_only_output = SimpleNamespace()
self.running_state = self.translator.get_state()
self.set_is_running(False)
def set_machine(self, machine_class,
machine_options=None,
machine_mappings=None,
reset_machine=False):
if (not reset_machine and
self.machine_class == machine_class and
self.machine_options == machine_options and
self.machine_mappings == machine_mappings):
return
if self.machine is not None:
log.debug('stopping machine: %s', self.machine_class.__name__)
self.machine.remove_state_callback(self._machine_state_callback)
self.machine.remove_stroke_callback(
self._translator_machine_callback)
self.machine.remove_stroke_callback(log.stroke)
self.machine.stop_capture()
self.machine_class = None
self.machine_options = None
self.machine_mappings = None
self.machine = None
if machine_class is not None:
log.debug('starting machine: %s', machine_class.__name__)
machine = machine_class(machine_options)
if machine_mappings is not None:
machine.set_mappings(machine_mappings)
machine.add_state_callback(self._machine_state_callback)
machine.add_stroke_callback(log.stroke)
machine.add_stroke_callback(self._translator_machine_callback)
self.machine = machine
self.machine_class = machine_class
self.machine_options = machine_options
self.machine_mappings = machine_mappings
self.machine.start_capture()
is_running = self.is_running
else:
is_running = False
self.set_is_running(is_running)
def set_dictionaries(self, file_names):
dictionary = self.translator.get_dictionary()
dicts = dict_manager.load(file_names)
dictionary.set_dicts(dicts)
self.suggestions = Suggestions(dictionary)
def get_dictionary(self):
return self.translator.get_dictionary()
def get_suggestions(self, translation):
return self.suggestions.find(translation)
def set_is_running(self, value):
if value != self.is_running:
log.debug('%s output', 'enabling' if value else 'disabling')
self.is_running = value
if self.is_running:
self.translator.set_state(self.running_state)
self.formatter.set_output(self.full_output)
else:
self.translator.clear_state()
self.formatter.set_output(self.command_only_output)
if self.machine is not None:
self.machine.set_suppression(self.is_running)
for callback in self.subscribers:
callback(None)
def set_output(self, o):
self.full_output.send_backspaces = o.send_backspaces
self.full_output.send_string = o.send_string
self.full_output.send_key_combination = o.send_key_combination
self.full_output.send_engine_command = o.send_engine_command
self.command_only_output.send_engine_command = o.send_engine_command
def destroy(self):
"""Halts the stenography capture-translate-format-display pipeline.
Calling this method causes all worker threads involved to terminate.
This method should be called at least once if the start method had been
previously called. Calling this method more than once or before the
start method has been called has no effect.
"""
if self.machine:
self.machine.stop_capture()
self.is_running = False
def add_callback(self, callback):
"""Subscribes a function to receive changes of the is_running state.
Arguments:
callback -- A function that takes no arguments.
"""
self.subscribers.append(callback)
def set_log_file_name(self, filename):
"""Set the file name for log output."""
log.set_stroke_filename(filename)
def enable_stroke_logging(self, b):
"""Turn stroke logging on or off."""
log.enable_stroke_logging(b)
def set_space_placement(self, s):
"""Set whether spaces will be inserted before the output or after the output."""
self.formatter.set_space_placement(s)
def set_starting_stroke_state(self, capitalize=False, attach=False):
self.formatter.start_attached = attach
self.formatter.start_capitalized = capitalize
def set_undo_levels(self, levels):
"""Set the maximum number of changes that can be undone."""
self.translator.set_min_undo_length(levels)
def enable_translation_logging(self, b):
"""Turn translation logging on or off."""
log.enable_translation_logging(b)
def add_stroke_listener(self, listener):
self.stroke_listeners.append(listener)
def remove_stroke_listener(self, listener):
self.stroke_listeners.remove(listener)
def _translate_stroke(self, s):
stroke = steno.Stroke(s)
self.translator.translate(stroke)
for listener in self.stroke_listeners:
listener(stroke)
def _translator_machine_callback(self, s):
self.thread_hook(self._translate_stroke, s)
def _notify_listeners(self, s):
for callback in self.subscribers:
callback(s)
def _machine_state_callback(self, s):
self.thread_hook(self._notify_listeners, s)
def set_dictionaries(self, file_names):
dictionary = self.translator.get_dictionary()
dicts = dict_manager.load(file_names)
dictionary.set_dicts(dicts)
self.suggestions = Suggestions(dictionary)