Working spoken form sharing

Author: pokey

cursorless-talon/src/csv_overrides.py

@@ -1,5 +1,4 @@
 import csv
-import json
 from collections.abc import Container
 from datetime import datetime
 from pathlib import Path
@@ -26,73 +25,77 @@
     desc="The directory to use for cursorless settings csvs relative to talon user directory",
 )
 
-default_ctx = Context()
-default_ctx.matches = r"""
+# The global context we use for our lists
+ctx = Context()
+
+# A context that contains default vocabulary, for use in testing
+normalized_ctx = Context()
+normalized_ctx.matches = r"""
 tag: user.cursorless_default_vocabulary
 """
 
 
-GetType = Callable[[str, str], str]
+ListToSpokenForms = dict[str, dict[str, str]]
 
 
 def init_csv_and_watch_changes(
     filename: str,
-    default_values: dict[str, dict[str, str]],
+    default_values: ListToSpokenForms,
+    handle_new_values: Optional[Callable[[ListToSpokenForms], None]] = None,
     extra_ignored_values: Optional[list[str]] = None,
     allow_unknown_values: bool = False,
     default_list_name: Optional[str] = None,
     headers: list[str] = [SPOKEN_FORM_HEADER, CURSORLESS_IDENTIFIER_HEADER],
-    ctx: Context = Context(),
     no_update_file: bool = False,
     pluralize_lists: list[str] = [],
-    get_type: Optional[GetType] = None,
 ):
     """
     Initialize a cursorless settings csv, creating it if necessary, and watch
     for changes to the csv.  Talon lists will be generated based on the keys of
     `default_values`.  For example, if there is a key `foo`, there will be a
-    list created called `user.cursorless_foo` that will contain entries from
-    the original dict at the key `foo`, updated according to customization in
-    the csv at
+    list created called `user.cursorless_foo` that will contain entries from the
+    original dict at the key `foo`, updated according to customization in the
+    csv at
 
-        actions.path.talon_user() / "cursorless-settings" / filename
+    ```
+    actions.path.talon_user() / "cursorless-settings" / filename
+    ```
 
     Note that the settings directory location can be customized using the
     `user.cursorless_settings_directory` setting.
 
     Args:
         filename (str): The name of the csv file to be placed in
