rightkit_transcript/
words.rs1use crate::contract::Transcript;
4use serde::{Deserialize, Serialize};
5
6pub const MAP_DURATION_TOLERANCE_MS: u64 = 20;
9
10#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
12pub struct TimedWord {
13 pub text: String,
14 pub start_ms: u64,
15 pub end_ms: u64,
16 #[serde(default, skip_serializing_if = "Option::is_none")]
20 pub source_ms: Option<(u64, u64)>,
21}
22
23impl TimedWord {
24 pub fn new(text: impl Into<String>, start_ms: u64, end_ms: u64) -> Self {
25 Self {
26 text: text.into(),
27 start_ms,
28 end_ms,
29 source_ms: None,
30 }
31 }
32
33 pub fn from_seconds(text: impl Into<String>, start_s: f32, end_s: f32) -> Self {
36 Self::new(text, seconds_to_ms(start_s), seconds_to_ms(end_s))
37 }
38
39 pub fn start_secs(&self) -> f64 {
41 self.start_ms as f64 / 1000.0
42 }
43
44 pub fn end_secs(&self) -> f64 {
46 self.end_ms as f64 / 1000.0
47 }
48}
49
50impl<T: Into<String>> From<(T, u64, u64)> for TimedWord {
51 fn from((text, start_ms, end_ms): (T, u64, u64)) -> Self {
53 Self::new(text, start_ms, end_ms)
54 }
55}
56
57fn seconds_to_ms(s: f32) -> u64 {
58 if s.is_finite() && s > 0.0 {
59 (s as f64 * 1000.0).round() as u64
60 } else {
61 0
62 }
63}
64
65pub fn words_from_seconds<'a>(
69 items: impl IntoIterator<Item = (&'a str, f32, f32)>,
70) -> Vec<TimedWord> {
71 items
72 .into_iter()
73 .map(|(t, s, e)| TimedWord::from_seconds(t, s, e))
74 .collect()
75}
76
77pub fn words_from_transcript<F>(transcript: &Transcript, map: F) -> Vec<TimedWord>
87where
88 F: Fn(u64) -> Option<u64>,
89{
90 let mut out = Vec::new();
91 for w in &transcript.words {
92 let text = w.text.trim();
93 if text.is_empty() || w.end_ms <= w.start_ms {
94 continue;
95 }
96 let Some(start) = map(w.start_ms) else {
97 continue;
98 };
99 let Some(end) = map(w.end_ms).or_else(|| map(w.end_ms - 1).map(|e| e + 1)) else {
100 continue;
101 };
102 if end <= start {
103 continue;
104 }
105 if (end - start).abs_diff(w.end_ms - w.start_ms) > MAP_DURATION_TOLERANCE_MS {
106 continue;
107 }
108 let mut word = TimedWord::new(text, start, end);
109 word.source_ms = Some((w.start_ms, w.end_ms));
110 out.push(word);
111 }
112 out
113}
114
115#[cfg(test)]
116mod tests {
117 use super::*;
118
119 #[test]
120 fn source_span_is_optional_on_wire_and_defaults_for_all_adapters() {
121 let legacy = r#"{"text":"hi","start_ms":10,"end_ms":20}"#;
122 let word: TimedWord = serde_json::from_str(legacy).unwrap();
123 assert_eq!(word, TimedWord::new("hi", 10, 20));
124 assert_eq!(
125 serde_json::to_value(&word).unwrap(),
126 serde_json::from_str::<serde_json::Value>(legacy).unwrap()
127 );
128 assert_eq!(TimedWord::from_seconds("hi", 0.01, 0.02).source_ms, None);
129 assert_eq!(TimedWord::from(("hi", 10, 20)).source_ms, None);
130 assert_eq!(words_from_seconds([("hi", 0.01, 0.02)])[0].source_ms, None);
131 let mut mapped = word;
132 mapped.source_ms = Some((100, 110));
133 let value = serde_json::to_value(&mapped).unwrap();
134 assert_eq!(value["source_ms"], serde_json::json!([100, 110]));
135 assert_eq!(serde_json::from_value::<TimedWord>(value).unwrap(), mapped);
136 }
137
138 #[test]
139 fn mapping_records_source_and_enforces_duration_tolerance() {
140 let transcript = Transcript::from_words(
141 &[TimedWord::new(" shifted ", 100, 200)],
142 "en",
143 Some(1000),
144 crate::ModelRef::default(),
145 crate::EndSource::Model,
146 );
147 let mapped = words_from_transcript(&transcript, |t| Some(t + 500));
148 assert_eq!(mapped[0].text, "shifted");
149 assert_eq!((mapped[0].start_ms, mapped[0].end_ms), (600, 700));
150 assert_eq!(mapped[0].source_ms, Some((100, 200)));
151 let at_limit =
152 words_from_transcript(&transcript, |t| Some(if t == 200 { t - 20 } else { t }));
153 assert_eq!(at_limit.len(), 1);
154 let beyond_limit =
155 words_from_transcript(&transcript, |t| Some(if t == 200 { t - 21 } else { t }));
156 assert!(beyond_limit.is_empty());
157 }
158}