forked from Blendman974/faceclaw
211 lines
8.6 KiB
TypeScript
211 lines
8.6 KiB
TypeScript
import { wrapTranscribeText } from "../transcribe/transcript-model";
|
|
|
|
type TranscriptEvent = { text: string; isFinal: boolean };
|
|
|
|
/**
|
|
* One block of speech (up to a pause) and its English translation. The last
|
|
* block may still be live, its transcript revising; it is translated
|
|
* provisionally as it grows, then again once final if its text changed.
|
|
*/
|
|
export type TranslationSegment = {
|
|
source: string;
|
|
/** Committed by the transcriber; a live block's source still revises. */
|
|
final: boolean;
|
|
/** The latest finished translation, of `translatedSource`. */
|
|
translation: string;
|
|
/** What `translation` translates: null until one finishes, behind `source` while provisional. */
|
|
translatedSource: string | null;
|
|
/** The text streamed so far by the request in flight for this block, else null. */
|
|
streaming: string | null;
|
|
/** A source whose translation failed; not retried until the source changes. */
|
|
failedSource: string | null;
|
|
};
|
|
|
|
export type TranslationTurn = { source: string; translation: string };
|
|
|
|
/** A request: a block's source as sent, with the finished turns before it. */
|
|
export type TranslationJob = {
|
|
segment: TranslationSegment;
|
|
/** The source sent (a live block's moves on while the request is in flight). */
|
|
source: string;
|
|
/** Earlier translated turns, oldest first. */
|
|
context: TranslationTurn[];
|
|
};
|
|
|
|
export type TranslationLine = { text: string; gray: number };
|
|
|
|
// Earlier turns sent with each request, so pronouns, names, and topic carry
|
|
// over between requests; bounded so a long session's requests stay small.
|
|
const CONTEXT_TURNS = 4;
|
|
const CONTEXT_CHARS = 800;
|
|
// A live block is translated again once its text has changed length by this
|
|
// much since the last request, so a trickle of revisions (punctuation, one
|
|
// corrected word) doesn't spend a request each. A final is always redone.
|
|
const PROVISIONAL_MIN_CHANGE = 3;
|
|
|
|
const TRANSLATION_GRAY = 230;
|
|
const PROVISIONAL_GRAY = 170;
|
|
const ORIGINAL_GRAY = 120;
|
|
const LIVE_GRAY = 90;
|
|
|
|
function newSegment(source: string, final: boolean): TranslationSegment {
|
|
return { source, final, translation: "", translatedSource: null, streaming: null, failedSource: null };
|
|
}
|
|
|
|
/** Whether a block's current source still needs a translation request. */
|
|
function wantsTranslation(segment: TranslationSegment): boolean {
|
|
const { source, translatedSource } = segment;
|
|
if (!source || source === translatedSource || source === segment.failedSource) return false;
|
|
return segment.final || translatedSource === null || Math.abs(source.length - translatedSource.length) >= PROVISIONAL_MIN_CHANGE;
|
|
}
|
|
|
|
/**
|
|
* The Translate app's conversation: blocks of speech with their translations.
|
|
* Translation is serial (one request at a time, in order, so each can carry
|
|
* the turns before it as context): final blocks first, then the live one.
|
|
* Finals that arrive while a request is in flight merge into one waiting
|
|
* block, so a slow model batches the backlog instead of falling further
|
|
* behind one request per pause.
|
|
*/
|
|
export class TranslationModel {
|
|
readonly segments: TranslationSegment[] = [];
|
|
private active: TranslationJob | null = null;
|
|
|
|
/**
|
|
* Take a transcript event (replace semantics within the live block).
|
|
* Returns true when it made the request in flight moot (its block was
|
|
* finalized as other text, or dropped); that request is abandoned here, and
|
|
* the caller should cancel it.
|
|
*/
|
|
accept(event: TranscriptEvent): boolean {
|
|
const text = event.text.trim();
|
|
const last = this.segments[this.segments.length - 1];
|
|
const live = last && !last.final ? last : null;
|
|
if (!event.isFinal) {
|
|
if (live) live.source = text;
|
|
else if (text) this.segments.push(newSegment(text, false));
|
|
return false;
|
|
}
|
|
const finalText = text || live?.source || "";
|
|
if (!live) {
|
|
if (finalText && !this.mergeIntoWaiting(finalText)) this.segments.push(newSegment(finalText, true));
|
|
return false;
|
|
}
|
|
const moot = this.active?.segment === live && this.active.source !== finalText;
|
|
if (moot) this.abandonActive();
|
|
if (!finalText || (this.active?.segment !== live && live.translatedSource === null && this.mergeIntoWaiting(finalText, live))) {
|
|
this.segments.pop();
|
|
return moot;
|
|
}
|
|
live.source = finalText;
|
|
live.final = true;
|
|
return moot;
|
|
}
|
|
|
|
/** Take the next request to make, or null while one is in flight or nothing waits. */
|
|
nextJob(): TranslationJob | null {
|
|
if (this.active) return null;
|
|
const segment = this.segments.find((candidate) => wantsTranslation(candidate));
|
|
if (!segment) return null;
|
|
segment.streaming = "";
|
|
this.active = { segment, source: segment.source, context: this.contextBefore(segment) };
|
|
return this.active;
|
|
}
|
|
|
|
isActive(job: TranslationJob): boolean {
|
|
return this.active === job;
|
|
}
|
|
|
|
/** Streamed text for the request in flight; false when `job` isn't it any more. */
|
|
progress(job: TranslationJob, textSoFar: string): boolean {
|
|
if (this.active !== job) return false;
|
|
job.segment.streaming = textSoFar;
|
|
return true;
|
|
}
|
|
|
|
complete(job: TranslationJob, translation: string): void {
|
|
if (this.active !== job) return;
|
|
this.active = null;
|
|
job.segment.streaming = null;
|
|
job.segment.translation = translation;
|
|
job.segment.translatedSource = job.source;
|
|
}
|
|
|
|
fail(job: TranslationJob): void {
|
|
if (this.active !== job) return;
|
|
this.active = null;
|
|
job.segment.streaming = null;
|
|
job.segment.failedSource = job.source;
|
|
}
|
|
|
|
private abandonActive(): void {
|
|
if (this.active) this.active.segment.streaming = null;
|
|
this.active = null;
|
|
}
|
|
|
|
/**
|
|
* Append a final to the block before `before` (default: the end) when that
|
|
* block is final but still waiting for its first request. Returns whether
|
|
* it did.
|
|
*/
|
|
private mergeIntoWaiting(finalText: string, before?: TranslationSegment): boolean {
|
|
const index = (before ? this.segments.indexOf(before) : this.segments.length) - 1;
|
|
const waiting = this.segments[index];
|
|
if (!waiting?.final || waiting.translatedSource !== null || waiting.failedSource !== null) return false;
|
|
if (this.active?.segment === waiting) return false;
|
|
waiting.source = `${waiting.source} ${finalText}`;
|
|
return true;
|
|
}
|
|
|
|
private contextBefore(segment: TranslationSegment): TranslationTurn[] {
|
|
const turns: TranslationTurn[] = [];
|
|
let chars = 0;
|
|
for (let index = this.segments.indexOf(segment) - 1; index >= 0 && turns.length < CONTEXT_TURNS; index--) {
|
|
const earlier = this.segments[index]!;
|
|
if (!earlier.final || earlier.translatedSource !== earlier.source || !earlier.translation) continue;
|
|
chars += earlier.source.length + earlier.translation.length;
|
|
if (turns.length && chars > CONTEXT_CHARS) break;
|
|
turns.unshift({ source: earlier.source, translation: earlier.translation });
|
|
}
|
|
return turns;
|
|
}
|
|
|
|
/**
|
|
* Display lines: each block's translation, bright once settled (final, and
|
|
* of its final text) and dimmer while provisional; its original, dim, above
|
|
* it when `showOriginal` is on and in its place until a translation
|
|
* arrives. A redo streams in over the translation it replaces only once it
|
|
* is as long, so the text doesn't shrink and regrow.
|
|
*/
|
|
lines(measure: (text: string) => number, maxWidth: number, showOriginal: boolean): TranslationLine[] {
|
|
const lines: TranslationLine[] = [];
|
|
const push = (text: string, gray: number) => {
|
|
for (const line of wrapTranscribeText(measure, text, maxWidth)) lines.push({ text: line, gray });
|
|
};
|
|
for (const segment of this.segments) {
|
|
if (!segment.source) continue;
|
|
const settled = segment.final && segment.translatedSource === segment.source;
|
|
const finished = segment.translation.trim();
|
|
const streaming = segment.streaming?.trim() ?? "";
|
|
const translation = streaming.length >= finished.length ? streaming : finished;
|
|
// A settled, empty translation is noise the model chose to drop.
|
|
if (showOriginal || (!translation && !settled)) push(segment.source, segment.final ? ORIGINAL_GRAY : LIVE_GRAY);
|
|
if (translation) push(translation, settled ? TRANSLATION_GRAY : PROVISIONAL_GRAY);
|
|
}
|
|
return lines;
|
|
}
|
|
|
|
/** Plain-text transcript for saving: each final original, then its translation. */
|
|
savedText(): string {
|
|
return this.segments
|
|
.filter((segment) => segment.final)
|
|
.map((segment) => {
|
|
const translation = segment.translation.trim();
|
|
if (!translation && segment.failedSource === segment.source) return `${segment.source}\n→ (not translated)`;
|
|
if (!translation || translation === segment.source.trim()) return segment.source;
|
|
return `${segment.source}\n→ ${translation}`;
|
|
})
|
|
.join("\n\n");
|
|
}
|
|
}
|