| |
| |
| |
| |
| |
| |
| |
|
|
| from __future__ import annotations |
|
|
| import math |
| from pathlib import Path |
|
|
| import pytest |
|
|
| from speech_text_data_aligners.core.errors import AlignmentValidationError |
| from speech_text_data_aligners.core.models import ( |
| AlignmentProvenance, |
| AlignmentRequest, |
| AlignmentResult, |
| LexicalWord, |
| WordAlignment, |
| ) |
| from speech_text_data_aligners.core.normalization import lexicalize |
| from speech_text_data_aligners.core.validation import ( |
| find_path_aliases, |
| validate_alignment_result, |
| ) |
|
|
|
|
| def make_pair() -> tuple[AlignmentRequest, AlignmentResult]: |
| request = AlignmentRequest("r", Path("a.wav"), "One two", 2.0) |
| words = lexicalize(request.transcript) |
| result = AlignmentResult( |
| "r", |
| (WordAlignment(words[0], 0.0, 0.5), WordAlignment(words[1], 0.5, 1.0)), |
| AlignmentProvenance("fake"), |
| runtime_s=0.1, |
| ) |
| return request, result |
|
|
|
|
| def test_validation_accepts_equality_and_single_word() -> None: |
| request, result = make_pair() |
| assert validate_alignment_result(request, result) is result |
| single_request = AlignmentRequest("s", Path("s.wav"), "Solo", 1.0) |
| word = lexicalize("Solo")[0] |
| single_result = AlignmentResult( |
| "s", (WordAlignment(word, 0.0, 1.0, 0.0),), AlignmentProvenance("fake") |
| ) |
| assert validate_alignment_result(single_request, single_result) is single_result |
|
|
|
|
| def test_validation_rejects_identity_duration_runtime_and_count() -> None: |
| request, result = make_pair() |
| variants = ( |
| (request, AlignmentResult("x", result.words, result.provenance)), |
| (AlignmentRequest("r", Path("a"), "One two", 0.0), result), |
| (AlignmentRequest("r", Path("a"), "One two", math.inf), result), |
| (request, AlignmentResult("r", result.words, result.provenance, runtime_s=-1)), |
| ( |
| request, |
| AlignmentResult("r", result.words, result.provenance, runtime_s=math.nan), |
| ), |
| (request, AlignmentResult("r", result.words[:1], result.provenance)), |
| ) |
| for candidate_request, candidate_result in variants: |
| with pytest.raises(AlignmentValidationError): |
| validate_alignment_result(candidate_request, candidate_result) |
|
|
|
|
| def test_validation_rejects_word_mapping_and_all_timestamp_errors() -> None: |
| request, result = make_pair() |
| first, second = result.words |
| wrong_word = LexicalWord(9, "wrong", 0, 5) |
| variants = ( |
| (WordAlignment(wrong_word, 0.0, 0.2), second), |
| (WordAlignment(first.lexical_word, math.nan, 0.2), second), |
| (WordAlignment(first.lexical_word, -0.1, 0.2), second), |
| (WordAlignment(first.lexical_word, 0.3, 0.2), second), |
| (first, WordAlignment(second.lexical_word, 0.5, 2.1)), |
| ( |
| WordAlignment(first.lexical_word, 0.0, 0.7), |
| WordAlignment(second.lexical_word, 0.6, 1.0), |
| ), |
| (WordAlignment(first.lexical_word, 0.0, 0.5, math.inf), second), |
| ) |
| for words in variants: |
| candidate = AlignmentResult("r", words, result.provenance) |
| with pytest.raises(AlignmentValidationError): |
| validate_alignment_result(request, candidate) |
|
|
|
|
| def test_path_alias_detection_handles_prospective_normalized_and_existing_aliases( |
| tmp_path: Path, |
| ) -> None: |
| source = tmp_path / "source.csv" |
| source.write_text("source", encoding="utf-8") |
| hard_link = tmp_path / "hard-link.csv" |
| try: |
| hard_link.hardlink_to(source) |
| except OSError as error: |
| pytest.skip(f"hard links are unavailable: {error}") |
| prospective = tmp_path / "future" / ".." / "source.csv" |
| distinct = tmp_path / "new.csv" |
| assert find_path_aliases( |
| { |
| "source": source, |
| "normalized": prospective, |
| "hard link": hard_link, |
| "distinct": distinct, |
| } |
| ) == ( |
| ("source", "normalized"), |
| ("source", "hard link"), |
| ("normalized", "hard link"), |
| ) |
|
|
|
|
| def test_path_alias_detection_falls_back_when_resolution_is_unavailable( |
| tmp_path: Path, monkeypatch: pytest.MonkeyPatch |
| ) -> None: |
| original_resolve = Path.resolve |
|
|
| def fail_selected(path: Path, *, strict: bool = False) -> Path: |
| if path.name == "unresolvable": |
| raise OSError("resolution unavailable") |
| return original_resolve(path, strict=strict) |
|
|
| monkeypatch.setattr(Path, "resolve", fail_selected) |
| path = tmp_path / "unresolvable" |
| assert find_path_aliases({"left": path, "right": path}) == (("left", "right"),) |
|
|