-        `cursorles-settings` dir
-        default_values (dict[str, dict]): The default values for the lists to
-        be customized in the given csv
-        extra_ignored_values list[str]: Don't throw an exception if any of
-        these appear as values; just ignore them and don't add them to any list
-        allow_unknown_values bool: If unknown values appear, just put them in the list
-        default_list_name Optional[str]: If unknown values are allowed, put any
-        unknown values in this list
-        no_update_file Optional[bool]: Set this to `TRUE` to indicate that we should
-        not update the csv. This is used generally in case there was an issue coming up with the default set of values so we don't want to persist those to disk
-        pluralize_lists: Create plural version of given lists
+            `cursorles-settings` dir
+        default_values (ListToSpokenForms): The default values for the lists to
+            be customized in the given csv
+        handle_new_values (Optional[Callable[[ListToSpokenForms], None]]): A
+            callback to be called when the lists are updated
+        extra_ignored_values (Optional[list[str]]): Don't throw an exception if
+            any of these appear as values; just ignore them and don't add them
+            to any list
+        allow_unknown_values (bool): If unknown values appear, just put them in
+            the list
+        default_list_name (Optional[str]): If unknown values are
+            allowed, put any unknown values in this list
+        headers (list[str]): The headers to use for the csv
+        no_update_file (bool): Set this to `True` to indicate that we should not
+            update the csv. This is used generally in case there was an issue
+            coming up with the default set of values so we don't want to persist
+            those to disk
+        pluralize_lists (list[str]): Create plural version of given lists
     """
     if extra_ignored_values is None:
         extra_ignored_values = []
 
     file_path = get_full_path(filename)
-    output_file_path = get_output_path(filename)
     super_default_values = get_super_values(default_values)
 
     file_path.parent.mkdir(parents=True, exist_ok=True)
 
     check_for_duplicates(filename, default_values)
     create_default_vocabulary_dicts(default_values, pluralize_lists)
 
-    try:
-        output_file_path.parent.mkdir(parents=True, exist_ok=True)
-    except Exception:
-        error_message = f"Error creating spoken form dir {output_file_path.parent}"
-        print(error_message)
-        app.notify(error_message)
-
     def on_watch(path, flags):
         if file_path.match(path):
             current_values, has_errors = read_file(
@@ -109,9 +112,7 @@ def on_watch(path, flags):
                 allow_unknown_values,
                 default_list_name,
                 pluralize_lists,
-                output_file_path,
-                get_type,
-                ctx,
+                handle_new_values,
             )
 
     fs.watch(str(file_path.parent), on_watch)
@@ -132,9 +133,7 @@ def on_watch(path, flags):
             allow_unknown_values,
             default_list_name,
             pluralize_lists,
-            output_file_path,
-            get_type,
-            ctx,
+            handle_new_values,
         )
     else:
         if not no_update_file:
@@ -146,9 +145,7 @@ def on_watch(path, flags):
             allow_unknown_values,
             default_list_name,
             pluralize_lists,
-            output_file_path,
-            get_type,
-            ctx,
+            handle_new_values,
         )
 
     def unsubscribe():
@@ -184,7 +181,7 @@ def create_default_vocabulary_dicts(
             if active_key:
                 updated_dict[active_key] = value2
         default_values_updated[key] = updated_dict
-    assign_lists_to_context(default_ctx, default_values_updated, pluralize_lists)
+    assign_lists_to_context(normalized_ctx, default_values_updated, pluralize_lists)
 
 
 def update_dicts(
@@ -194,9 +191,7 @@ def update_dicts(
     allow_unknown_values: bool,
     default_list_name: Optional[str],
     pluralize_lists: list[str],
-    output_file_path: Path,
-    get_type: Optional[GetType],
-    ctx: Context,
+    handle_new_values: Optional[Callable[[ListToSpokenForms], None]],
 ):
     # Create map with all default values
     results_map = {}
@@ -222,34 +217,32 @@ def update_dicts(
 
     # Convert result map back to result list
     results = {res["list"]: {} for res in results_map.values()}
-    output_file_entries = []
     for obj in results_map.values():
         value = obj["value"]
         key = obj["key"]
-        spoken_forms = list(get_spoken_forms(value, key))
-        for spoken_form in spoken_forms:
-            results[obj["list"]][spoken_form] = value
-        if get_type is not None and (entry_type := get_type(obj["list"], value)):
-            output_file_entries.append(
-                {"type": entry_type, "id": value, "spokenForms": spoken_forms}
-            )
+        if not is_removed(key):
+            for k in key.split("|"):
+                if value == "pasteFromClipboard" and k.endswith(" to"):
+                    # FIXME: This is a hack to work around the fact that the
+                    # spoken form of the `pasteFromClipboard` action used to be
+                    # "paste to", but now the spoken form is just "paste" and
+                    # the "to" is part of the positional target. Users who had
+                    # cursorless before this change would have "paste to" as
+                    # their spoken form and so would need to say "paste to to".
+                    k = k[:-3]
+                results[obj["list"]][k.strip()] = value
 
     # Assign result to talon context list
     assign_lists_to_context(ctx, results, pluralize_lists)
 
-    with open(output_file_path, "w") as out:
-        try:
-            out.write(json.dumps({"version": 0, "entries": output_file_entries}))
-        except Exception:
-            error_message = f"Error writing spoken form json {output_file_path}"
-            print(error_message)
-            app.notify(error_message)
+    if handle_new_values is not None:
+        handle_new_values(results)
 
 
 def assign_lists_to_context(
     ctx: Context,
     results: dict,
-    pluralize_lists: Optional[list[str]],
+    pluralize_lists: list[str],
 ):
     for list_name, dict in results.items():
         list_singular_name = get_cursorless_list_name(list_name)
@@ -259,21 +252,6 @@ def assign_lists_to_context(
             ctx.lists[list_plural_name] = {pluralize(k): v for k, v in dict.items()}
 
 
-def get_spoken_forms(id: str, spoken_form: str):
-    if not is_removed(spoken_form):
-        for k in spoken_form.split("|"):
-            if id == "pasteFromClipboard" and k.endswith(" to"):
-                # FIXME: This is a hack to work around the fact that the
-                # spoken form of the `pasteFromClipboard` action used to be
-                # "paste to", but now the spoken form is just "paste" and
-                # the "to" is part of the positional target. Users who had
-                # cursorless before this change would have "paste to" as
-                # their spoken form and so would need to say "paste to to".
-                k = k[:-3]
-
-            yield k.strip()
-
-
 def update_file(
     path: Path,
     headers: list[str],
@@ -414,27 +392,20 @@ def read_file(
     return result, has_errors
 
 
-def get_full_path(output_file_path: str):
-    if not output_file_path.endswith(".csv"):
-        output_file_path = f"{output_file_path}.csv"
+def get_full_path(filename: str):
+    if not filename.endswith(".csv"):
+        filename = f"{filename}.csv"
 
     user_dir: Path = actions.path.talon_user()
     settings_directory = Path(cursorless_settings_directory.get())
 
     if not settings_directory.is_absolute():
         settings_directory = user_dir / settings_directory
 
-    return (settings_directory / output_file_path).resolve()
-
-
-def get_output_path(output_file_path: str):
-    if output_file_path.endswith(".csv"):
-        output_file_path = output_file_path[:-4]
-
-    return Path.home() / ".cursorless" / "spokenForms" / f"{output_file_path}.json"
+    return (settings_directory / filename).resolve()
 
 
-def get_super_values(values: dict[str, dict[str, str]]):
+def get_super_values(values: ListToSpokenForms):
     result: dict[str, str] = {}
     for value_dict in values.values():
         result.update(value_dict)

cursorless-talon/src/marks/decorated_mark.py

@@ -137,7 +137,7 @@ def setup_hat_styles_csv(hat_colors: dict, hat_shapes: dict):
             "hat_color": active_hat_colors,
             "hat_shape": active_hat_shapes,
         },
-        [*hat_colors.values(), *hat_shapes.values()],
+        extra_ignored_values=[*hat_colors.values(), *hat_shapes.values()],
         no_update_file=is_shape_error or is_color_error,
     )