asr-core 0.0.2

Unified streaming, offline, and cloud speech-to-text engine for Rust
Documentation
use super::state::SessionState;
use crate::{PartialView, Segment, SessionView, Update};

pub(crate) enum Delivery {
    Update(Update),
    Disconnected,
    Pending,
}

pub(crate) fn current_view(state: &SessionState) -> SessionView {
    SessionView {
        phase: state.lifecycle.phase,
        transcript: state.results.transcript().clone(),
        partials: state.results.partial_views(),
        received_frames: state.input.received,
        processed_frames: state.input.processed,
        queued_frames: state.input.queued,
        error: state
            .lifecycle
            .outcome
            .as_ref()
            .and_then(|result| result.as_ref().err().map(|failure| failure.error.clone())),
    }
}

pub(crate) fn take_next(state: &mut SessionState) -> Delivery {
    if state.observer.needs_reset {
        state.observer.updates.clear();
        state.observer.needs_reset = false;
        return Delivery::Update(Update::Reset(current_view(state)));
    }
    if let Some(update) = state.observer.updates.pop_front() {
        return Delivery::Update(update);
    }
    if state.lifecycle.outcome.is_some() {
        Delivery::Disconnected
    } else {
        Delivery::Pending
    }
}

pub(crate) fn enable(state: &mut SessionState) {
    state.observer.subscription_enabled = true;
    state.observer.updates.clear();
    state.observer.needs_reset = true;
}

pub(crate) fn disable(state: &mut SessionState) {
    state.observer.subscription_enabled = false;
    state.observer.updates.clear();
    state.observer.needs_reset = false;
}

pub(crate) fn terminal(state: &mut SessionState) {
    if state.observer.subscription_enabled {
        require_reset(state);
    }
}

pub(crate) fn partial(state: &mut SessionState, update: &PartialView, capacity: usize) {
    if !state.observer.subscription_enabled || state.observer.needs_reset {
        return;
    }
    state.observer.updates.retain(
        |queued| !matches!(queued, Update::Partial { utterance_id, .. } if utterance_id == &update.utterance_id),
    );
    push(
        state,
        Update::Partial {
            utterance_id: update.utterance_id.clone(),
            revision: update.revision,
            text: update.text.clone(),
        },
        capacity,
    );
}

pub(crate) fn phase(state: &mut SessionState, capacity: usize) {
    if !state.observer.subscription_enabled || state.observer.needs_reset {
        return;
    }
    state
        .observer
        .updates
        .retain(|queued| !matches!(queued, Update::Phase(_)));
    push(state, Update::Phase(state.lifecycle.phase), capacity);
}

pub(crate) fn final_segments(
    state: &mut SessionState,
    completed_id: &str,
    removed_partial: bool,
    segments: &[Segment],
    capacity: usize,
) {
    if !state.observer.subscription_enabled {
        return;
    }
    if state.observer.needs_reset {
        return;
    }

    remove_queued_partial(state, completed_id);
    if removed_partial && segments.is_empty() {
        require_reset(state);
        return;
    }

    for segment in segments {
        remove_queued_partial(state, &segment.id);
        if !push(state, Update::Segment(segment.clone()), capacity) {
            return;
        }
    }
}

#[cfg_attr(not(feature = "backend-openai-realtime"), allow(dead_code))]
pub(crate) fn partial_removed_without_segment(state: &mut SessionState, id: &str) {
    if !state.observer.subscription_enabled || state.observer.needs_reset {
        return;
    }
    remove_queued_partial(state, id);
    require_reset(state);
}

fn remove_queued_partial(state: &mut SessionState, id: &str) {
    state.observer.updates.retain(
        |queued| !matches!(queued, Update::Partial { utterance_id, .. } if utterance_id == id),
    );
}

fn push(state: &mut SessionState, update: Update, capacity: usize) -> bool {
    if state.observer.updates.len() >= capacity {
        require_reset(state);
        false
    } else {
        state.observer.updates.push_back(update);
        true
    }
}

fn require_reset(state: &mut SessionState) {
    state.observer.updates.clear();
    state.observer.needs_reset = true;
}

#[cfg(test)]
mod tests;