use std::path::Path;
use bunsen::kits::speech::asr::driver::TranscriptSegment;
use serde::Serialize;
#[derive(Clone, Debug, Serialize)]
pub struct Transcript {
pub text: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub language: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub words: Option<Vec<Word>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub segments: Option<Vec<Segment>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub turns: Option<Vec<Turn>>,
}
#[derive(Clone, Debug, Serialize)]
pub struct Word {
pub word: String,
pub start: f64,
pub end: f64,
pub tokens: Vec<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub speaker: Option<String>,
}
#[derive(Clone, Debug, Serialize)]
pub struct Segment {
pub start: f64,
pub end: f64,
pub text: String,
pub tokens: Vec<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub speaker: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct Turn {
pub speaker: Option<String>,
pub start: f64,
pub end: f64,
pub text: String,
}
pub fn segment_speaker(segment: &TranscriptSegment) -> Option<String> {
segment.speaker.map(|label| speaker_name(label.index))
}
pub fn speaker_turns(segments: &[TranscriptSegment]) -> Vec<Turn> {
let mut turns: Vec<Turn> = Vec::new();
for segment in segments {
let Some(text) = segment
.text
.as_deref()
.map(str::trim)
.filter(|t| !t.is_empty())
else {
continue;
};
let speaker = segment_speaker(segment);
match turns.last_mut() {
Some(turn) if turn.speaker == speaker => {
turn.end = millis(segment.end);
turn.text.push(' ');
turn.text.push_str(text);
}
_ => turns.push(Turn {
speaker,
start: millis(segment.start),
end: millis(segment.end),
text: text.to_string(),
}),
}
}
turns
}
pub fn speaker_name(index: usize) -> String {
format!("speaker_{index}")
}
pub fn recording_id(path: &Path) -> String {
path.file_stem()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_else(|| path.display().to_string())
}
pub fn millis(seconds: f64) -> f64 {
(seconds * 1000.0).round() / 1000.0
}
#[cfg(test)]
mod tests {
use bunsen::kits::speech::asr::driver::SpeakerLabel;
use super::*;
fn segment(
text: &str,
start: f64,
speaker: Option<usize>,
) -> TranscriptSegment {
TranscriptSegment {
start,
end: start + 0.5,
tokens: Vec::new(),
text: Some(text.to_string()),
speaker: speaker.map(|index| SpeakerLabel {
index,
confidence: 0.9,
}),
}
}
#[test]
fn test_speaker_turns() {
let turns = speaker_turns(&[
segment(" hello", 0.0, Some(0)),
segment(" ", 0.5, Some(1)),
segment("there", 1.0, Some(0)),
segment("hi", 2.0, Some(1)),
segment("um", 3.0, None),
]);
let lines: Vec<(Option<&str>, &str)> = turns
.iter()
.map(|t| (t.speaker.as_deref(), t.text.as_str()))
.collect();
assert_eq!(
lines,
[
(Some("speaker_0"), "hello there"),
(Some("speaker_1"), "hi"),
(None, "um")
]
);
assert_eq!((turns[0].start, turns[0].end), (0.0, 1.5));
}
}