test: refactor test_lambdaSpeechToScore.py to test all fields

aip_trainer/lambdas/lambdaSpeechToScore.py

@@ -22,12 +22,13 @@ transform = Resample(orig_freq=sample_rate_start, new_freq=16000)
 
 
 def lambda_handler(event, context):
-    data = json.loads(event['body'])
+    body = event['body']
+    data = json.loads(body)
 
     real_text = data['title']
-    base64Audio = data["base64Audio"]
-    app_logger.debug(f"base64Audio:{base64Audio} ...")
-    file_bytes_or_audiotmpfile = base64.b64decode(base64Audio[22:].encode('utf-8'))
+    base64_audio = data["base64Audio"]
+    app_logger.debug(f"base64Audio:{base64_audio} ...")
+    file_bytes_or_audiotmpfile = base64.b64decode(base64_audio[22:].encode('utf-8'))
     language = data['language']
 
     if len(real_text) == 0:

tests/events/example.json

@@ -0,0 +1,18 @@
+{
+    "key": "value",
+    "example": {
+        "body": {
+            "real_transcript": "hi how are you",
+            "ipa_transcript": "ha\u026a ha\u028a \u0259r ju",
+            "pronunciation_accuracy": 69.0,
+            "real_transcripts": "Hi there, how are you?",
+            "matched_transcripts": "hi - how are you",
+            "real_transcripts_ipa": "ha\u026a \u00f0\u025br, ha\u028a \u0259r ju?",
+            "matched_transcripts_ipa": "ha\u026a  ha\u028a \u0259r ju",
+            "pair_accuracy_category": "0 2 0 0 0",
+            "start_time": "0.2245625 1.3228125 0.852125 1.04825 1.3228125",
+            "end_time": "0.559875 1.658125 1.14825 1.344375 1.658125",
+            "is_letter_correct_all_words": "11 000001 111 111 1111 "
+        }
+    }
+}

tests/events/get_speech_to_score_dict_en.json

@@ -0,0 +1 @@
+{"real_transcript": "hi how are you", "ipa_transcript": "ha\u026a ha\u028a \u0259r ju", "pronunciation_accuracy": 69.0, "real_transcripts": "Hi there, how are you?", "matched_transcripts": "hi - how are you", "real_transcripts_ipa": "ha\u026a \u00f0\u025br, ha\u028a \u0259r ju?", "matched_transcripts_ipa": "ha\u026a  ha\u028a \u0259r ju", "pair_accuracy_category": "0 2 0 0 0", "start_time": "0.2245625 1.3228125 0.852125 1.04825 1.3228125", "end_time": "0.559875 1.658125 1.14825 1.344375 1.658125", "is_letter_correct_all_words": "11 000001 111 111 1111 "}

tests/lambdas/test_lambdaSpeechToScore.py

@@ -9,56 +9,219 @@ from aip_trainer.lambdas import lambdaSpeechToScore
 from tests import EVENTS_FOLDER
 
 
