feat: summarize g2p errors in assemble and on the CLI

In assemble, just list the words that could not be g2p'd, so the error
message shown to the user in Studio-Web is legible.

In the CLI, add a summary list of the words that could not be g2p's in
the error message.

Author: joanise

readalongs/align_utils.py

@@ -58,7 +58,7 @@ def parse_and_make_xml(
     xml = add_ids(xml)
     if save_temps is not None:
         save_xml(save_temps + ".ids.readalong", xml)
-    xml, valid = convert_xml(
+    xml, valid, non_convertible_words = convert_xml(
         xml,
         verbose_warnings=verbose_g2p_warnings,
         output_orthography=output_orthography,
@@ -67,8 +67,10 @@ def parse_and_make_xml(
         save_xml(save_temps + ".g2p.readalong", xml)
     if not valid:
         raise RuntimeError(
-            "Some words could not be g2p'd correctly. Aborting. "
-            "Run with --debug-g2p for more detailed g2p error logs."
+            "These words could not be g2p'd correctly: '"
+            + "', '".join(non_convertible_words)
+            + "'. Aborting. "
+            + "Run with --debug-g2p for more detailed g2p error logs."
         )
     return xml
 

readalongs/cli.py

@@ -749,7 +749,9 @@ def g2p(**kwargs):
     xml = add_ids(xml)
 
     # Apply the g2p mappings.
-    xml, valid = convert_xml(xml, verbose_warnings=kwargs["debug_g2p"])
+    xml, valid, non_convertible_words = convert_xml(
+        xml, verbose_warnings=kwargs["debug_g2p"]
+    )
 
     if output_path == "-":
         write_xml(sys.stdout.buffer, xml)
@@ -759,7 +761,9 @@ def g2p(**kwargs):
 
     if not valid:
         LOGGER.error(
-            "Some word(s) could not be g2p'd correctly."
+            "These word(s) could not be g2p'd correctly: '"
+            + "', '".join(non_convertible_words)
+            + "'."
             + (
                 " Run again with --debug-g2p to get more detailed error messages."
                 if not kwargs["debug_g2p"]

readalongs/text/convert_xml.py

@@ -205,6 +205,7 @@ def convert_word_with_cascade(
     all_g2p_valid = True
     if start_time is None:
         start_time = perf_counter()
+    non_convertible_words: Dict[str, bool] = {}  # dict used as ordered set
     for i, word in enumerate(xml.xpath(".//" + word_unit)):
         if time_limit is not None and perf_counter() - start_time > time_limit:
             raise TimeLimitException(
@@ -234,6 +235,7 @@ def convert_word_with_cascade(
                     text_to_g2p, g2p_lang, g2p_fallbacks
                 )
                 if not valid:
+                    non_convertible_words[text_to_g2p] = True
                     all_g2p_valid = False
                 if effective_g2p_lang:
                     word.attrib["effective-g2p-lang"] = effective_g2p_lang
@@ -256,7 +258,7 @@ def convert_word_with_cascade(
 
         word.attrib["ARPABET"] = all_arpabet.strip()
 
-    return xml, all_g2p_valid
+    return xml, all_g2p_valid, list(non_convertible_words.keys())
 
 
 def convert_xml(
@@ -280,21 +282,22 @@ def convert_xml(
                     of the calling process
 
     Returns:
-        xml (etree), valid (bool):
+        xml (etree), valid (bool), non_convertible_words (list[str]):
           - xml is a deepcopy of the input xml with the ARPABET attribute added
             to each word_unit element;
           - valid is a flag indicating whether all words were g2p'd successfully
+          - non_convertible_words is a list of words that could not be g2p converted
 
     Raises:
         TimeLimitException: if the time_limit is specified and exceeded
     """
     xml_copy = copy.deepcopy(xml)
-    xml_copy, valid = convert_words(
+    xml_copy, valid, non_convertible_words = convert_words(
         xml_copy,
         word_unit,
         output_orthography,
         verbose_warnings,
         time_limit,
         start_time,
     )
-    return xml_copy, valid
+    return xml_copy, valid, non_convertible_words

readalongs/text/make_package.py

@@ -116,7 +116,7 @@ def encode_from_path(path: Union[str, os.PathLike]) -> str:
     return f"data:{mime_type};base64,{b64}"
 
 
-def fetch_bundle_file(url, filename, prev_status_code):
+def fetch_bundle_file(url: str, filename: str, prev_status_code: Any):
     """Fetch either of the online bundles, or their on-disk fallback if needed."""
     import requests  # Defer expensive import
 

readalongs/web_api.py

@@ -259,7 +259,7 @@ async def assemble(
 
         # g2p
         try:
-            g2ped, valid = convert_xml(
+            g2ped, valid, non_convertible_words = convert_xml(
                 ids_added,
                 start_time=start_time,
                 time_limit=ASSEMBLE_TIME_LIMIT_IN_SECONDS,
@@ -268,10 +268,18 @@ async def assemble(
             raise HTTPException(status_code=422, detail=str(e)) from e
 
         if not valid:
+            if non_convertible_words:
+                logs = (
+                    "These words could not be converted from text to phonemes by g2p: '"
+                    + "', '".join(non_convertible_words)
+                    + "'."
+                )
+            else:
+                logs = "Logs: " + captured_logs.getvalue()
             raise HTTPException(
                 status_code=422,
-                detail="g2p could not be performed, please check your text or your language code. Logs: "
-                + captured_logs.getvalue(),
+                detail="g2p could not be performed, please check your text or your language code. "
+                + logs,
             )
         # create grammar
         dict_data, text_input = create_grammar(g2ped)

test/test_g2p_cli.py

@@ -449,15 +449,15 @@ def test_convert_xml_subwords(self):
     def test_convert_xml_invalid(self):
         """test readalongs.text.convert_xml.convert_xml() with invalid input"""
         xml = parse_xml('<s><w ARPABET="V AA L IY D">valid</w></s>')
-        c_xml, valid = convert_xml(xml)
+        c_xml, valid, _ = convert_xml(xml)
         self.assertEqual(
             etree.tounicode(c_xml), '<s><w ARPABET="V AA L IY D">valid</w></s>'
         )
         self.assertTrue(valid, "convert_xml with valid pre-g2p'd text")
 
         xml = parse_xml('<s><w ARPABET="invalid">invalid</w></s>')
         with redirect_stderr(StringIO()):
-            c_xml, valid = convert_xml(xml)
+            c_xml, valid, _ = convert_xml(xml)
         self.assertEqual(
             etree.tounicode(c_xml), '<s><w ARPABET="invalid">invalid</w></s>'
         )
@@ -473,13 +473,20 @@ def test_invalid_langs_in_xml(self):
         """
         )
         with self.assertLogs(LOGGER, level="WARNING") as cm:
-            c_xml, valid = convert_xml(xml, verbose_warnings=True)
+            c_xml, valid, _ = convert_xml(xml, verbose_warnings=True)
         self.assertFalse(valid)
         logger_output = "\n".join(cm.output)
         self.assertIn("No lang", logger_output)
         self.assertIn("foo", logger_output)
         self.assertIn('no path from "crx-syl"', logger_output)
 
+    def test_non_convertible_words(self):
+        xml = parse_xml("<s><w>43:23</w><w>65:67</w><w>43:23</w></s>")
+        with self.assertLogs(LOGGER, level="WARNING"):
+            g2p_xml, valid, non_convertible_words = convert_xml(xml)
+        self.assertFalse(valid)
+        self.assertEqual(non_convertible_words, ["43:23", "65:67"])
+
 
 if __name__ == "__main__":
     main()

test/test_web_api.py

@@ -105,7 +105,7 @@ def test_create_grammar(self):
         with redirect_stderr(StringIO()):
             tokenized = tokenize_xml(parsed)
         ids_added = add_ids(tokenized)
-        g2ped, valid = convert_xml(ids_added)
+        g2ped, valid, _ = convert_xml(ids_added)
 
         word_dict, text = create_grammar(g2ped)
         self.assertTrue(valid)
@@ -159,11 +159,11 @@ def test_convert_time_limit(self):
                 ids_added, time_limit=1.001, start_time=perf_counter() - 1.0
             )
         # Lots of time, should not raise
-        _, valid = convert_xml(
+        _, valid, _ = convert_xml(
             ids_added, time_limit=100, start_time=perf_counter() - 1.0
         )
         self.assertTrue(valid)
-        _, valid = convert_xml(ids_added, time_limit=100)
+        _, valid, _ = convert_xml(ids_added, time_limit=100)
         self.assertTrue(valid)
 
     def test_bad_g2p(self):
@@ -189,7 +189,7 @@ def test_g2p_faiture(self):
             response = self.API_CLIENT.post("/api/v1/assemble", json=request)
         self.assertEqual(response.status_code, 422)
         content = response.json()
-        self.assertIn("No valid g2p conversion", content["detail"])
+        self.assertIn("These words could not", content["detail"])
 
     def test_no_words(self):
         # Test the assemble endpoint with no actual words in the text
@@ -216,7 +216,7 @@ def test_empty_g2p(self):
             response = self.API_CLIENT.post("/api/v1/assemble", json=request)
         self.assertEqual(response.status_code, 422)
         content_log = response.json()["detail"]
-        for message_part in ["The output of the g2p process", "24", "23", "is empty"]:
+        for message_part in ["These words could not", "24", "23"]:
             self.assertIn(message_part, content_log)
 
     def test_langs(self):