Implement dynamic status update of the dictionaries (#1400)

Author: user202729

news.d/feature/1400.ui.md

@@ -0,0 +1 @@
+Dynamically update individual status icons while loading dictionaries.

plover/dictionary/loading_manager.py

@@ -7,13 +7,19 @@
 import time
 
 from plover.dictionary.base import load_dictionary
-from plover.exception import DictionaryLoaderException
 from plover.resource import resource_timestamp
 from plover import log
 
 
 class DictionaryLoadingManager:
-    def __init__(self):
+    def __init__(self, state_change_callback):
+        """
+        Parameters:
+        state_change_callback -- A function that will be called when any dictionary is loaded
+            with two parameters: the filename and the loaded StenoDictionary object
+            (or an instance of ErroredDictionary if the load fails).
+        """
+        self._state_change_callback = state_change_callback
         self.dictionaries = {}
 
     def __len__(self):
@@ -32,7 +38,7 @@ def start_loading(self, filename):
         log.info(
             "%s dictionary: %s", "loading" if op is None else "reloading", filename
         )
-        op = DictionaryLoadingOperation(filename)
+        op = DictionaryLoadingOperation(filename, self._state_change_callback)
         self.dictionaries[filename] = op
         return op
 
@@ -52,7 +58,15 @@ def load(self, filenames):
 
 
 class DictionaryLoadingOperation:
-    def __init__(self, filename):
+    def __init__(self, filename, state_change_callback):
+        """
+        Parameters:
+        filename -- Path to dictionary file.
+        state_change_callback -- A function that will be called when the load is finished
+            with two parameters: the filename and the loaded StenoDictionary object
+            (or an instance of ErroredDictionary if the load fails).
+        """
+        self._state_change_callback = state_change_callback
         self.loading_thread = threading.Thread(target=self.load)
         self.filename = filename
         self.result = None
@@ -87,8 +101,11 @@ def load(self):
             self.result = load_dictionary(self.filename)
         except Exception as e:
             log.debug("loading dictionary %s failed", self.filename, exc_info=True)
-            self.result = DictionaryLoaderException(self.filename, e)
+            from plover.engine import ErroredDictionary
+
+            self.result = ErroredDictionary(self.filename, e)
             self.result.timestamp = timestamp
+        self._state_change_callback(self.filename, self.result)
 
     def get(self):
         self.loading_thread.join()

plover/engine.py

@@ -1,13 +1,13 @@
 from collections import namedtuple, OrderedDict
 from functools import wraps
 from queue import Queue
+import functools
 import os
 import shutil
 import threading
 
 from plover import log, system
 from plover.dictionary.loading_manager import DictionaryLoadingManager
-from plover.exception import DictionaryLoaderException
 from plover.formatting import Formatter
 from plover.misc import shorten_path
 from plover.registry import registry
@@ -83,6 +83,7 @@ class StenoEngine:
     output_changed
     config_changed
     dictionaries_loaded
+    dictionary_state_changed
     send_string
     send_backspaces
     send_key_combination
@@ -116,8 +117,10 @@ def __init__(self, config, controller, keyboard_emulation):
         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._dictionaries = self._translator.get_dictionary()  # type: StenoDictionaryCollection
+        self._dictionaries_manager = DictionaryLoadingManager(
+            functools.partial(self._trigger_hook, "dictionary_state_changed")
+        )
         self._running_state = self._translator.get_state()
         self._translator.clear_state()
         self._keyboard_emulation = keyboard_emulation
@@ -282,18 +285,15 @@ def _update(self, config_update=None, full=False, reset_machine=False):
         )
         # And then (re)load all dictionaries.
         dictionaries = []
-        for result in self._dictionaries_manager.load(config_dictionaries.keys()):
-            if isinstance(result, DictionaryLoaderException):
-                d = ErroredDictionary(result.path, result.exception)
+        for d in self._dictionaries_manager.load(config_dictionaries.keys()):
+            if isinstance(d, ErroredDictionary):
                 # Only show an error if it's new.
-                if d != self._dictionaries.get(result.path):
+                if d != self._dictionaries.get(d.path):
                     log.error(
                         "loading dictionary `%s` failed: %s",
-                        shorten_path(result.path),
-                        str(result.exception),
+                        shorten_path(d.path),
+                        str(d.exception),
                     )
-            else:
-                d = result
             d.enabled = config_dictionaries[d.path].enabled
             dictionaries.append(d)
         self._set_dictionaries(dictionaries)

plover/exception.py

@@ -13,15 +13,3 @@ class InvalidConfigurationError(Exception):
     "Raised when there is something wrong in the configuration."
 
     pass
-
-
-class DictionaryLoaderException(Exception):
-    """Dictionary file could not be loaded."""
-
-    def __init__(self, path, exception):
-        super().__init__(path, exception)
-        self.path = path
-        self.exception = exception
-
-    def __str__(self):
-        return "loading dictionary `%s` failed: %s" % (self.path, self.exception)

plover/gui_qt/dictionaries_widget.py