-text_dict = {
-    "de": "Ich bin Alex, wer bist du?",
-    "de1": "Hallo, wie geht es dir?",
-    "en": "Hi there, how are you?",
+text_dict = {"de": "Hallo, wie geht es dir?", "en": "Hi there, how are you?"}
+expected_get_speech_to_score = {
+    "de": {
+        "real_transcript": "ich bin alexwe beste du",
+        "ipa_transcript": "ɪç biːn aːlɛksvɛː bɛstɛː duː",
+        "pronunciation_accuracy": 18.0,
+        "real_transcripts": "Hallo, wie geht es dir?",
+        "matched_transcripts": "ich bin beste - du",
+        "real_transcripts_ipa": "haloː, viː ɡeːt ɛːs diːr?",
+        "matched_transcripts_ipa": "ɪç biːn bəstə - duː",
+        "pair_accuracy_category": "2 2 2 2 2",
+        "start_time": "0.0 0.3075 1.5785625 2.1346875 2.1346875",
+        "end_time": "0.328 0.6458125 2.15525 2.4730625 2.4730625",
+        "is_letter_correct_all_words": "100001 010 0101 00 1001 ",
+    },
+    "en": {
+        "real_transcript": "hi how are you",
+        "ipa_transcript": "haɪ haʊ ər ju",
+        "pronunciation_accuracy": 69.0,
+        "real_transcripts": "Hi there, how are you?",
+        "matched_transcripts": "hi - how are you",
+        "real_transcripts_ipa": "haɪ ðɛr, haʊ ər ju?",
+        "matched_transcripts_ipa": "haɪ  haʊ ər ju",
+        "pair_accuracy_category": "0 2 0 0 0",
+        "start_time": "0.2245625 1.3228125 0.852125 1.04825 1.3228125",
+        "end_time": "0.559875 1.658125 1.14825 1.344375 1.658125",
+        "is_letter_correct_all_words": "11 000001 111 111 1111 ",
+    },
 }
-expected_output = {
+expected_with_audio_files_splitted_list = {
     "de": {
-        "real_transcript": text_dict["de"],
-        "ipa_transcript": "\u026a\u00e7 bi\u02d0n a\u02d0l\u025bksv\u025b\u02d0 b\u025bst\u025b\u02d0 du\u02d0",
-        "pronunciation_accuracy": 63.0,
-        "real_transcripts": text_dict["de"],
-        "matched_transcripts": "ich bin alexwe - beste du",
-        "real_transcripts_ipa": "\u026a\u00e7 bi\u02d0n a\u02d0l\u025bks, v\u0250 b\u026ast du\u02d0?",
-        "matched_transcripts_ipa": "\u026a\u00e7 bi\u02d0n a\u02d0l\u025bksv\u0259 - b\u0259st\u0259 du\u02d0",
-        "pair_accuracy_category": "0 0 2 2 2 0",
-        "start_time": "0.0 0.3075 0.62525 2.1346875 1.5785625 2.1346875",
-        "end_time": "0.328 0.6458125 1.44025 2.4730625 2.15525 2.4730625",
-        "is_letter_correct_all_words": "111 111 11111 000 1011 111 ",
+        "audio_files": [
+            f"{EVENTS_FOLDER}/test_de__part0_start0.0_end0.328..wav",
+            f"{EVENTS_FOLDER}/test_de__part1_start0.3075_end0.6458125..wav",
+            f"{EVENTS_FOLDER}/test_de__part2_start1.5785625_end2.15525..wav",
+            f"{EVENTS_FOLDER}/test_de__part3_start2.1346875_end2.4730625..wav",
+            f"{EVENTS_FOLDER}/test_de__part4_start2.1346875_end2.4730625..wav",
+        ],
+        "audio_durations": [
+            0.328,
+            0.3383125,
+            0.5766875,
+            0.3383750000000001,
+            0.3383750000000001,
+        ],
+        "real_transcript": "ich bin alexwe beste du",
+        "ipa_transcript": "ɪç biːn aːlɛksvɛː bɛstɛː duː",
+        "pronunciation_accuracy": 18.0,
+        "real_transcripts": "Hallo, wie geht es dir?",
+        "matched_transcripts": "ich bin beste - du",
+        "real_transcripts_ipa": "haloː, viː ɡeːt ɛːs diːr?",
+        "matched_transcripts_ipa": "ɪç biːn bəstə - duː",
+        "pair_accuracy_category": "2 2 2 2 2",
+        "start_time": "0.0 0.3075 1.5785625 2.1346875 2.1346875",
+        "end_time": "0.328 0.6458125 2.15525 2.4730625 2.4730625",
+        "is_letter_correct_all_words": "100001 010 0101 00 1001 ",
     },
     "en": {
-        "real_transcript": text_dict["en"],
-        "ipa_transcript": "ha\u026a ha\u028a \u0259r ju",
+        "audio_files": [
+            f"{EVENTS_FOLDER}/test_en__part0_start0.2245625_end0.559875..wav",
+            f"{EVENTS_FOLDER}/test_en__part1_start1.3228125_end1.658125..wav",
+            f"{EVENTS_FOLDER}/test_en__part2_start0.852125_end1.14825..wav",
+            f"{EVENTS_FOLDER}/test_en__part3_start1.04825_end1.344375..wav",
+            f"{EVENTS_FOLDER}/test_en__part4_start1.3228125_end1.658125..wav",
+        ],
+        "audio_durations": [
+            0.3353125,
+            0.3353125000000001,
+            0.29612499999999997,
+            0.2961250000000002,
+            0.3353125000000001,
+        ],
+        "real_transcript": "hi how are you",
+        "ipa_transcript": "haɪ haʊ ər ju",
         "pronunciation_accuracy": 69.0,
-        "real_transcripts": text_dict["en"],
+        "real_transcripts": "Hi there, how are you?",
         "matched_transcripts": "hi - how are you",
-        "real_transcripts_ipa": "ha\u026a \u00f0\u025br, ha\u028a \u0259r ju?",
-        "matched_transcripts_ipa": "ha\u026a  ha\u028a \u0259r ju",
+        "real_transcripts_ipa": "haɪ ðɛr, haʊ ər ju?",
+        "matched_transcripts_ipa": "haɪ  haʊ ��r ju",
         "pair_accuracy_category": "0 2 0 0 0",
         "start_time": "0.2245625 1.3228125 0.852125 1.04825 1.3228125",
         "end_time": "0.559875 1.658125 1.14825 1.344375 1.658125",
         "is_letter_correct_all_words": "11 000001 111 111 1111 ",
     },
 }
+expected_with_selected_word_valid_index = {
+    "de": {
+        "audio_files": [
+            f"{EVENTS_FOLDER}/test_de_easy__part0_start0.0_end0.4733125..wav",
+            f"{EVENTS_FOLDER}/test_de_easy__part1_start0.3733125_end0.70425..wav",
+            f"{EVENTS_FOLDER}/test_de_easy__part2_start0.60425_end0.8966875..wav",
+            f"{EVENTS_FOLDER}/test_de_easy__part3_start0.7966875_end1.089125..wav",
+            f"{EVENTS_FOLDER}/test_de_easy__part4_start0.989125_end1.3200625..wav",
+        ],
+        "audio_durations": [
+            0.4733125,
+            0.33093750000000005,
+            0.2924375,
+            0.2924374999999999,
+            0.3309374999999999,
+        ],
+        "real_transcript": "hallo wie geht es dir",
+        "ipa_transcript": "haloː viː ɡeːt ɛːs diːɐ̯",
+        "pronunciation_accuracy": 100.0,
+        "real_transcripts": "Hallo, wie geht es dir?",
+        "matched_transcripts": "hallo wie geht es dir",
+        "real_transcripts_ipa": "haloː, viː ɡeːt ɛːs diːr?",
+        "matched_transcripts_ipa": "haloː viː ɡeːt ɛːs diːɐ̯",
+        "pair_accuracy_category": "0 0 0 0 0",
+        "start_time": "0.0 0.3733125 0.60425 0.7966875 0.989125",
+        "end_time": "0.4733125 0.70425 0.8966875 1.089125 1.3200625",
+        "is_letter_correct_all_words": "111111 111 1111 11 1111 ",
+    },
+    "en": {
+        "audio_files": [
+            f"{EVENTS_FOLDER}/test_en_easy__part0_start0.0_end0.1625..wav",
+            f"{EVENTS_FOLDER}/test_en_easy__part1_start0.0625_end0.3875..wav",
+            f"{EVENTS_FOLDER}/test_en_easy__part2_start0.2875_end0.575..wav",
+            f"{EVENTS_FOLDER}/test_en_easy__part3_start0.475_end0.8..wav",
+            f"{EVENTS_FOLDER}/test_en_easy__part4_start0.7_end0.9875..wav",
+        ],
+        "audio_durations": [
+            0.1625,
+            0.325,
+            0.2875,
+            0.32500000000000007,
+            0.2875000000000001,
+        ],
+        "real_transcript": "i there how are you",
+        "ipa_transcript": "aɪ ðɛr haʊ ər ju",
+        "pronunciation_accuracy": 94.0,
+        "real_transcripts": "Hi there, how are you?",
+        "matched_transcripts": "i there how are you",
+        "real_transcripts_ipa": "haɪ ðɛr, haʊ ər ju?",
+        "matched_transcripts_ipa": "aɪ ðɛr haʊ ər ju",
+        "pair_accuracy_category": "2 0 0 0 0",
+        "start_time": "0.0 0.0625 0.2875 0.475 0.7",
+        "end_time": "0.1625 0.3875 0.575 0.8 0.9875",
+        "is_letter_correct_all_words": "01 111111 111 111 1111 ",
+    },
+}
+expected_get_accuracy_lambda = {
+    "de": {
+        "real_transcript": "ich bin om werbst du wille freude wo no wie essen",
+        "ipa_transcript": "ɪç biːn oːm vɛːrbst duː vɪlɛː frɔɪ̯dɛː voː noː viː ɛzɛːn",
+        "pronunciation_accuracy": 62.0,
+        "real_transcripts": "Ich bin Tom, wer bist du? Viel Freude. Wollen wir essen?",
+        "matched_transcripts": "ich bin om - - du wille freude wo wie essen",
+        "real_transcripts_ipa": "ɪç biːn toːm, vɐ bɪst duː? fiːl frɔɪ̯dɛː. vɔln̩ viːɐ̯ ɛzɛːn?",
+        "matched_transcripts_ipa": "ɪç biːn oːm - - duː vɪlə frɔɪ̯də voː viː ɛzɛːn",
+        "pair_accuracy_category": "0 0 1 2 2 0 2 0 2 1 0",
+        "start_time": "0.625875 0.8644375 1.3415625 5.7945625 5.7945625 2.772875 3.4885 3.886125 4.919875 5.51625 5.7945625",
+        "end_time": "0.9644375 1.203 1.6800625 6.371625 6.371625 3.1114375 3.986125 4.46325 5.258375 5.815 6.371625",
+        "is_letter_correct_all_words": "111 111 0111 000 0000 111 0101 1111111 110000 110 111111 ",
+    },
+    "en": {
+        "real_transcript": "tom weing as someone else ca",
+        "ipa_transcript": "tɑm weing ɛz ˈsəmˌwən ɛls ˈsiˈeɪ",
+        "pronunciation_accuracy": 75.0,
+        "real_transcripts": "Tom is wearing someone else's coat.",
+        "matched_transcripts": "tom - weing someone else ca",
+        "real_transcripts_ipa": "tɑm ɪz ˈwɛrɪŋ ˈsəmˌwən ˈɛlsɪz koʊt.",
+        "matched_transcripts_ipa": "tɑm  weing ˈsəmˌwən ɛls ˈsiˈeɪ",
+        "pair_accuracy_category": "0 2 0 0 0 2",
+        "start_time": "1.4094375 3.4605 2.0405 2.671625 3.0660625 3.4605",
+        "end_time": "1.903875 3.7971875 2.5744375 3.1660625 3.5605 3.7971875",
+        "is_letter_correct_all_words": "111 00 1100111 1111111 111110 10101 ",
+    },
+}
+
+
+def set_seed(seed=0):
+    import random
+    import torch
+    import numpy as np
 
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
 
-def assert_raises_get_speech_to_score_dict(self, real_text, file_bytes_or_audiotmpfile, language, exc, error_message):
+
+def get_request_body(language, text, base64_audio=None):
+    body = json.dumps(
+        {
+            "language": language,
+            "title": text,
+            "base64Audio": f"data:audio/ogg;;base64,{base64_audio}",
+        }
+    )
+    return {"body": body}
+
+
+def assert_raises_get_speech_to_score_dict(
+    cls, real_text, file_bytes_or_audiotmpfile, language, exc, error_message
+):
     from aip_trainer.lambdas import lambdaSpeechToScore
 
-    with self.assertRaises(exc):
+    with cls.assertRaises(exc):
         try:
             lambdaSpeechToScore.get_speech_to_score_dict(
-                real_text, file_bytes_or_audiotmpfile, language, remove_random_file=False
+                real_text,
+                file_bytes_or_audiotmpfile,
+                language,
+                remove_random_file=False,
             )
         except exc as e:
-            self.assertEqual(str(e), error_message)
+            cls.assertEqual(str(e), error_message)
             raise e
 
 
 def check_value_by_field(value, match):
     import re
+
     assert len(value.strip()) > 0
     for word in value.lstrip().rstrip().split(" "):
         word_check = re.findall(match, word.strip())
@@ -73,32 +236,12 @@ def check_output_by_field(output, key, match, expected_output):
     return output
 
 
-def check_output(self, output, expected_output, check_audio_files=False):
+def check_output(cls, output, expected_output, check_audio_files=False):
     from pathlib import Path
-    self.maxDiff = None
+
+    cls.maxDiff = None
     try:
-        assert len(output["matched_transcripts"].strip()) > 0
-        assert len(output["matched_transcripts_ipa"].strip()) > 0
-        assert len(output["ipa_transcript"].strip()) > 0
-        assert len(output["real_transcripts_ipa"].strip()) > 0
-        output = check_output_by_field(
-            output, "is_letter_correct_all_words", "[01]+", expected_output
-        )
-        match_numbers = "\\d+\\.\\d+"
-        output = check_output_by_field(output, "end_time", match_numbers, expected_output)
-        output = check_output_by_field(
-            output, "start_time", match_numbers, expected_output
-        )
-        pronunciation_accuracy = output["pronunciation_accuracy"]
-        assert isinstance(pronunciation_accuracy, float)
-        assert pronunciation_accuracy <= 100
-        output["matched_transcripts"] = expected_output["matched_transcripts"]
-        output["matched_transcripts_ipa"] = expected_output["matched_transcripts_ipa"]
-        output["pronunciation_accuracy"] = expected_output["pronunciation_accuracy"]
-        output["pair_accuracy_category"] = expected_output["pair_accuracy_category"]
-        output["ipa_transcript"] = expected_output["ipa_transcript"]
-        output["real_transcript"] = expected_output["real_transcript"]
-        output["real_transcripts_ipa"] = expected_output["real_transcripts_ipa"]
+        cls.assertDictEqual(output, expected_output)
         if check_audio_files:
             audio_files = output["audio_files"]
             audio_durations = output["audio_durations"]
@@ -110,21 +253,115 @@ def check_output(self, output, expected_output, check_audio_files=False):
                 app_logger.info(f"path_audio_file:{path_audio_file}.")
                 assert path_audio_file.is_file()
                 path_audio_file.unlink()
-        
-            output["audio_files"] = [*audio_files]
-            expected_output["audio_files"] = [*audio_files]
-            n_durations = len(output["audio_durations"])
-            audio_durations = [x/4 + 0.5 for x in range(n_durations)]
-            output["audio_durations"] = [*audio_durations]
-            expected_output["audio_durations"] = [*audio_durations]
-            app_logger.info(f"output audio_files:{output['audio_files']}.")
-            app_logger.info(f"expected_output audio_files:{expected_output['audio_files']}.")
-        self.assertDictEqual(output, expected_output)
     except Exception as e:
         app_logger.error(f"e:{e}.")
         raise e
 
 
+def assert_get_speech_to_score_ok(cls, language, expected):
+    from aip_trainer.lambdas import lambdaSpeechToScore
+
+    set_seed()
+    path = EVENTS_FOLDER / f"test_{language}.wav"
+    output = lambdaSpeechToScore.get_speech_to_score_dict(
+        real_text=text_dict[language],
+        file_bytes_or_audiotmpfile=str(path),
+        language=language,
+        remove_random_file=False,
+    )
+    cls.assertDictEqual(output, expected)
+
+
+def assert_get_speech_to_score_ok_remove_input_file(cls, language, expected):
+    import shutil
+    from aip_trainer.lambdas import lambdaSpeechToScore
+
+    set_seed()
+    path = EVENTS_FOLDER / f"test_{language}.wav"
+    path2 = EVENTS_FOLDER / f"test2_{language}.wav"
+    shutil.copy(path, path2)
+    assert path2.exists() and path2.is_file()
+    output = lambdaSpeechToScore.get_speech_to_score_dict(
+        real_text=text_dict[language],
+        file_bytes_or_audiotmpfile=str(path2),
+        language=language,
+        remove_random_file=True,
+    )
+    assert not path2.exists()
+    cls.assertDictEqual(output, expected)
+
+
+def assert_get_speech_to_score_tuple_ok(cls, language, expected, expected_num_words):
+    from aip_trainer.lambdas import lambdaSpeechToScore
+
+    set_seed()
+    path = EVENTS_FOLDER / f"test_{language}.wav"
+    (
+        real_transcripts,
+        is_letter_correct_all_words,
+        pronunciation_accuracy,
+        ipa_transcript,
+        real_transcripts_ipa,
+        num_words,
+        first_audio_file,
+        dumped,
+    ) = lambdaSpeechToScore.get_speech_to_score_tuple(
+        real_text=text_dict[language],
+        file_bytes_or_audiotmpfile=str(path),
+        language=language,
+        remove_random_file=False,
+    )
+    assert real_transcripts == text_dict[language]
+    expected_output = expected[language]
+    assert is_letter_correct_all_words.strip() == expected_output["is_letter_correct_all_words"].strip()
+    assert pronunciation_accuracy == expected_output["pronunciation_accuracy"]
+    assert ipa_transcript.strip() == expected_output["ipa_transcript"].strip()
+    assert real_transcripts_ipa.strip() == expected_output["real_transcripts_ipa"]
+    assert num_words == expected_num_words
+    first_audio_file_path = Path(first_audio_file)
+    assert first_audio_file_path.exists() and first_audio_file_path.is_file()
+    json_loaded = json.loads(dumped)
+    check_output(cls, json_loaded, expected_output, check_audio_files=True)
+
+
+def assert_get_selected_word_valid_index_ok(language, expected):
+    set_seed()
+    path = EVENTS_FOLDER / f"test_{language}_easy.wav"
+    input_text = text_dict[language]
+    _, _, _, _, _, _, _, output_json = lambdaSpeechToScore.get_speech_to_score_tuple(
+        input_text, str(path), language, False
+    )
+    idx_recorded_word = 2
+    output_loaded = json.loads(output_json)
+    audio_file, word, duration = lambdaSpeechToScore.get_selected_word(
+        idx_recorded_word, output_json
+    )
+    audio_file_path = Path(audio_file)
+    assert audio_file_path.exists() and audio_file_path.is_file()
+    expected_end_time_list = expected[language]["audio_durations"]
+    expected_end_time = expected_end_time_list[idx_recorded_word]
+    assert duration == expected_end_time
+    words_list = text_dict[language].split()
+    assert word == words_list[idx_recorded_word]
+    for file_to_del in output_loaded["audio_files"]:
+        Path(file_to_del).unlink()
+
+
+def assert_get_selected_word_invalid_index(cls, language):
+    set_seed()
+    path = EVENTS_FOLDER / f"test_{language}_easy.wav"
+    _, _, _, _, _, _, _, output_json = lambdaSpeechToScore.get_speech_to_score_tuple(
+        text_dict[language], str(path), language, False
+    )
+    with cls.assertRaises(IndexError):
+        try:
+            lambdaSpeechToScore.get_selected_word(120, output_json)
+        except IndexError as ie:
+            msg = str(ie)
+            assert msg == "list index out of range"
+            raise ie
+
+
 class TestGetAccuracyFromRecordedAudio(unittest.TestCase):
     def setUp(self):
         if platform.system() == "Windows" or platform.system() == "Win32":
@@ -137,18 +374,19 @@ class TestGetAccuracyFromRecordedAudio(unittest.TestCase):
             del os.environ["PYTHONUTF8"]
 
     def test_GetAccuracyFromRecordedAudio(self):
+        set_seed()
         with open(EVENTS_FOLDER / "GetAccuracyFromRecordedAudio.json", "r") as src:
             inputs_outputs = json.load(src)
         inputs = inputs_outputs["inputs"]
-        outputs = inputs_outputs["outputs"]
-        for event_name, event_content in inputs.items():
-            current_expected_output = outputs[event_name]
+        for language, event_content in inputs.items():
+            current_expected_output = expected_get_accuracy_lambda[language]
             output = lambdaSpeechToScore.lambda_handler(event_content, [])
             output = json.loads(output)
+            expected_get_accuracy_lambda[language] = output
             app_logger.info(
                 f"output type:{type(output)}, expected_output type:{type(current_expected_output)}."
             )
-            check_output(self, output, current_expected_output)
+            self.assertDictEqual(output, current_expected_output)
 
     def test_lambda_handler_empty_text(self):
         from aip_trainer.lambdas import lambdaSpeechToScore
@@ -177,233 +415,119 @@ class TestGetAccuracyFromRecordedAudio(unittest.TestCase):
         )
 
     def test_get_speech_to_score_en_ok(self):
-        from aip_trainer.lambdas import lambdaSpeechToScore
-
-        language = "en"
-        path = EVENTS_FOLDER / f"test_{language}.wav"
-        output = lambdaSpeechToScore.get_speech_to_score_dict(
-            real_text=text_dict[language],
-            file_bytes_or_audiotmpfile=str(path),
-            language=language,
-            remove_random_file=False,
-        )
-        check_output(self, output, expected_output[language])
-
-    def test_get_speech_to_score_en_ok_remove_input_file(self):
-        import shutil
-        from aip_trainer.lambdas import lambdaSpeechToScore
-
-        language = "en"
-        path = EVENTS_FOLDER / f"test_{language}.wav"
-        path2 = EVENTS_FOLDER / f"test2_{language}.wav"
-        shutil.copy(path, path2)
-        assert path2.exists() and path2.is_file()
-        output = lambdaSpeechToScore.get_speech_to_score_dict(
-            real_text=text_dict[language],
-            file_bytes_or_audiotmpfile=str(path2),
-            language=language,
-            remove_random_file=True,
-        )
-        assert not path2.exists()
-        check_output(self, output, expected_output[language])
+        assert_get_speech_to_score_ok(self, "en", expected_get_speech_to_score["en"])
 
     def test_get_speech_to_score_de_ok(self):
-        from aip_trainer.lambdas import lambdaSpeechToScore
+        assert_get_speech_to_score_ok(self, "de", expected_get_speech_to_score["de"])
 
-        language = "de"
-        path = EVENTS_FOLDER / f"test_{language}.wav"
-        output = lambdaSpeechToScore.get_speech_to_score_dict(
-            real_text=text_dict[language],
-            file_bytes_or_audiotmpfile=str(path),
-            language=language,
-            remove_random_file=False,
+    def test_get_speech_to_score_en_ok_remove_input_file(self):
+        assert_get_speech_to_score_ok_remove_input_file(
+            self, "en", expected_get_speech_to_score["en"]
         )
-        check_output(self, output, expected_output[language])
 
     def test_get_speech_to_score_de_ok_remove_input_file(self):
-        import shutil
-        from aip_trainer.lambdas import lambdaSpeechToScore
-
-        language = "de"
-        path = EVENTS_FOLDER / f"test_{language}.wav"
-        path2 = EVENTS_FOLDER / f"test2_{language}.wav"
-        shutil.copy(path, path2)
-        assert path2.exists() and path2.is_file()
-        output = lambdaSpeechToScore.get_speech_to_score_dict(
-            real_text=text_dict[language],
-            file_bytes_or_audiotmpfile=str(path2),
-            language=language,
-            remove_random_file=True,
+        assert_get_speech_to_score_ok_remove_input_file(
+            self, "de", expected_get_speech_to_score["de"]
         )
-        assert not path2.exists()
-        check_output(self, output, expected_output[language])
 
     def test_get_speech_to_score_tuple_de_ok(self):
-        from aip_trainer.lambdas import lambdaSpeechToScore
-
-        language = "de"
-        path = EVENTS_FOLDER / f"test_{language}.wav"
-        (
-            real_transcripts,
-            is_letter_correct_all_words,
-            pronunciation_accuracy,
-            ipa_transcript,
-            real_transcripts_ipa,
-            num_words,
-            first_audio_file,
-            dumped,
-        ) = lambdaSpeechToScore.get_speech_to_score_tuple(
-            real_text=text_dict[language],
-            file_bytes_or_audiotmpfile=str(path),
-            language=language,
-            remove_random_file=False,
+        assert_get_speech_to_score_tuple_ok(
+            self, "de", expected_with_audio_files_splitted_list, expected_num_words=5
         )
-        assert real_transcripts == text_dict[language]
-        check_value_by_field(is_letter_correct_all_words, "[01]+")
-        assert isinstance(pronunciation_accuracy, float)
-        assert pronunciation_accuracy <= 100
-        assert len(ipa_transcript.strip()) > 0
-        assert len(real_transcripts_ipa.strip()) > 0
-        assert num_words == 6
-        first_audio_file_path = Path(first_audio_file)
-        assert first_audio_file_path.exists() and first_audio_file_path.is_file()
-        json_loaded = json.loads(dumped)
-        check_output(self, json_loaded, expected_output[language], check_audio_files=True)
 
     def test_get_speech_to_score_tuple_en_ok(self):
-        from aip_trainer.lambdas import lambdaSpeechToScore
-
-        language = "en"
-        path = EVENTS_FOLDER / f"test_{language}.wav"
-        (
-            real_transcripts,
-            is_letter_correct_all_words,
-            pronunciation_accuracy,
-            ipa_transcript,
-            real_transcripts_ipa,
-            num_words,
-            first_audio_file,
-            dumped,
-        ) = lambdaSpeechToScore.get_speech_to_score_tuple(
-            real_text=text_dict[language],
-            file_bytes_or_audiotmpfile=str(path),
-            language=language,
-            remove_random_file=False,
+        assert_get_speech_to_score_tuple_ok(
+            self, "en", expected_with_audio_files_splitted_list, expected_num_words=5
         )
-        assert real_transcripts == text_dict[language]
-        check_value_by_field(is_letter_correct_all_words, "[01]+")
-        assert isinstance(pronunciation_accuracy, float)
-        assert pronunciation_accuracy <= 100
-        assert len(ipa_transcript.strip()) > 0
-        assert len(real_transcripts_ipa.strip()) > 0
-        assert num_words == 5
-        first_audio_file_path = Path(first_audio_file)
-        assert first_audio_file_path.exists() and first_audio_file_path.is_file()
-        check_output(self, json.loads(dumped), expected_output[language], check_audio_files=True)
 
     def test_get_speech_to_score_dict__de_empty_input_text(self):
         language = "de"
         path = EVENTS_FOLDER / f"test_{language}.wav"
-        assert_raises_get_speech_to_score_dict(self, "", str(path), language, ValueError, "cannot read an empty/None text: ''...")
+        assert_raises_get_speech_to_score_dict(
+            self,
+            "",
+            str(path),
+            language,
+            ValueError,
+            "cannot read an empty/None text: ''...",
+        )
 
     def test_get_speech_to_score_dict__en_empty_input_text(self):
         language = "en"
         path = EVENTS_FOLDER / f"test_{language}.wav"
-        assert_raises_get_speech_to_score_dict(self, "", str(path), language, ValueError, "cannot read an empty/None text: ''...")
+        assert_raises_get_speech_to_score_dict(
+            self,
+            "",
+            str(path),
+            language,
+            ValueError,
+            "cannot read an empty/None text: ''...",
+        )
 
     def test_get_speech_to_score_dict__de_empty_input_file(self):
         language = "de"
-        assert_raises_get_speech_to_score_dict(self, "text fake", "", language, OSError, "cannot read an empty/None file: ''...")
+        assert_raises_get_speech_to_score_dict(
+            self,
+            "text fake",
+            "",
+            language,
+            OSError,
+            "cannot read an empty/None file: ''...",
+        )
 
     def test_get_speech_to_score_dict__en_empty_input_file(self):
         language = "en"
-        assert_raises_get_speech_to_score_dict(self, "text fake", "", language, OSError, "cannot read an empty/None file: ''...")
-    
+        assert_raises_get_speech_to_score_dict(
+            self,
+            "text fake",
+            "",
+            language,
+            OSError,
+            "cannot read an empty/None file: ''...",
+        )
+
     def test_get_speech_to_score_dict__empty_language(self):
-        assert_raises_get_speech_to_score_dict(self, "text fake", "fake_file", "", NotImplementedError, "Not tested/supported with '' language...")
-    
+        assert_raises_get_speech_to_score_dict(
+            self,
+            "text fake",
+            "fake_file",
+            "",
+            NotImplementedError,
+            "Not tested/supported with '' language...",
+        )
+
     def test_get_speech_to_score_dict__empty_language(self):
         language = "en"
         path_file = str(EVENTS_FOLDER / "empty_file.wav")
-        assert_raises_get_speech_to_score_dict(self, "text fake", path_file, language, OSError, f"cannot read an empty file: '{path_file}'...")
+        assert_raises_get_speech_to_score_dict(
+            self,
+            "text fake",
+            path_file,
+            language,
+            OSError,
+            f"cannot read an empty file: '{path_file}'...",
+        )
 
     def test_get_selected_word_valid_index_de_ok(self):
-        language = "de"
-        path = EVENTS_FOLDER / f"test_{language}_easy.wav"
-        input_text = text_dict["de1"]
-        _, _, _, _, _, _, _, output_json = lambdaSpeechToScore.get_speech_to_score_tuple(
-            input_text,
-            str(path), language,
-            False
+        assert_get_selected_word_valid_index_ok(
+            "de", expected_with_selected_word_valid_index
         )
-        idx_recorded_word = 2
-        output_loaded = json.loads(output_json)
-        audio_file, word, duration = lambdaSpeechToScore.get_selected_word(idx_recorded_word, output_json)
-        audio_file_path = Path(audio_file)
-        assert audio_file_path.exists() and audio_file_path.is_file()
-        assert duration > 0
-        words_list = text_dict["de1"].split()
-        assert word == words_list[idx_recorded_word]
-        for file_to_del in output_loaded["audio_files"]:
-            Path(file_to_del).unlink()
 
     def test_get_selected_word_valid_index_en_ok(self):
-        language = "en"
-        path = EVENTS_FOLDER / f"test_{language}_easy.wav"
-        _, _, _, _, _, _, _, output_json = lambdaSpeechToScore.get_speech_to_score_tuple(
-            text_dict[language],
-            str(path), language,
-            False
+        assert_get_selected_word_valid_index_ok(
+            "en", expected_with_selected_word_valid_index
         )
-        idx_recorded_word = 2
-        output_loaded = json.loads(output_json)
-        audio_file, word, duration = lambdaSpeechToScore.get_selected_word(idx_recorded_word, output_json)
-        audio_file_path = Path(audio_file)
-        assert audio_file_path.exists() and audio_file_path.is_file()
-        assert duration > 0
-        words_list = text_dict[language].split()
-        assert word == words_list[idx_recorded_word]
-        for file_to_del in output_loaded["audio_files"]:
-            Path(file_to_del).unlink()
 
     def test_get_selected_word_invalid_index_de(self):
-        language = "de"
-        path = EVENTS_FOLDER / f"test_{language}_easy.wav"
-        _, _, _, _, _, _, _, output_json = lambdaSpeechToScore.get_speech_to_score_tuple(
-            text_dict["de1"],
-            str(path), language,
-            False
-        )
-        with self.assertRaises(IndexError):
-            try:
-                lambdaSpeechToScore.get_selected_word(120, output_json)
-            except IndexError as ie:
-                msg = str(ie)
-                assert msg == 'list index out of range'
-                raise ie
+        assert_get_selected_word_invalid_index(self, "de")
 
     def test_get_selected_word_invalid_index_en(self):
-        language = "en"
-        path = EVENTS_FOLDER / f"test_{language}_easy.wav"
-        _, _, _, _, _, _, _, output_json = lambdaSpeechToScore.get_speech_to_score_tuple(
-            text_dict[language],
-            str(path), language,
-            False
-        )
-        with self.assertRaises(IndexError):
-            try:
-                lambdaSpeechToScore.get_selected_word(120, output_json)
-            except IndexError as ie:
-                msg = str(ie)
-                assert msg == 'list index out of range'
-                raise ie
+        assert_get_selected_word_invalid_index(self, "en")
 
     def test_get_selected_word_empty_transcripts(self):
-        raw_json_output = json.dumps({
-            "audio_files": [],
-            "real_transcripts": "",
-            "audio_durations": []
-        })
+        raw_json_output = json.dumps(
+            {"audio_files": [], "real_transcripts": "", "audio_durations": []}
+        )
         idx_recorded_word = 0
         with self.assertRaises(IndexError):
             lambdaSpeechToScore.get_selected_word(idx_recorded_word, raw_json_output)
@@ -413,11 +537,9 @@ class TestGetAccuracyFromRecordedAudio(unittest.TestCase):
         path = str(EVENTS_FOLDER / f"test_{language}.wav")
         start_time = [0.0, 1.0, 2.0]
         end_time = [1.0, 2.0, 2.5]
-        
+
         audio_files, audio_durations = lambdaSpeechToScore.get_splitted_audio_file(
-            audiotmpfile=path,
-            start_time=start_time,
-            end_time=end_time
+            audiotmpfile=path, start_time=start_time, end_time=end_time
         )
 
         assert len(audio_files) == len(start_time)
@@ -437,9 +559,7 @@ class TestGetAccuracyFromRecordedAudio(unittest.TestCase):
         with self.assertRaises(LibsndfileError):
             try:
                 lambdaSpeechToScore.get_splitted_audio_file(
-                    audiotmpfile="",
-                    start_time=start_time,
-                    end_time=end_time
+                    audiotmpfile="", start_time=start_time, end_time=end_time
                 )
             except LibsndfileError as lsfe:
                 msg = str(lsfe)
@@ -457,13 +577,11 @@ class TestGetAccuracyFromRecordedAudio(unittest.TestCase):
         with self.assertRaises(LibsndfileError):
             try:
                 lambdaSpeechToScore.get_splitted_audio_file(
-                    audiotmpfile=str(path),
-                    start_time=start_time,
-                    end_time=end_time
+                    audiotmpfile=str(path), start_time=start_time, end_time=end_time
                 )
             except LibsndfileError as lsfe:
                 msg = str(lsfe)
-                assert msg == 'Internal psf_fseek() failed.'
+                assert msg == "Internal psf_fseek() failed."
                 raise lsfe
 
 

tests/utils/test_utilities.py

@@ -40,9 +40,9 @@ class TestUtilities(unittest.TestCase):
         app_logger.info(f"output_hash test_en: {output_hash}")
         assert b'Dsvmm+mj/opHnmKLT7wIqyhqMLeIuVP4hTWi+DAXS8Y=' == output_hash
 
-        output_hash = hash_calculate(EVENTS_FOLDER / "GetAccuracyFromRecordedAudio.json", is_file=True)
+        output_hash = hash_calculate(EVENTS_FOLDER / "example.json", is_file=True)
         app_logger.info(f"output_hash json: {output_hash}")
-        assert b'i83jKpwzfcPitZsrHsnhyFt8xbc+DStpns9rb3vfigw=' == output_hash
+        assert b'aLGnsOa1Z3QmfilSPybdVcUHcjgd5ntOZh6mbQDEy2w=' == output_hash
 
 
 if __name__ == '__main__':