feat #14740: merge speakers and name calls
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -7,6 +7,8 @@
|
||||
use std::cmp::Ordering;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use thiserror::Error;
|
||||
|
||||
use crate::model::{Segment, Speaker, Word};
|
||||
|
||||
/// Longest gap, in seconds, that still belongs to the same segment. A gap
|
||||
@@ -94,6 +96,103 @@ pub fn label(speaker: &Speaker, names: &BTreeMap<String, String>) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// Why a speaker merge (`from` → `into`) was refused.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Error)]
|
||||
pub enum MergeError {
|
||||
#[error("Unbekannter Sprecher: {0}")]
|
||||
UnknownSpeaker(String),
|
||||
#[error("„Ich“ kann nicht zusammengeführt werden")]
|
||||
Me,
|
||||
#[error("Ein Sprecher kann nicht mit sich selbst zusammengeführt werden")]
|
||||
SameSpeaker,
|
||||
#[error("Diese Zuordnung würde eine Schleife ergeben")]
|
||||
Cycle,
|
||||
}
|
||||
|
||||
/// Checks whether `from_key` may be merged into `into_key` on top of the
|
||||
/// call's existing `merges` (source key → target key): both must be
|
||||
/// distinct remote speakers, and with the new merge in place (replacing
|
||||
/// `from_key`'s own, if any) following the targets must not run in a loop.
|
||||
pub fn check_merge(
|
||||
merges: &BTreeMap<String, String>,
|
||||
from_key: &str,
|
||||
into_key: &str,
|
||||
) -> Result<(), MergeError> {
|
||||
for key in [from_key, into_key] {
|
||||
match Speaker::from_key(key) {
|
||||
Some(Speaker::Remote(_)) => {}
|
||||
Some(Speaker::Me) => return Err(MergeError::Me),
|
||||
None => return Err(MergeError::UnknownSpeaker(key.to_string())),
|
||||
}
|
||||
}
|
||||
if from_key == into_key {
|
||||
return Err(MergeError::SameSpeaker);
|
||||
}
|
||||
let mut proposed: BTreeMap<&str, &str> = merges
|
||||
.iter()
|
||||
.map(|(from, into)| (from.as_str(), into.as_str()))
|
||||
.collect();
|
||||
proposed.insert(from_key, into_key);
|
||||
match final_target(&proposed, from_key) {
|
||||
Some(_) => Ok(()),
|
||||
None => Err(MergeError::Cycle),
|
||||
}
|
||||
}
|
||||
|
||||
/// Resolves stored merges (source key → target key) to each source's final
|
||||
/// target, following chains (3 → 2 and 2 → 1 give 3 → 1). Merges involving
|
||||
/// anything but two remote speakers, and merges caught in a cycle, are
|
||||
/// ignored; [`check_merge`] keeps both from being stored.
|
||||
pub fn resolve_merges(merges: &BTreeMap<String, String>) -> BTreeMap<String, String> {
|
||||
let is_remote = |key: &str| matches!(Speaker::from_key(key), Some(Speaker::Remote(_)));
|
||||
let usable: BTreeMap<&str, &str> = merges
|
||||
.iter()
|
||||
.filter(|(from, into)| is_remote(from) && is_remote(into))
|
||||
.map(|(from, into)| (from.as_str(), into.as_str()))
|
||||
.collect();
|
||||
|
||||
usable
|
||||
.keys()
|
||||
.filter_map(|&from| Some((from.to_string(), final_target(&usable, from)?.to_string())))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Follows `merges` from `key` to a speaker that is not merged itself, or
|
||||
/// `None` if the chain runs in a cycle.
|
||||
fn final_target<'a>(merges: &BTreeMap<&'a str, &'a str>, key: &'a str) -> Option<&'a str> {
|
||||
let mut current = key;
|
||||
for _ in 0..=merges.len() {
|
||||
match merges.get(current) {
|
||||
Some(&next) => current = next,
|
||||
None => return Some(current),
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The call's transcript as the user sees it after merging speakers:
|
||||
/// every segment of a merged source is attributed to its final target (see
|
||||
/// [`resolve_merges`]), then segments left adjacent with the same speaker
|
||||
/// are joined under the same 1.5 s gap rule as step 4 of [`merge`]. The
|
||||
/// stored segments stay untouched, so removing a merge restores them.
|
||||
pub fn apply_merges(segments: &[Segment], merges: &BTreeMap<String, String>) -> Vec<Segment> {
|
||||
let resolved = resolve_merges(merges);
|
||||
let mapped = segments
|
||||
.iter()
|
||||
.map(|segment| {
|
||||
let speaker = resolved
|
||||
.get(&segment.speaker.key())
|
||||
.and_then(|target| Speaker::from_key(target))
|
||||
.unwrap_or(segment.speaker);
|
||||
Segment {
|
||||
speaker,
|
||||
..segment.clone()
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
merge_adjacent(mapped)
|
||||
}
|
||||
|
||||
/// Orders by `start` (NaN treated as `0.0`), then — for ties — puts the mic
|
||||
/// first and orders remote speakers by ascending number.
|
||||
fn cmp_for_merge_order(a: &Segment, b: &Segment) -> Ordering {
|
||||
@@ -238,6 +337,141 @@ fn join_text(a: &str, b: &str) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod speaker_merge_tests {
|
||||
use super::{apply_merges, check_merge, label, resolve_merges, MergeError};
|
||||
use crate::model::{Segment, Speaker};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
fn merges(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
|
||||
pairs
|
||||
.iter()
|
||||
.map(|(from, into)| (from.to_string(), into.to_string()))
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn seg(speaker: Speaker, start: f64, end: f64, text: &str) -> Segment {
|
||||
Segment {
|
||||
speaker,
|
||||
start,
|
||||
end,
|
||||
text: text.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chains_resolve_to_the_final_speaker() {
|
||||
let resolved = resolve_merges(&merges(&[
|
||||
("remote:3", "remote:2"),
|
||||
("remote:2", "remote:1"),
|
||||
]));
|
||||
assert_eq!(
|
||||
resolved,
|
||||
merges(&[("remote:2", "remote:1"), ("remote:3", "remote:1")])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_stored_cycle_or_a_mapping_involving_me_is_ignored() {
|
||||
let resolved = resolve_merges(&merges(&[
|
||||
("remote:1", "remote:2"),
|
||||
("remote:2", "remote:1"),
|
||||
("remote:3", "me"),
|
||||
("me", "remote:4"),
|
||||
("remote:5", "remote:4"),
|
||||
]));
|
||||
assert_eq!(resolved, merges(&[("remote:5", "remote:4")]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_merge_that_closes_a_cycle_is_rejected() {
|
||||
let existing = merges(&[("remote:3", "remote:2"), ("remote:2", "remote:1")]);
|
||||
assert_eq!(
|
||||
check_merge(&existing, "remote:1", "remote:3"),
|
||||
Err(MergeError::Cycle)
|
||||
);
|
||||
assert_eq!(
|
||||
MergeError::Cycle.to_string(),
|
||||
"Diese Zuordnung würde eine Schleife ergeben"
|
||||
);
|
||||
assert_eq!(check_merge(&existing, "remote:4", "remote:3"), Ok(()));
|
||||
// Re-pointing an existing merge replaces it instead of chaining.
|
||||
assert_eq!(check_merge(&existing, "remote:2", "remote:4"), Ok(()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn me_is_never_merged() {
|
||||
let none = BTreeMap::new();
|
||||
assert_eq!(check_merge(&none, "me", "remote:1"), Err(MergeError::Me));
|
||||
assert_eq!(check_merge(&none, "remote:1", "me"), Err(MergeError::Me));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_speaker_is_not_merged_into_itself_or_an_unknown_key() {
|
||||
let none = BTreeMap::new();
|
||||
assert_eq!(
|
||||
check_merge(&none, "remote:1", "remote:1"),
|
||||
Err(MergeError::SameSpeaker)
|
||||
);
|
||||
assert_eq!(
|
||||
check_merge(&none, "remote:x", "remote:1"),
|
||||
Err(MergeError::UnknownSpeaker("remote:x".into()))
|
||||
);
|
||||
assert_eq!(
|
||||
MergeError::UnknownSpeaker("remote:x".into()).to_string(),
|
||||
"Unbekannter Sprecher: remote:x"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn applied_merges_rejoin_adjacent_segments_and_keep_others_apart() {
|
||||
let segments = [
|
||||
seg(Speaker::Remote(1), 0.0, 2.0, "Guten Tag,"),
|
||||
seg(Speaker::Remote(2), 2.5, 4.0, "hier ist das Weingut."),
|
||||
seg(Speaker::Me, 4.5, 6.0, "Hallo."),
|
||||
seg(Speaker::Remote(2), 6.5, 7.0, "Also,"),
|
||||
// 2 s after the previous line: adjacent, but too far apart.
|
||||
seg(Speaker::Remote(1), 9.0, 10.0, "die Lieferung."),
|
||||
];
|
||||
|
||||
let merged = apply_merges(&segments, &merges(&[("remote:2", "remote:1")]));
|
||||
|
||||
assert_eq!(
|
||||
merged,
|
||||
[
|
||||
seg(
|
||||
Speaker::Remote(1),
|
||||
0.0,
|
||||
4.0,
|
||||
"Guten Tag, hier ist das Weingut."
|
||||
),
|
||||
seg(Speaker::Me, 4.5, 6.0, "Hallo."),
|
||||
seg(Speaker::Remote(1), 6.5, 7.0, "Also,"),
|
||||
seg(Speaker::Remote(1), 9.0, 10.0, "die Lieferung."),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn merged_speakers_take_the_targets_name_and_undo_restores_them() {
|
||||
let segments = [
|
||||
seg(Speaker::Remote(1), 0.0, 1.0, "Eins."),
|
||||
seg(Speaker::Me, 1.5, 2.0, "Ja."),
|
||||
seg(Speaker::Remote(2), 2.5, 3.0, "Zwei."),
|
||||
];
|
||||
let names = merges(&[("remote:1", "Frau Beispiel"), ("remote:2", "Herr Probe")]);
|
||||
|
||||
let merged = apply_merges(&segments, &merges(&[("remote:2", "remote:1")]));
|
||||
let labels: Vec<_> = merged.iter().map(|s| label(&s.speaker, &names)).collect();
|
||||
assert_eq!(labels, ["Frau Beispiel", "Ich", "Frau Beispiel"]);
|
||||
|
||||
// Undo: without the merge, the original segments and names return.
|
||||
let restored = apply_merges(&segments, &BTreeMap::new());
|
||||
assert_eq!(restored, segments);
|
||||
assert_eq!(label(&restored[2].speaker, &names), "Herr Probe");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{label, merge};
|
||||
|
||||
Reference in New Issue
Block a user