@@ -132,6 +132,9 @@ def __init__(self, engine, icons, max_undo=20):
             config = engine.config
             engine.signal_connect("config_changed", self._on_config_changed)
             engine.signal_connect("dictionaries_loaded", self._on_dictionaries_loaded)
+            engine.signal_connect(
+                "dictionary_state_changed", self._on_dictionary_state_changed
+            )
             self._reset_items(
                 config["dictionaries"],
                 config["classic_dictionaries_display_order"],
@@ -248,6 +251,12 @@ def _on_dictionaries_loaded(self, loaded_dictionaries):
         updated_rows.update(self._update_favorite())
         self._updated_rows(updated_rows)
 
+    def _on_dictionary_state_changed(self, filename, d):
+        [item] = [item for item in self._from_row if item.path == filename]
+        if item.loaded != d:
+            item.loaded = d
+            self._updated_rows([item.row])
+
     def _move(self, index_list, step):
         row_list = sorted(self._normalized_row_list(index_list))
         if not row_list:

plover/gui_qt/engine.py

@@ -14,7 +14,12 @@ class Engine(StenoEngine, QThread):
     signal_machine_state_changed = Signal(str, str)
     signal_output_changed = Signal(bool)
     signal_config_changed = Signal(object)
-    signal_dictionaries_loaded = Signal(object)
+    signal_dictionary_state_changed = Signal(
+        str, object
+    )  # Some dictionary has finished loading. Refer to class DictionaryLoadingManager for argument description.
+    signal_dictionaries_loaded = Signal(
+        object
+    )  # All dictionaries are loaded. Argument is a StenoDictionaryCollection instance.
     signal_send_string = Signal(str)
     signal_send_backspaces = Signal(int)
     signal_send_key_combination = Signal(str)

test/gui_qt/test_dictionaries_widget.py

@@ -222,7 +222,11 @@ def model_test(monkeypatch, request):
     """.split():
         getattr(model, slot).connect(getattr(signals, slot))
     connections = dict(call.args for call in engine.signal_connect.mock_calls)
-    assert connections.keys() == {"config_changed", "dictionaries_loaded"}
+    assert connections.keys() == {
+        "config_changed",
+        "dictionaries_loaded",
+        "dictionary_state_changed",
+    }
     config.reset_mock()
     engine.reset_mock()
     # Test helper.

test/test_engine.py

@@ -177,8 +177,11 @@ def test_engine_lifecycle(engine):
 
 def test_loading_dictionaries(tmp_path, engine):
     def check_loaded_events(actual_events, expected_events):
-        assert len(actual_events) == len(expected_events)
-        for n, event in enumerate(actual_events):
+        filtered_events = [
+            event for event in actual_events if event[0] != "dictionary_state_changed"
+        ]
+        assert len(filtered_events) == len(expected_events)
+        for n, event in enumerate(filtered_events):
             event_type, event_args, event_kwargs = event
             msg = "event %u: %r" % (n, event)
             assert event_type == "dictionaries_loaded", msg
@@ -230,12 +233,8 @@ def check_loaded_events(actual_events, expected_events):
                     (valid_dict_1, False),
                     (invalid_dict_1, True),
                 ],
-                [
-                    (valid_dict_1, False, False),
-                    (invalid_dict_1, True, True),
-                ],
             ],
-            # Replace invalid dictonary with another invalid one.
+            # Replace invalid dictionary with another invalid one.
             [
                 [
                     (valid_dict_1, False),

test/test_loading_manager.py

@@ -9,7 +9,7 @@
 
 import pytest
 
-from plover.exception import DictionaryLoaderException
+from plover.engine import ErroredDictionary
 import plover.dictionary.loading_manager as loading_manager
 
 
@@ -66,7 +66,7 @@ def df(name):
 
     loader = MockLoader(dictionaries)
     monkeypatch.setattr("plover.dictionary.loading_manager.load_dictionary", loader)
-    manager = loading_manager.DictionaryLoadingManager()
+    manager = loading_manager.DictionaryLoadingManager(lambda filename, result: None)
     manager.start_loading(df("a")).get()
     manager.start_loading(df("b")).get()
     results = manager.load([df("c"), df("b")])
@@ -82,15 +82,15 @@ def df(name):
     assert df("b") in manager
     assert df("c") in manager
     assert results == [manager[df("c")], manager[df("b")]]
-    # Return a DictionaryLoaderException for load errors.
+    # Return a ErroredDictionary for load errors.
     results = manager.load([df("c"), df("e"), df("b"), df("f")])
     assert len(results) == 4
     assert results[0] == "ccccc"
     assert results[2] == "bbbbb"
-    assert isinstance(results[1], DictionaryLoaderException)
+    assert isinstance(results[1], ErroredDictionary)
     assert results[1].path == df("e")
     assert isinstance(results[1].exception, Exception)
-    assert isinstance(results[3], DictionaryLoaderException)
+    assert isinstance(results[3], ErroredDictionary)
     assert results[3].path == df("f")
     assert isinstance(results[3].exception, Exception)
     # Only loaded the files once.