use std::{
collections::BTreeMap,
fmt,
};
use bunsen::{
data::{
builds::LookupExpr,
catalog::{
CatalogErrorExt,
CatalogName,
resolve::ResolvedBuild,
select::{
choose::{
SelectRequest,
SelectionContext,
},
query::{
LabeledStage,
SortKeys,
Stage,
},
state::{
DeriveTags,
DerivedKey,
SelectEnv,
},
},
},
},
errors::{
BunsenError,
BunsenResult,
LookupError,
},
};
use serde::{
Deserialize,
Serialize,
};
use serde_json::{
Value,
json,
};
use crate::{
asr::{
AsrFamily,
AsrKit,
Emission,
Streaming,
VadArgs,
},
support::{
builtin_catalog,
log_choice,
with_patch,
},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Mode {
Offline,
Live,
}
impl Mode {
pub fn command(self) -> &'static str {
match self {
Mode::Offline => "transcribe",
Mode::Live => "live",
}
}
}
#[derive(
Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum, Serialize, Deserialize,
)]
#[serde(rename_all = "lowercase")]
pub enum Speech {
En,
Multi,
}
#[derive(
Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum, Serialize, Deserialize,
)]
#[serde(rename_all = "lowercase")]
pub enum Task {
Transcribe,
Translate,
}
#[derive(
Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum, Serialize, Deserialize,
)]
#[serde(rename_all = "lowercase")]
pub enum Quality {
Fast,
Balanced,
Good,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Need {
pub speech: Speech,
pub task: Task,
pub quality: Quality,
}
impl fmt::Display for Need {
fn fmt(
&self,
f: &mut fmt::Formatter<'_>,
) -> fmt::Result {
use clap::ValueEnum;
let name = |v: Option<clap::builder::PossibleValue>| {
v.expect("no variant is skipped").get_name().to_string()
};
write!(
f,
"{}/{}/{}",
name(self.speech.to_possible_value()),
name(self.task.to_possible_value()),
name(self.quality.to_possible_value())
)
}
}
impl Need {
pub fn settled(self) -> Need {
self.settled_why().0
}
pub fn settled_why(self) -> (Need, Vec<&'static str>) {
let mut reasons = Vec::new();
let need = construct_config()
.implications
.iter()
.fold(self, |need, rule| {
if rule.when.matches(need) && rule.then.apply(need) != need {
reasons.push(rule.reason.as_str());
rule.then.apply(need)
} else {
need
}
});
(need, reasons)
}
}
#[derive(Clone, Debug)]
pub struct AsrRecipe {
pub engine: EngineSlot,
pub emission: Emission,
pub chunk_ms: usize,
}
#[derive(Clone, Debug)]
pub struct EngineSlot {
pub family: AsrFamily,
pub model: String,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ModeRecipe {
pub emission: Emission,
pub chunk_ms: usize,
#[serde(default)]
pub patch: Option<Value>,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct FamilyRecipes {
pub offline: ModeRecipe,
pub live: ModeRecipe,
}
impl FamilyRecipes {
pub fn get(
&self,
mode: Mode,
) -> &ModeRecipe {
match mode {
Mode::Offline => &self.offline,
Mode::Live => &self.live,
}
}
}
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AsrPreset {
pub name: String,
#[serde(default)]
pub aliases: Vec<String>,
pub description: String,
pub need: Need,
pub selection: Vec<LabeledStage>,
}
#[derive(Clone, Debug, Default, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SelectionPart {
#[serde(default)]
pub run: Vec<LabeledStage>,
#[serde(default)]
pub order: Option<SortKeys>,
}
impl AsrPreset {
pub fn recipe(
&self,
mode: Mode,
) -> BunsenResult<AsrRecipe> {
construct_config().pick(self, self.need.settled(), mode, None)
}
pub fn resolve(
&self,
mode: Mode,
) -> BunsenResult<AsrConstruct> {
self.recipe(mode)?
.resolve(&self.name, self.need, mode, None, None)
}
}
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Axis {
pub name: String,
pub description: String,
pub members: Vec<AxisMember>,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AxisMember {
pub name: String,
pub description: String,
}
impl Speech {
pub fn hears(
self,
speech: Speech,
) -> bool {
self == speech || (self == Speech::Multi && speech == Speech::En)
}
}
#[derive(Clone, Debug, Default, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct EngineTraits {
#[serde(default)]
pub language: Option<String>,
#[serde(default)]
pub tasks: Option<EngineTasks>,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct EngineTasks {
pub default: Task,
pub presets: BTreeMap<Task, String>,
pub patch: TaskPatch,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TaskPatch {
pub key: String,
pub values: BTreeMap<Task, String>,
}
impl EngineTasks {
pub fn does(
&self,
task: Task,
) -> bool {
self.presets.contains_key(&task)
}
pub fn set(
&self,
model: &str,
task: Task,
) -> BunsenResult<String> {
let mut expr = LookupExpr::parse(model)?;
expr.selection
.presets
.retain(|p| !self.presets.values().any(|t| t == p));
if task != self.default
&& let Some(preset) = self.presets.get(&task)
{
expr.selection.presets.push(preset.clone());
}
if let Some(patch) = expr
.selection
.patch
.as_mut()
.and_then(|p| p.as_object_mut())
{
patch.remove(&self.patch.key);
}
Ok(expr.to_string())
}
pub fn read(
&self,
model: &str,
) -> Task {
let Ok(expr) = LookupExpr::parse(model) else {
return self.default;
};
let patched = expr
.selection
.patch
.as_ref()
.and_then(|p| p.get(&self.patch.key))
.and_then(|t| t.as_str());
if let Some(value) = patched {
return self
.patch
.values
.iter()
.find(|(_, v)| v.as_str() == value)
.map_or(self.default, |(task, _)| *task);
}
self.presets
.iter()
.find(|(task, preset)| {
**task != self.default && expr.selection.presets.contains(preset)
})
.map_or(self.default, |(task, _)| *task)
}
}
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct LanguageRule {
pub speech: BTreeMap<String, Speech>,
pub otherwise: Speech,
}
impl LanguageRule {
pub fn speech(
&self,
language: &str,
) -> Speech {
self.speech
.iter()
.find(|(code, _)| code.eq_ignore_ascii_case(language))
.map_or(self.otherwise, |(_, speech)| *speech)
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NeedPattern {
#[serde(default)]
pub speech: Option<Speech>,
#[serde(default)]
pub task: Option<Task>,
#[serde(default)]
pub quality: Option<Quality>,
}
impl NeedPattern {
fn matches(
&self,
need: Need,
) -> bool {
self.speech.is_none_or(|s| s == need.speech)
&& self.task.is_none_or(|t| t == need.task)
&& self.quality.is_none_or(|q| q == need.quality)
}
fn apply(
&self,
need: Need,
) -> Need {
Need {
speech: self.speech.unwrap_or(need.speech),
task: self.task.unwrap_or(need.task),
quality: self.quality.unwrap_or(need.quality),
}
}
}
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Implication {
pub when: NeedPattern,
pub then: NeedPattern,
pub reason: String,
}
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AsrConstructConfig {
pub axes: Vec<Axis>,
pub presets: Vec<AsrPreset>,
pub selection: Vec<LabeledStage>,
pub order: SortKeys,
#[serde(default)]
pub qualities: BTreeMap<Quality, SelectionPart>,
#[serde(default)]
pub modes: BTreeMap<Mode, SelectionPart>,
pub implications: Vec<Implication>,
#[serde(default)]
pub engines: BTreeMap<AsrFamily, EngineTraits>,
pub language: LanguageRule,
pub vad: String,
pub recipes: BTreeMap<AsrFamily, FamilyRecipes>,
}
pub fn construct_config() -> &'static AsrConstructConfig {
static CATALOG: std::sync::OnceLock<AsrConstructConfig> = std::sync::OnceLock::new();
CATALOG.get_or_init(|| {
serde_saphyr::from_str(include_str!("asr_construct.yml"))
.unwrap_or_else(|e| panic!("the embedded asr_construct.yml: {e}"))
})
}
impl AsrConstructConfig {
pub fn engine(
&self,
family: AsrFamily,
) -> &EngineTraits {
static NONE: EngineTraits = EngineTraits {
language: None,
tasks: None,
};
self.engines.get(&family).unwrap_or(&NONE)
}
pub fn pick(
&self,
preset: &AsrPreset,
need: Need,
mode: Mode,
language: Option<&str>,
) -> BunsenResult<AsrRecipe> {
let quality = self.qualities.get(&need.quality);
let in_mode = self.modes.get(&mode);
let mut stages: Vec<LabeledStage> = preset.selection.clone();
for part in [quality, in_mode].into_iter().flatten() {
stages.extend(part.run.iter().cloned());
}
if need.task == Task::Translate {
stages.push(stage(json!({"keep": {"translate": true}})));
}
if let Some(language) = language {
stages.push(stage(
json!({"weigh": {"by": [{"match": {"language": language}, "else": 0.8}]}}),
));
}
let order = [in_mode, quality]
.into_iter()
.flatten()
.find_map(|part| part.order.clone())
.unwrap_or_else(|| self.order.clone());
stages.push(Stage::Order(order).into());
let builds = asr_builds()?;
let universe: Vec<CatalogName> = builds.iter().map(|(name, _)| name.clone()).collect();
let stack = builtin_catalog()?;
let steps: Vec<&dyn DeriveTags> = vec![&SpeechTags];
let env = SelectEnv::with_derive(&stack, steps)
.map_err(|e| BunsenError::policy(e.problem_message()))?;
let context = SelectionContext {
defaults: self.selection.clone(),
named: Vec::new(),
};
let mut request = SelectRequest::default();
for labeled in stages {
request
.stages
.push(bunsen::data::catalog::select::choose::OriginStage::labeled(
labeled,
bunsen::data::catalog::select::state::StageOrigin::Query,
));
}
let (chosen, run) = context
.choose(&env, Some(&universe), None, &request)
.map_err(|e| BunsenError::policy(e.problem_message()))?;
let name = chosen.build.name.clone();
let family = builds
.iter()
.find(|(n, _)| *n == name)
.map(|(_, f)| *f)
.expect("the choice is one of the universe's builds");
let recipe = self.recipes.get(&family).ok_or_else(|| {
BunsenError::invalid_resource(format!(
"the ASR table has no recipe for {}",
family.name()
))
})?;
let recipe = recipe.get(mode);
let mut model = name.to_string();
if let Some(patch) = &recipe.patch {
model = with_patch(&model, patch)?;
}
log::info!("preset {} ({need}, {})", preset.name, mode.command());
log_choice(&model, &run);
Ok(AsrRecipe {
engine: EngineSlot { family, model },
emission: recipe.emission,
chunk_ms: recipe.chunk_ms,
})
}
}
fn stage(value: Value) -> LabeledStage {
serde_json::from_value(value).expect("the construct's own stages are stages")
}
pub struct SpeechTags;
impl SpeechTags {
pub fn of(build: &ResolvedBuild) -> BTreeMap<String, Value> {
let mut tags = BTreeMap::new();
if let Some(wer) = build
.tag("scores")
.and_then(|s| s.get("wer.en"))
.and_then(Value::as_f64)
{
tags.insert("wer_en".to_string(), json!(wer));
}
let multilingual = build
.tag("language")
.and_then(Value::as_array)
.is_some_and(|tags| tags.len() > 1 || tags.iter().any(|t| t == "*"));
tags.insert("multilingual".to_string(), json!(multilingual));
tags
}
}
impl DeriveTags for SpeechTags {
fn keys(&self) -> Vec<DerivedKey> {
vec![
DerivedKey {
name: "wer_en".to_string(),
description: "the published English word error rate, from `scores`".to_string(),
},
DerivedKey {
name: "multilingual".to_string(),
description: "more than one language, or `*`".to_string(),
},
]
}
fn tags(
&self,
build: &ResolvedBuild,
) -> BTreeMap<String, Value> {
Self::of(build)
}
}
pub fn asr_builds() -> BunsenResult<Vec<(CatalogName, AsrFamily)>> {
let mut builds = Vec::new();
for family in AsrFamily::ALL {
for (_, row) in AsrKit::Asr(family).listing()?.rows {
builds.push((row.name, family));
}
}
Ok(builds)
}
pub const DEFAULT_PRESET: &str = "default";
pub fn presets() -> &'static [AsrPreset] {
&construct_config().presets
}
pub fn lookup(name: &str) -> BunsenResult<&'static AsrPreset> {
presets()
.iter()
.find(|p| p.name == name || p.aliases.iter().any(|a| a == name))
.ok_or_else(|| {
let names = presets()
.iter()
.flat_map(|p| std::iter::once(&p.name).chain(&p.aliases))
.cloned();
BunsenError::lookup(LookupError::missing("ASR preset", name).with_candidates(names))
})
}
#[derive(Clone, Debug)]
pub struct AsrConstruct {
pub preset: String,
pub need: Need,
pub mode: Mode,
pub family: AsrFamily,
pub model: String,
pub emission: Emission,
pub chunk_ms: usize,
pub vad: Option<String>,
}
impl AsrRecipe {
pub fn resolve(
&self,
preset: &str,
need: Need,
mode: Mode,
task: Option<Task>,
language: Option<&str>,
) -> BunsenResult<AsrConstruct> {
let engine = construct_config().engine(self.engine.family);
let mut model = self.engine.model.clone();
let task = task.unwrap_or(need.settled().task);
if let Some(tasks) = &engine.tasks
&& tasks.read(&model) != task
{
model = tasks.set(&model, task)?;
}
if let Some(language) = language {
if let Some(key) = &engine.language {
let mut patch = serde_json::Map::new();
patch.insert(key.clone(), serde_json::Value::from(language));
model = with_patch(&model, &serde_json::Value::Object(patch))?;
} else {
log::info!(
"preset {preset} runs {}, which finds the language itself: \
--language {language} not applied",
self.engine.family.name()
);
}
}
let mut resolved = AsrConstruct {
preset: preset.to_string(),
need: need.settled(),
mode,
family: self.engine.family,
model,
emission: self.emission,
chunk_ms: self.chunk_ms,
vad: VadArgs::default().slot(self.emission)?,
};
resolved.need.task = resolved.task();
Ok(resolved)
}
}
impl AsrConstruct {
pub fn task(&self) -> Task {
construct_config()
.engine(self.family)
.tasks
.as_ref()
.map_or(Task::Transcribe, |tasks| tasks.read(&self.model))
}
pub fn command_line(&self) -> Vec<String> {
let mut line: Vec<String> = [
"bunsen-tool",
"asr",
"family",
self.family.name(),
self.mode.command(),
"--model",
&self.model,
"--emission",
self.emission.name(),
"--chunk-ms",
]
.map(String::from)
.to_vec();
line.push(self.chunk_ms.to_string());
if let Some(vad) = &self.vad {
line.extend(["--vad".to_string(), vad.clone()]);
}
line
}
pub fn streaming(&self) -> Streaming {
Streaming {
emission: self.emission,
vad: self.vad.clone(),
chunk_ms: self.chunk_ms,
}
}
pub fn stamp(&self) -> Stamp {
Stamp {
preset: self.preset.clone(),
need: self.need,
recipe: AsrRecipeStamp {
family: self.family.name().to_string(),
model: self.model.clone(),
emission: self.emission.name().to_string(),
chunk_ms: self.chunk_ms,
vad: self.vad.clone(),
},
}
}
}
pub fn shell_line(words: &[String]) -> String {
words
.iter()
.map(|w| {
if !w.is_empty()
&& w.chars()
.all(|c| c.is_ascii_alphanumeric() || "-_./:=+,@".contains(c))
{
w.clone()
} else {
format!("'{}'", w.replace('\'', r"'\''"))
}
})
.collect::<Vec<_>>()
.join(" ")
}
#[derive(Clone, Debug, Serialize)]
pub struct Stamp {
pub preset: String,
pub need: Need,
pub recipe: AsrRecipeStamp,
}
#[derive(Clone, Debug, Serialize)]
pub struct AsrRecipeStamp {
pub family: String,
pub model: String,
pub emission: String,
pub chunk_ms: usize,
#[serde(skip_serializing_if = "Option::is_none")]
pub vad: Option<String>,
}
#[cfg(test)]
mod tests {
use super::*;
use crate::asr::AsrKit;
fn resolve(
name: &str,
mode: Mode,
task: Option<Task>,
language: Option<&str>,
) -> BunsenResult<AsrConstruct> {
let preset = lookup(name)?;
preset
.recipe(mode)?
.resolve(&preset.name, preset.need, mode, task, language)
}
#[test]
fn test_profiles_parse() {
let mut names = Vec::new();
for preset in presets() {
names.push(preset.name.as_str());
names.extend(preset.aliases.iter().map(String::as_str));
for mode in [Mode::Offline, Mode::Live] {
let resolved = resolve(&preset.name, mode, None, None).unwrap();
assert_eq!(resolved.need, preset.need.settled(), "{}", preset.name);
}
}
let mut unique = names.clone();
unique.sort();
unique.dedup();
assert_eq!(unique.len(), names.len(), "{names:?}");
assert_eq!(lookup(DEFAULT_PRESET).unwrap().name, "en");
assert!(lookup("klingon").is_err());
}
#[test]
fn test_picks() {
let pick = |preset: &str, quality: Quality, mode: Mode| {
let preset = lookup(preset).unwrap();
let need = Need {
quality,
..preset.need
};
let recipe = construct_config()
.pick(preset, need.settled(), mode, None)
.unwrap();
format!("{} {}", recipe.engine.family.name(), recipe.engine.model)
};
use Mode::{
Live,
Offline,
};
use Quality::{
Balanced,
Fast,
Good,
};
let grid = [
("en", Balanced, Offline, "parakeet fermion/phonon-2"),
("en", Balanced, Live, "parakeet fermion/phonon-2"),
("en", Fast, Offline, "parakeet fermion/phonon-2"),
("en", Good, Offline, "parakeet fermion/phonon-2"),
("multi", Balanced, Offline, "qwen3-asr qwen/qwen3-asr-1.7b"),
("multi", Balanced, Live, "qwen3-asr qwen/qwen3-asr-0.6b"),
("multi", Fast, Offline, "qwen3-asr qwen/qwen3-asr-0.6b"),
("multi", Good, Live, "qwen3-asr qwen/qwen3-asr-0.6b"),
(
"translate-en",
Balanced,
Offline,
"whisper openai/whisper/large/large-v3{beam_size: 5}",
),
(
"translate-en",
Balanced,
Live,
"whisper openai/whisper/tiny{beam_size: 1}",
),
];
for (preset, quality, mode, want) in grid {
assert_eq!(
pick(preset, quality, mode),
want,
"{preset} {quality:?} {mode:?}"
);
}
let multi = lookup("multi").unwrap();
let translating = Need {
task: Task::Translate,
..multi.need
};
let recipe = construct_config()
.pick(multi, translating, Offline, None)
.unwrap();
assert_eq!(
recipe.engine.model,
"openai/whisper/large/large-v3{beam_size: 5}"
);
let recipe = construct_config()
.pick(multi, multi.need, Offline, Some("de"))
.unwrap();
assert_ne!(recipe.engine.family, AsrFamily::Parakeet);
}
#[test]
fn test_builds_and_derived_keys() {
let builds = asr_builds().unwrap();
let family = |name: &str| {
builds
.iter()
.find(|(n, _)| n.to_string() == name)
.map(|(_, f)| *f)
.unwrap_or_else(|| panic!("{name}"))
};
assert_eq!(family("fermion/phonon-2"), AsrFamily::Parakeet);
assert_eq!(family("openai/whisper/tiny"), AsrFamily::Whisper);
let stack = builtin_catalog().unwrap();
let tags = |name: &str| {
let name = CatalogName::parse(name).unwrap();
SpeechTags::of(&stack.resolve_build(&name).unwrap())
};
let phonon = tags("fermion/phonon-2");
assert_eq!(phonon["wer_en"], 5.21);
assert_eq!(phonon["multilingual"], false);
assert_eq!(tags("qwen/qwen3-asr-1.7b")["multilingual"], true);
assert!(!tags("openai/whisper/tiny").contains_key("wer_en"));
}
fn selection(model: &str) -> (Vec<String>, Option<serde_json::Value>) {
let expr = LookupExpr::parse(model).unwrap();
(expr.selection.presets, expr.selection.patch)
}
#[test]
fn test_task_and_language() {
use serde_json::json;
let r = resolve("translate-en", Mode::Offline, None, Some("de")).unwrap();
assert_eq!(
selection(&r.model),
(
vec!["translate".to_string()],
Some(json!({"beam_size": 5, "language": "de"}))
)
);
assert_eq!(r.need.task, Task::Translate);
let r = resolve("translate-en", Mode::Live, Some(Task::Transcribe), None).unwrap();
assert_eq!(selection(&r.model), (vec![], Some(json!({"beam_size": 1}))));
assert_eq!(
(r.task(), r.need.task),
(Task::Transcribe, Task::Transcribe)
);
let r = resolve("en", Mode::Live, None, Some("de")).unwrap();
assert_eq!(r.model, "fermion/phonon-2");
let mut r = resolve("translate-en", Mode::Live, None, None).unwrap();
r.model = "openai/whisper/small{task: Transcribe}".to_string();
assert_eq!(r.task(), Task::Transcribe);
r.model = "openai/whisper/small{task: Translate}".to_string();
assert_eq!(r.task(), Task::Translate);
let tasks = construct_config()
.engine(AsrFamily::Whisper)
.tasks
.as_ref()
.unwrap();
assert_eq!(
selection(&tasks.set(&r.model, Task::Transcribe).unwrap()),
(vec![], Some(json!({})))
);
assert_eq!(
selection(
&tasks
.set("openai/whisper/small[transcribe]", Task::Translate)
.unwrap()
)
.0,
["translate"]
);
let parakeet = construct_config().engine(AsrFamily::Parakeet);
assert!(parakeet.tasks.is_none() && parakeet.language.is_none());
}
#[test]
fn test_command_line() {
let r = resolve("translate-en", Mode::Live, None, None).unwrap();
assert_eq!(
shell_line(&r.command_line()),
"bunsen-tool asr family whisper live --model 'openai/whisper/tiny[translate]{beam_size: 1}' \
--emission conservative --chunk-ms 250 --vad 'silero/vad-16k[faster-whisper]'"
);
assert_eq!(
shell_line(&["a b".into(), "it's".into(), "".into()]),
r"'a b' 'it'\''s' ''"
);
let stamp = serde_json::to_value(r.stamp()).unwrap();
assert_eq!(
stamp["recipe"]["model"],
"openai/whisper/tiny[translate]{beam_size: 1}"
);
assert_eq!(stamp["preset"], "translate-en");
assert_eq!(
stamp["need"],
serde_json::json!({"speech": "multi", "task": "translate", "quality": "balanced"})
);
}
#[test]
fn test_catalog() {
use bunsen::kits::speech::asr::{
parakeet::pretrained::default_parakeet_factory,
qwen3_asr::pretrained::default_qwen3_asr_factory,
voxtral::pretrained::default_voxtral_factory,
whisper::pretrained::default_whisper_factory,
};
use clap::ValueEnum;
let table = construct_config();
let members = |axis: &str| -> Vec<String> {
let axis = table.axes.iter().find(|a| a.name == axis).unwrap();
assert!(!axis.description.is_empty());
axis.members
.iter()
.inspect(|m| assert!(!m.description.is_empty(), "{}", m.name))
.map(|m| m.name.clone())
.collect()
};
let names = |values: Vec<Option<clap::builder::PossibleValue>>| -> Vec<String> {
values
.into_iter()
.map(|v| v.unwrap().get_name().to_string())
.collect()
};
assert_eq!(
members("speech"),
names(
Speech::value_variants()
.iter()
.map(|v| v.to_possible_value())
.collect()
)
);
assert_eq!(
members("task"),
names(
Task::value_variants()
.iter()
.map(|v| v.to_possible_value())
.collect()
)
);
assert_eq!(
members("quality"),
names(
Quality::value_variants()
.iter()
.map(|v| v.to_possible_value())
.collect()
)
);
for family in AsrFamily::ALL {
assert!(table.recipes.contains_key(&family), "{}", family.name());
}
for preset in presets() {
for mode in [Mode::Offline, Mode::Live] {
let recipe = preset.recipe(mode).unwrap();
let model = &recipe.engine.model;
let looked = match recipe.engine.family {
AsrFamily::Parakeet => default_parakeet_factory()
.and_then(|f| f.lookup(model))
.map(drop),
AsrFamily::Qwen3Asr => default_qwen3_asr_factory()
.and_then(|f| f.lookup(model))
.map(drop),
AsrFamily::Voxtral => default_voxtral_factory()
.and_then(|f| f.lookup(model))
.map(drop),
AsrFamily::Whisper => default_whisper_factory()
.and_then(|f| f.lookup(model))
.map(drop),
};
looked.unwrap_or_else(|e| panic!("{} {model}: {e}", preset.name));
}
}
for (family, engine) in &table.engines {
let Some(tasks) = &engine.tasks else {
continue;
};
let listing = AsrKit::Asr(*family).listing().unwrap();
for preset in tasks.presets.values() {
assert!(
listing
.rows
.iter()
.any(|(_, row)| row.presets.get(preset).is_some()),
"{} {preset}",
family.name()
);
}
assert!(tasks.does(tasks.default));
}
assert_eq!(table.language.speech("EN"), Speech::En);
assert_eq!(table.language.speech("de"), Speech::Multi);
assert!(Speech::Multi.hears(Speech::En));
assert!(!Speech::En.hears(Speech::Multi));
assert!(Speech::En.hears(Speech::En));
let (need, why) = Need {
speech: Speech::En,
task: Task::Translate,
quality: Quality::Fast,
}
.settled_why();
assert_eq!(need.task, Task::Transcribe);
assert_eq!(why, ["English speech translated to English is transcribed"]);
}
}