Zum Inhalt

tests/test_transcript_align.py

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
"""Tests for transcript_align — propagating segment.text edits into segment.words.

The Remotion renderer drives the per-word karaoke highlight from segment.words
and only falls back to segment.text when the word list is empty
(visualizer/src/DialogueComposition.tsx:644). A text edit that never reaches
words is therefore invisible in the rendered MP4.
"""

from itertools import pairwise


def test_replacing_one_word_keeps_the_surrounding_timings():
    from transcript_align import propagate_text_to_words

    segment = {
        "start": 0.0,
        "end": 2.0,
        "text": "wir deployen auf Kubernetes heute",
        "words": [
            {"word": "wir", "start": 0.0, "end": 0.3, "score": 0.9},
            {"word": "deployen", "start": 0.3, "end": 0.7, "score": 0.9},
            {"word": "auf", "start": 0.7, "end": 0.9, "score": 0.9},
            {"word": "Kubernetis", "start": 0.9, "end": 1.5, "score": 0.4},
            {"word": "heute", "start": 1.5, "end": 2.0, "score": 0.9},
        ],
    }

    propagate_text_to_words(segment)

    words = segment["words"]
    assert [w["word"] for w in words] == [
        "wir",
        "deployen",
        "auf",
        "Kubernetes",
        "heute",
    ]
    # The replaced word keeps the slot it was spoken in.
    assert words[3]["start"] == 0.9
    assert words[3]["end"] == 1.5
    # Untouched neighbours keep their timings byte-for-byte.
    assert words[0]["start"] == 0.0
    assert words[4]["end"] == 2.0


def test_deleted_word_disappears_and_leaves_the_others_untouched():
    from transcript_align import propagate_text_to_words

    segment = {
        "start": 0.0,
        "end": 1.0,
        "text": "wir deployen heute",
        "words": [
            {"word": "wir", "start": 0.0, "end": 0.3, "score": 0.9},
            {"word": "deployen", "start": 0.3, "end": 0.7, "score": 0.9},
            {"word": "jetzt", "start": 0.7, "end": 0.8, "score": 0.9},
            {"word": "heute", "start": 0.8, "end": 1.0, "score": 0.9},
        ],
    }

    propagate_text_to_words(segment)

    assert [w["word"] for w in segment["words"]] == ["wir", "deployen", "heute"]
    assert segment["words"][2]["start"] == 0.8


def test_segment_without_words_stays_empty():
    """WhisperX leaves some segments wordless; the renderer falls back to
    segment.text there. Inventing words would fake timings that were never
    measured — and the fake would then drive the karaoke highlight."""
    from transcript_align import propagate_text_to_words

    segment = {"start": 2.5, "end": 4.0, "text": "Sounds great to me.", "words": []}

    assert propagate_text_to_words(segment) == 0
    assert segment["words"] == []


def test_inserted_word_gets_a_highlightable_slot_between_gapless_neighbours():
    from transcript_align import propagate_text_to_words

    segment = {
        "start": 0.0,
        "end": 1.0,
        "text": "wir deployen das heute",
        "words": [
            {"word": "wir", "start": 0.0, "end": 0.3, "score": 0.9},
            {"word": "deployen", "start": 0.3, "end": 0.7, "score": 0.9},
            {"word": "heute", "start": 0.7, "end": 1.0, "score": 0.9},
        ],
    }

    propagate_text_to_words(segment)

    words = segment["words"]
    assert [w["word"] for w in words] == ["wir", "deployen", "das", "heute"]
    # Every word needs a non-empty window — the renderer highlights on
    # `nowMs >= startMs && nowMs < endMs`, so start == end never lights up.
    for w in words:
        assert w["end"] > w["start"], f"{w['word']} has an empty window"
    # Monotonic and inside the segment.
    assert all(a["end"] <= b["start"] for a, b in pairwise(words))
    assert words[0]["start"] >= segment["start"]
    assert words[-1]["end"] <= segment["end"]


def test_inserted_word_at_segment_head_gets_a_highlightable_slot():
    """WhisperX segments start exactly where their first word starts (measured:
    715 of 716 segments in a real run), so there is no room before the first
    word — the head insertion has to share the right neighbour's span."""
    from transcript_align import propagate_text_to_words

    segment = {
        "start": 0.0,
        "end": 1.0,
        "text": "also wir deployen heute",
        "words": [
            {"word": "wir", "start": 0.0, "end": 0.3, "score": 0.9},
            {"word": "deployen", "start": 0.3, "end": 0.7, "score": 0.9},
            {"word": "heute", "start": 0.7, "end": 1.0, "score": 0.9},
        ],
    }

    propagate_text_to_words(segment)

    words = segment["words"]
    assert [w["word"] for w in words] == ["also", "wir", "deployen", "heute"]
    for w in words:
        assert w["end"] > w["start"], f"{w['word']} has an empty window"
    assert all(a["end"] <= b["start"] for a, b in pairwise(words))
    assert words[0]["start"] >= segment["start"]
    # Only the inserted word is an edit; the re-timed neighbour keeps its text.
    assert words[0].get("_edited") is True
    assert "_edited" not in words[1]
    # Words after the borrowed neighbour are untouched.
    assert words[2] == {"word": "deployen", "start": 0.3, "end": 0.7, "score": 0.9}