eric/seriatim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 4 Wiki Activity

Minor updates to overlap detection and segment coalescing logic

Browse Source
This commit is contained in:
Eric Rakestraw
2026-04-28 14:11:38 -05:00
parent 28c2eea340
commit a3ca6665a9
14 changed files with 662 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

180
internal/overlap/resolve_test.go
View File

@@ -15,7 +15,7 @@ func TestResolveNoOverlapGroupsIsNoOp(t *testing.T) {
},
}
got, summary, err := Resolve(merged, 0.75, 0.4)
got, summary, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -40,7 +40,7 @@ func TestResolveCreatesChronologicalWordRunSegments(t *testing.T) {
merged.Segments[0].OverlapGroupID = 1
merged.Segments[1].OverlapGroupID = 1
got, summary, err := Resolve(merged, 0.75, 0.4)
got, summary, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -94,7 +94,7 @@ func TestResolveIncludesWordsByIntervalIntersection(t *testing.T) {
}
merged.Segments[0].OverlapGroupID = 1
got, _, err := Resolve(merged, 10, 0.4)
got, _, err := Resolve(merged, 10, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -106,6 +106,158 @@ func TestResolveIncludesWordsByIntervalIntersection(t *testing.T) {
}
}
func TestResolveIncludesContextWordsAroundOverlapWindow(t *testing.T) {
merged := model.MergedTranscript{
Segments: []model.Segment{
segmentWithWords("a.json", 0, "Alice", 7.5, 9.5, word("before", 8.5, 8.7)),
segmentWithWords("a.json", 1, "Alice", 10, 12, word("inside", 10.5, 10.7)),
segmentWithWords("a.json", 2, "Alice", 12.5, 13.5, word("after", 13, 13.2)),
segmentWithWords("b.json", 0, "Bob", 10.2, 11.2, word("bob", 10.4, 10.6)),
},
OverlapGroups: []model.OverlapGroup{
group(1, 10, 12, []string{"a.json#1", "b.json#0"}, []string{"Alice", "Bob"}),
},
}
merged.Segments[1].OverlapGroupID = 1
merged.Segments[3].OverlapGroupID = 1
got, summary, err := Resolve(merged, 10, 0.4, 3)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
if summary.GroupsChanged != 1 || summary.OriginalsRemoved != 4 || summary.ReplacementsCreated != 2 {
t.Fatalf("unexpected summary: %#v", summary)
}
if gotTexts(got.Segments) != "before inside after,bob" {
t.Fatalf("segment texts = %s", gotTexts(got.Segments))
}
alice := got.Segments[0]
if alice.Start != 8.5 || alice.End != 13.2 {
t.Fatalf("context bounds = %f-%f, want 8.5-13.2", alice.Start, alice.End)
}
if !reflect.DeepEqual(alice.DerivedFrom, []string{"a.json#0", "a.json#1", "a.json#2"}) {
t.Fatalf("derived_from = %v", alice.DerivedFrom)
}
}
func TestResolveDoesNotIncludeContextOutsideWindow(t *testing.T) {
merged := model.MergedTranscript{
Segments: []model.Segment{
segmentWithWords("a.json", 0, "Alice", 5, 6.9, word("outside", 6, 6.2)),
segmentWithWords("a.json", 1, "Alice", 10, 12, word("inside", 10.5, 10.7)),
segmentWithWords("b.json", 0, "Bob", 10.2, 11.2, word("bob", 10.4, 10.6)),
},
OverlapGroups: []model.OverlapGroup{
group(1, 10, 12, []string{"a.json#1", "b.json#0"}, []string{"Alice", "Bob"}),
},
}
got, _, err := Resolve(merged, 10, 0.4, 3)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
if gotTexts(got.Segments) != "Alice,bob,inside" {
t.Fatalf("segment texts = %s", gotTexts(got.Segments))
}
if got.Segments[0].SourceSegmentIndex == nil || *got.Segments[0].SourceSegmentIndex != 0 {
t.Fatalf("outside context segment was not preserved: %#v", got.Segments[0])
}
}
func TestResolveDoesNotIncludeNearbyNonGroupSpeakerContext(t *testing.T) {
merged := model.MergedTranscript{
Segments: []model.Segment{
segmentWithWords("a.json", 0, "Alice", 10, 12, word("alice", 10.5, 10.7)),
segmentWithWords("b.json", 0, "Bob", 10.2, 11.2, word("bob", 10.4, 10.6)),
segmentWithWords("c.json", 0, "Carol", 12.5, 13.5, word("carol", 13, 13.2)),
},
OverlapGroups: []model.OverlapGroup{
group(1, 10, 12, []string{"a.json#0", "b.json#0"}, []string{"Alice", "Bob"}),
},
}
got, _, err := Resolve(merged, 10, 0.4, 3)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
if gotTexts(got.Segments) != "bob,alice,Carol" {
t.Fatalf("segment texts = %s", gotTexts(got.Segments))
}
if got.Segments[2].SourceSegmentIndex == nil || *got.Segments[2].SourceSegmentIndex != 0 {
t.Fatalf("non-group speaker context segment was not preserved: %#v", got.Segments[2])
}
}
func TestResolveRemovesIncludedContextSegmentsForReplacedSpeaker(t *testing.T) {
merged := model.MergedTranscript{
Segments: []model.Segment{
segmentWithWords("a.json", 0, "Alice", 8, 9, word("before", 8.5, 8.7)),
segmentWithWords("a.json", 1, "Alice", 10, 12, word("inside", 10.5, 10.7)),
segmentWithWords("b.json", 0, "Bob", 10.2, 11.2),
},
OverlapGroups: []model.OverlapGroup{
group(1, 10, 12, []string{"a.json#1", "b.json#0"}, []string{"Alice", "Bob"}),
},
}
merged.Segments[1].OverlapGroupID = 1
merged.Segments[2].OverlapGroupID = 1
got, summary, err := Resolve(merged, 10, 0.4, 3)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
if summary.OriginalsRemoved != 2 || summary.ReplacementsCreated != 1 {
t.Fatalf("unexpected summary: %#v", summary)
}
if gotTexts(got.Segments) != "before inside,Bob" {
t.Fatalf("segment texts = %s", gotTexts(got.Segments))
}
if got.Segments[1].OverlapGroupID != 0 {
t.Fatalf("kept original group annotation = %d, want 0", got.Segments[1].OverlapGroupID)
}
}
func TestResolveSkipsContextSegmentReferencedByAnotherOverlapGroup(t *testing.T) {
merged := model.MergedTranscript{
Segments: []model.Segment{
segmentWithWords("a.json", 0, "Alice", 8, 9, word("other-group", 8.5, 8.7)),
segmentWithWords("a.json", 1, "Alice", 10, 12, word("inside", 10.5, 10.7)),
segmentWithWords("b.json", 0, "Bob", 10.2, 11.2, word("bob", 10.4, 10.6)),
segmentWithWords("c.json", 0, "Carol", 8.5, 9.5),
},
OverlapGroups: []model.OverlapGroup{
group(1, 10, 12, []string{"a.json#1", "b.json#0"}, []string{"Alice", "Bob"}),
group(2, 8, 9.5, []string{"a.json#0", "c.json#0"}, []string{"Alice", "Carol"}),
},
}
merged.Segments[0].OverlapGroupID = 2
merged.Segments[1].OverlapGroupID = 1
merged.Segments[2].OverlapGroupID = 1
merged.Segments[3].OverlapGroupID = 2
refToIndex := map[string]int{}
for index, segment := range merged.Segments {
refToIndex[SegmentRef(segment)] = index
}
overlapRefs := map[string]struct{}{
"a.json#0": {},
"a.json#1": {},
"b.json#0": {},
"c.json#0": {},
}
resolved, err := resolveGroup(merged, merged.OverlapGroups[0], refToIndex, overlapRefs, 10, 0.4, 3)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
if !reflect.DeepEqual(resolved.removeRefs, []string{"a.json#1", "b.json#0"}) {
t.Fatalf("remove refs = %v", resolved.removeRefs)
}
if gotTexts(resolved.replacements) != "bob,inside" {
t.Fatalf("replacement texts = %s", gotTexts(resolved.replacements))
}
}
func TestResolveWordRunGapThreshold(t *testing.T) {
merged := model.MergedTranscript{
Segments: []model.Segment{
@@ -117,7 +269,7 @@ func TestResolveWordRunGapThreshold(t *testing.T) {
}
merged.Segments[0].OverlapGroupID = 1
got, _, err := Resolve(merged, 0.75, 0.4)
got, _, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -142,7 +294,7 @@ func TestResolvePartialResolutionKeepsNoWordSpeakerOriginals(t *testing.T) {
merged.Segments[0].OverlapGroupID = 1
merged.Segments[1].OverlapGroupID = 1
got, summary, err := Resolve(merged, 0.75, 0.4)
got, summary, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -179,7 +331,7 @@ func TestResolveGroupWithNoUsableWordsRemainsUnchanged(t *testing.T) {
merged.Segments[0].OverlapGroupID = 1
merged.Segments[1].OverlapGroupID = 1
got, summary, err := Resolve(merged, 0.75, 0.4)
got, summary, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -202,7 +354,7 @@ func TestResolveReplacementProvenanceIsDeterministic(t *testing.T) {
},
}
got, _, err := Resolve(merged, 0.75, 0.4)
got, _, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -239,7 +391,7 @@ func TestResolveIncludesUntimedWordsInTextWithoutChangingBounds(t *testing.T) {
},
}
got, _, err := Resolve(merged, 0.75, 0.4)
got, _, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -274,7 +426,7 @@ func TestResolveUntimedWordsDoNotBridgeWordRunGap(t *testing.T) {
},
}
got, _, err := Resolve(merged, 0.75, 0.4)
got, _, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -300,7 +452,7 @@ func TestResolveSpeakerWithOnlyUntimedWordsIsNotReplaced(t *testing.T) {
}
merged.Segments[0].OverlapGroupID = 1
got, summary, err := Resolve(merged, 0.75, 0.4)
got, summary, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -323,7 +475,7 @@ func TestResolveReordersNearStartWordRunsByDuration(t *testing.T) {
},
}
got, _, err := Resolve(merged, 0.75, 0.4)
got, _, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -349,7 +501,7 @@ func TestResolveDoesNotReorderWordRunsOutsideWindow(t *testing.T) {
},
}
got, _, err := Resolve(merged, 0.75, 0.4)
got, _, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -370,7 +522,7 @@ func TestResolveReordersTransitiveNearStartClustersByDuration(t *testing.T) {
},
}
got, _, err := Resolve(merged, 0.75, 0.4)
got, _, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}
@@ -390,7 +542,7 @@ func TestResolveReorderFallsBackToDeterministicOrderForEqualDurations(t *testing
},
}
got, _, err := Resolve(merged, 0.75, 0.4)
got, _, err := Resolve(merged, 0.75, 0.4, 0)
if err != nil {
t.Fatalf("resolve failed: %v", err)
}