def test_select_importer_when_already_selected(tmpdir): """ Re-specify the importer will clear settings back to the default. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') ds.select_importer('Elan') ds.importer.context["tier"] = "Shift" ds.select_importer('Elan') assert ds.state == json.loads(f""" {{ "name": "dataset_x", "hash": "{ds.hash}", "date": "{ds.date}", "has_been_processed": false, "files": [], "processed_labels": [], "importer": {{ "name": "Elan", "context": {{ "tier": "Phrase", "graphic": "elan.png" }} }} }} """) return
def test_change_importer_setting(tmpdir): """ Change a property of the importer. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') ds.select_importer('Elan') ds.importer.context["tier"] = "Shift" assert ds.state == json.loads(f""" {{ "name": "dataset_x", "hash": "{ds.hash}", "date": "{ds.date}", "has_been_processed": false, "files": [], "processed_labels": [], "importer": {{ "name": "Elan", "context": {{ "tier": "Shift", "graphic": "elan.png" }} }} }} """) return
def test_new_dataset(tmpdir): """ Check the state of a dataset without adding any files, selecting an importer or processing. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') # Black-box property testing assert ds.files == [] assert ds.processed_labels == [] assert ds.importer is None assert ds.has_been_processed == False assert ds.state == json.loads(f""" {{ "name": "dataset_x", "hash": "{ds.hash}", "date": "{ds.date}", "has_been_processed": false, "files": [], "processed_labels": [], "importer": null }} """) # White-box testing, contains empty child directories "original" and # "resampled". path_to_original = Path(f'{tmpdir}/state/datasets/{ds.hash}/original') assert path_to_original.is_dir() assert [n for n in path_to_original.iterdir()] == [] path_to_resampled = Path(f'{tmpdir}/state/datasets/{ds.hash}/resampled') assert path_to_resampled.is_dir() assert [n for n in path_to_resampled.iterdir()] == [] return
def test_new_dataset_using_use_existing(tmpdir): """ Using the use_existing when an existing dataset does not exist is okay. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x', use_existing=True) # Black-box property testing assert ds.files == [] assert ds.processed_labels == [] assert ds.importer is None assert ds.has_been_processed == False assert ds.state == json.loads(f""" {{ "name": "dataset_x", "hash": "{ds.hash}", "date": "{ds.date}", "has_been_processed": false, "files": [], "processed_labels": [], "importer": null }} """) return
def test_construction(tmpdir): KaldiInterface(f'{tmpdir}/state') # White-box testing path_to_datasets = Path(f'{tmpdir}/state/datasets') path_to_pron_dicts = Path(f'{tmpdir}/state/pron_dicts') path_to_models = Path(f'{tmpdir}/state/models') path_to_transcriptions = Path(f'{tmpdir}/state/transcriptions') # Creates empty child directories: # datasets/ # pron_dicts/ # models/ # transcriptions/ assert path_to_datasets.is_dir() assert path_to_datasets.exists() assert [n for n in path_to_datasets.iterdir()] == [] assert path_to_pron_dicts.is_dir() assert path_to_pron_dicts.exists() assert [n for n in path_to_pron_dicts.iterdir()] == [] assert path_to_models.is_dir() assert path_to_models.exists() assert [n for n in path_to_models.iterdir()] == [] assert path_to_transcriptions.is_dir() assert path_to_transcriptions.exists() assert [n for n in path_to_transcriptions.iterdir()] == [] # TODO: much more testing here
def test_new_pron_dict_using_use_existing(tmpdir): """ Using the use_existing when an existing pron dict does not exist is okay. """ kaldi = KaldiInterface(f'{tmpdir}/state') kaldi.new_pron_dict('p', use_existing=True) return
def test_add_directory(tmpdir): """ Add all files in a directory and see the state change. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') ds.add_directory('/recordings/transcribed') assert set(ds.files) == { "1_1_1.wav", "1_1_1.eaf", "1_1_2.wav", "1_1_2.eaf", "1_1_3.wav", "1_1_3.eaf", "1_1_4.wav", "1_1_4.eaf" } assert set(ds.state['files']) == set( json.loads(f""" [ "1_1_1.wav", "1_1_1.eaf", "1_1_2.wav", "1_1_2.eaf", "1_1_3.wav", "1_1_3.eaf", "1_1_4.wav", "1_1_4.eaf" ] """)) return
def test_select_importer(tmpdir): """ Select an existing importer. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') ds.select_importer('Elan') assert ds.importer is not None assert ds.has_been_processed == False assert ds.state == json.loads(f""" {{ "name": "dataset_x", "hash": "{ds.hash}", "date": "{ds.date}", "has_been_processed": false, "files": [], "processed_labels": [], "importer": {{ "name": "Elan", "context": {{ "tier": "Phrase", "graphic": "elan.png" }} }} }} """) return
def test_new_transcription_using_use_existing(tmpdir): """ Using the use_existing when an existing transcription does not exist is okay. """ kaldi = KaldiInterface(f'{tmpdir}/state') kaldi.new_transcription('transcription_w', use_existing=True) return
def reset(): interface_path = Path('/elpis/state') shutil.rmtree(interface_path) app.config['INTERFACE'] = KaldiInterface(interface_path) app.config['CURRENT_DATASET'] = None # not okay for multi-user app.config['CURRENT_PRON_DICT'] = None # not okay for multi-user app.config['CURRENT_MODEL'] = None # not okay for multi-user return jsonify({"status": "ok", "message": "reset ok"})
def test_override_and_use_existing(tmpdir): """ Cannot have both the override and use_existing parameters set to True. """ kaldi = KaldiInterface(f'{tmpdir}/state') with pytest.raises(ValueError): kaldi.new_pron_dict('x', override=True, use_existing=True) return
def test_set_l2s_missing_path(tmpdir): """ If the path does not exist then get a missing file error. """ kaldi = KaldiInterface(f'{tmpdir}/state') pd = kaldi.new_pron_dict('pronunciation dictionary') with pytest.raises(FileNotFoundError): pd.set_l2s_path('/missing/letter_to_sound.txt') return
def test_process_empty_dataset(tmpdir): """ Attempting to process a dataset with no files will not produce an error. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') ds.select_importer('Elan') ds.process() return
def test_select_nonexistant_importer(tmpdir): """ The importer name must exist. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') with pytest.raises(ValueError): ds.select_importer('this_importer_name_does_not_exist') return
def test_change_setting_before_selecting_importer(tmpdir): """ If an attempt to change a setting of the importer is made, then an error will be raised. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') with pytest.raises(AttributeError): # importer is None ds.importer.context["tier"] = "Shift" return
def test_process_without_importer(tmpdir): """ Running the process() function without specifying an importer from the available data transformers will raise an error. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') with pytest.raises(RuntimeError): ds.process() return
def test_remove_file_that_does_not_exist(tmpdir): """ Raise an error when there is an attempt to remove a file that has not been added. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') with pytest.raises(ValueError): ds.remove_file("1_1_1.wav") return
def test_two_new_transcription_with_same_name(tmpdir): """ Trying to create two transcriptions with the same name without override or use_existing set to True will produce a ValueError. """ kaldi = KaldiInterface(f'{tmpdir}/state') kaldi.new_transcription('transcription_w') with pytest.raises(ValueError): kaldi.new_transcription('transcription_w') return
def test_lexicon_before_linking(tmpdir): """ Must link to a dataset before attempting to generate the lexicon, otherwise an error is produced. """ kaldi = KaldiInterface(f'{tmpdir}/state') pd = kaldi.new_pron_dict('pronunciation dictionary') pd.set_l2s_path('/recordings/letter_to_sound.txt') with pytest.raises(RuntimeError): pd.generate_lexicon() return
def test_load(tmpdir): """ Load an already existing dataset. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds1 = kaldi.new_dataset('dataset_x') ds2 = Dataset.load(ds1.path) assert ds2.importer is None assert ds2.has_been_processed == False return
def test_existing_pron_dict_using_use_existing(tmpdir): """ Use the use_existing parameter to load configurations from existing pron dict. """ kaldi = KaldiInterface(f'{tmpdir}/state') pd1 = kaldi.new_pron_dict('x') pd1_hash = pd1.hash pd2 = kaldi.new_pron_dict('x', use_existing=True) assert len(kaldi.list_pron_dicts()) == 1 assert pd1_hash == pd2.hash assert pd1.path == pd2.path return
def test_lexicon_before_dataset_processing(tmpdir): """ An attempt to generate lexicon before processing the dataset will raise an error. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') pd = kaldi.new_pron_dict('pronunciation dictionary') pd.link(ds) pd.set_l2s_path('/recordings/letter_to_sound.txt') with pytest.raises(RuntimeError): pd.generate_lexicon()
def test_annotations_before_processing(tmpdir): """ If there is an attempt to collect the annotations before processing the data (annotationts cannot exist), an error will be raised, """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') ds.add_directory('/recordings/transcribed') ds.select_importer('Elan') with pytest.raises(RuntimeError): _ = ds.annotations return
def test_existing_dataset_using_use_existing(tmpdir): """ Use the use_existing parameter to load configurations from existing dataset. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds1 = kaldi.new_dataset('dataset_x') ds1_hash = ds1.hash ds2 = kaldi.new_dataset('dataset_x', use_existing=True) assert len(kaldi.list_datasets()) == 1 assert ds1_hash == ds2.hash assert ds1.path == ds2.path return
def test_existing_transcription_using_override(tmpdir): """ Use override to delete a transcription with the same name and create a totally new transcription with the same name. """ kaldi = KaldiInterface(f'{tmpdir}/state') t1 = kaldi.new_transcription('transcription_w') t1_hash = t1.hash t2 = kaldi.new_transcription('transcription_w', override=True) # note t1 can no longer be used assert len(kaldi.list_transcriptions()) == 1 assert t1_hash != t2.hash return
def test_existing_pron_dict_using_override(tmpdir): """ Use override to delete a pron dict with the same name and create a totally new pron dict with the same name. """ kaldi = KaldiInterface(f'{tmpdir}/state') pd1 = kaldi.new_pron_dict('pronunciation dictionary') pd1_hash = pd1.hash pd2 = kaldi.new_pron_dict('pronunciation dictionary', override=True) # note pd1 can no longer be used assert len(kaldi.list_pron_dicts()) == 1 assert pd1_hash != pd2.hash return
def test_remove_file(tmpdir): """ Test that a file can be removed. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') ds.add_directory('/recordings/transcribed') ds.remove_file("1_1_1.wav") assert set(ds.files) == { "1_1_1.eaf", "1_1_2.wav", "1_1_2.eaf", "1_1_3.wav", "1_1_3.eaf", "1_1_4.wav", "1_1_4.eaf" } return
def test_annotations_after_processing(tmpdir): """ Ensure annotations are retrievable. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') ds.add_directory('/recordings/transcribed') ds.select_importer('Elan') ds.process() annotations = ds.annotations # ensure no errors are raised. annotations is JSONable assert len(annotations) != 0 return
def test_process_then_delete_file(tmpdir): """ Test when a file is removed, that the has_been_processed flag is switched to false as the dataset has changed. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') ds.add_directory('/recordings/transcribed') ds.select_importer('Elan') ds.process() ds.remove_file("1_1_1.wav") assert ds.has_been_processed == False return
def test_label_reset(tmpdir): """ Test when a file is removed, and the has_been_processed flag is switched to false, that the labels are also removed. """ kaldi = KaldiInterface(f'{tmpdir}/state') ds = kaldi.new_dataset('dataset_x') ds.add_directory('/recordings/transcribed') ds.select_importer('Elan') ds.process() ds.remove_file("1_1_1.wav") assert ds.processed_labels == [] return