use bunsen::{
data::builds::LookupExpr,
errors::{
BunsenError,
BunsenResult,
},
};
use crate::asr::{
AsrConstruct,
AsrFamily,
AsrKit,
AsrPreset,
DEFAULT_PRESET,
Emission,
Mode,
Need,
Quality,
Speech,
Task,
VadArgs,
construct_config,
lookup,
shell_line,
};
#[derive(clap::Args, Debug)]
pub struct AsrConstructArgs {
#[arg(long = "preset", value_name = "PRESET")]
pub preset: Option<String>,
#[arg(long, value_enum)]
pub speech: Option<Speech>,
#[arg(long, value_enum)]
pub task: Option<Task>,
#[arg(long, value_enum)]
pub quality: Option<Quality>,
#[arg(long)]
pub language: Option<String>,
#[arg(long, value_name = "EXPR")]
pub model: Option<String>,
#[clap(flatten)]
pub vad: VadArgs,
#[arg(long, value_enum)]
pub emission: Option<Emission>,
#[arg(long)]
pub chunk_ms: Option<usize>,
}
struct Asked {
name: String,
need: Need,
preset: &'static AsrPreset,
}
impl AsrConstructArgs {
fn speech(&self) -> BunsenResult<Option<Speech>> {
let config = construct_config();
let implied = self.language.as_deref().map(|l| config.language.speech(l));
match (self.speech, implied) {
(Some(given), Some(implied)) if !given.hears(implied) => {
Err(BunsenError::policy(format!(
"--speech {}, but --language {} is {} speech, which {} does not hear",
value_name(given),
self.language.as_deref().unwrap_or_default(),
value_name(implied),
value_name(given)
)))
}
(Some(speech), _) => Ok(Some(speech)),
(None, implied) => Ok(implied),
}
}
fn family(
&self,
picked: AsrFamily,
) -> BunsenResult<AsrFamily> {
let Some(model) = &self.model else {
return Ok(picked);
};
let name = LookupExpr::parse(model)?.name;
if AsrKit::Asr(picked).lists(&name)? {
return Ok(picked);
}
let mut others = Vec::new();
for family in AsrFamily::ALL {
if family != picked && AsrKit::Asr(family).lists(&name)? {
others.push(family);
}
}
match others.as_slice() {
[] => Ok(picked),
[family] => {
log::info!(
"--model {model}: a {} model, so {} runs in place of {}",
family.name(),
family.name(),
picked.name()
);
Ok(*family)
}
many => {
let names: Vec<&str> = many.iter().map(|f| f.name()).collect();
Err(BunsenError::policy(format!(
"--model {model}: {} each list it; `asr family <family>` names one",
names.join(" and ")
)))
}
}
}
fn speech_flag(&self) -> String {
match (self.speech, &self.language) {
(Some(speech), _) => format!("--speech {}", value_name(speech)),
(None, Some(language)) => format!("--language {language}"),
(None, None) => unreachable!("no flag set the speech"),
}
}
fn asked(&self) -> BunsenResult<Asked> {
let speech = self.speech()?;
let settle = |asked: Need| {
let (need, reasons) = asked.settled_why();
for reason in reasons {
log::info!("{asked}: {reason}");
}
need
};
let Some(name) = &self.preset else {
let preset = match (self.task, speech) {
(Some(Task::Translate), Some(Speech::Multi) | None) => lookup("translate-en")?,
(_, Some(Speech::Multi)) => lookup("multi")?,
(_, Some(Speech::En)) => lookup("en")?,
_ => lookup(DEFAULT_PRESET)?,
};
let need = settle(Need {
speech: speech.unwrap_or(preset.need.speech),
task: self.task.unwrap_or(preset.need.task),
quality: self.quality.unwrap_or(preset.need.quality),
});
let named = self.speech.is_some()
|| self.task.is_some()
|| self.quality.is_some()
|| self.language.is_some();
return Ok(Asked {
name: if named {
need.to_string()
} else {
preset.name.to_string()
},
need,
preset,
});
};
let preset = lookup(name)?;
if let Some(speech) = speech
&& !preset.need.speech.hears(speech)
{
return Err(BunsenError::policy(format!(
"preset {} hears {}; {} needs another preset, or none",
preset.name,
value_name(preset.need.speech),
self.speech_flag()
)));
}
let need = settle(Need {
speech: speech.unwrap_or(preset.need.speech),
task: self.task.unwrap_or(preset.need.task),
quality: self.quality.unwrap_or(preset.need.quality),
});
Ok(Asked {
name: preset.name.to_string(),
need,
preset,
})
}
pub fn resolve(
&self,
mode: Mode,
) -> BunsenResult<AsrConstruct> {
let asked = self.asked()?;
let mut recipe =
construct_config().pick(asked.preset, asked.need, mode, self.language.as_deref())?;
if let Some(model) = &self.model {
recipe.engine.family = self.family(recipe.engine.family)?;
recipe.engine.model = model.clone();
}
let mut resolved = recipe.resolve(
&asked.name,
asked.need,
mode,
Some(asked.need.task),
self.language.as_deref(),
)?;
if let Some(emission) = self.emission {
resolved.emission = emission;
}
resolved.vad = self.vad.slot(resolved.emission)?;
if let Some(chunk_ms) = self.chunk_ms {
resolved.chunk_ms = chunk_ms;
}
log::debug!(
"preset {} ({}): {}",
resolved.preset,
resolved.need,
shell_line(&resolved.command_line())
);
Ok(resolved)
}
}
fn value_name(value: impl clap::ValueEnum) -> String {
value
.to_possible_value()
.expect("no variant is skipped")
.get_name()
.to_string()
}
#[cfg(test)]
mod tests {
use clap::Parser;
use super::*;
#[derive(Parser, Debug)]
#[command(no_binary_name = true)]
struct Line {
#[command(flatten)]
args: AsrConstructArgs,
}
fn resolve(
line: &[&str],
mode: Mode,
) -> BunsenResult<AsrConstruct> {
Line::try_parse_from(line).unwrap().args.resolve(mode)
}
fn ran(
line: &[&str],
mode: Mode,
) -> BunsenResult<(String, String, String, Task)> {
let r = resolve(line, mode)?;
crate::asr::with_flags!(r.family, _flags => ());
assert_eq!(r.need.task, r.task(), "{line:?}");
Ok((
r.preset.clone(),
r.need.to_string(),
r.model.clone(),
r.task(),
))
}
#[test]
fn test_slots() {
let r = resolve(
&["--preset", "multi", "--model", "fermion/phonon-1"],
Mode::Offline,
)
.unwrap();
assert_eq!(
(r.family, r.model.as_str()),
(AsrFamily::Qwen3Asr, "fermion/phonon-1")
);
assert_eq!(r.vad, None);
let r = resolve(&["--model", "OpenAI/Small{beam_size: 2}"], Mode::Offline).unwrap();
assert_eq!(r.family, AsrFamily::Whisper);
assert_eq!(r.model, "OpenAI/Small{beam_size: 2}");
assert_eq!(r.task(), Task::Transcribe);
let r = resolve(
&[
"--preset",
"multi",
"--task",
"translate",
"--model",
"openai/whisper/small",
],
Mode::Live,
)
.unwrap();
assert_eq!(
(r.family, r.model.as_str(), r.need.task),
(
AsrFamily::Whisper,
"openai/whisper/small[translate]",
Task::Translate
)
);
let r = resolve(&["--preset", "multi", "--task", "translate"], Mode::Live).unwrap();
assert_eq!(
(r.family, r.model.as_str()),
(
AsrFamily::Whisper,
"openai/whisper/tiny[translate]{beam_size: 1}"
)
);
let r = resolve(&["--model", "hf:org/repo"], Mode::Offline).unwrap();
assert_eq!(r.family, AsrFamily::Parakeet);
let r = resolve(&["--model", "catalog:openai/whisper/tiny"], Mode::Offline).unwrap();
assert_eq!(r.family, AsrFamily::Whisper);
let table = construct_config().vad.as_str();
assert_eq!(
resolve(&[], Mode::Live).unwrap().vad.as_deref(),
Some(table)
);
let vad = "silero/vad-16k[silero]";
let r = resolve(&["--vad", vad], Mode::Live).unwrap();
assert_eq!(r.vad.as_deref(), Some(vad));
assert_eq!(r.stamp().recipe.vad.as_deref(), Some(vad));
assert!(r.command_line().ends_with(&["--vad".into(), vad.into()]));
let err = resolve(&["--vad", vad], Mode::Offline).unwrap_err();
assert!(
err.to_string()
.contains("`--vad` has no effect with `--emission offline`"),
"{err}"
);
assert!(resolve(&["--vad", vad, "--emission", "offline"], Mode::Live).is_err());
let r = resolve(&["--vad", vad, "--emission", "conservative"], Mode::Offline).unwrap();
assert_eq!(r.vad.as_deref(), Some(vad));
assert_eq!(
resolve(&["--emission", "offline"], Mode::Live).unwrap().vad,
None
);
}
#[test]
fn test_rules() {
use Mode::{
Live,
Offline,
};
use Task::{
Transcribe,
Translate,
};
const PHONON: &str = "fermion/phonon-2";
const QWEN: &str = "qwen/qwen3-asr-1.7b";
const QWEN_LIVE: &str = "qwen/qwen3-asr-0.6b";
const LARGE: &str = "openai/whisper/large/large-v3[translate]{beam_size: 5}";
const TINY: &str = "openai/whisper/tiny[translate]{beam_size: 1}";
const LARGE_DE: &str =
"openai/whisper/large/large-v3[translate]{beam_size: 5, language: de}";
const LARGE_TRANSCRIBE: &str = "openai/whisper/large/large-v3{beam_size: 5}";
const TINY_TRANSCRIBE: &str = "openai/whisper/tiny{beam_size: 1}";
const TINY_EN: &str = "openai/whisper/tiny{beam_size: 1, language: en}";
type Ran<'a> = Result<(&'a str, &'a str, &'a str, Task), &'a str>;
let rows: &[(&[&str], Mode, Ran)] = &[
(
&[],
Offline,
Ok(("en", "en/transcribe/balanced", PHONON, Transcribe)),
),
(
&[],
Live,
Ok(("en", "en/transcribe/balanced", PHONON, Transcribe)),
),
(
&["--language", "de"],
Offline,
Ok((
"multi/transcribe/balanced",
"multi/transcribe/balanced",
QWEN,
Transcribe,
)),
),
(
&["--language", "en"],
Offline,
Ok((
"en/transcribe/balanced",
"en/transcribe/balanced",
PHONON,
Transcribe,
)),
),
(
&["--language", "de", "--task", "translate"],
Offline,
Ok((
"multi/translate/balanced",
"multi/translate/balanced",
LARGE_DE,
Translate,
)),
),
(
&["--speech", "multi", "--language", "en"],
Offline,
Ok((
"multi/transcribe/balanced",
"multi/transcribe/balanced",
QWEN,
Transcribe,
)),
),
(
&["--speech", "en", "--language", "de"],
Offline,
Err("is multi speech, which en does not hear"),
),
(
&["--task", "transcribe"],
Offline,
Ok((
"en/transcribe/balanced",
"en/transcribe/balanced",
PHONON,
Transcribe,
)),
),
(
&["--task", "translate"],
Offline,
Ok((
"multi/translate/balanced",
"multi/translate/balanced",
LARGE,
Translate,
)),
),
(
&["--task", "translate"],
Live,
Ok((
"multi/translate/balanced",
"multi/translate/balanced",
TINY,
Translate,
)),
),
(
&["--speech", "multi"],
Offline,
Ok((
"multi/transcribe/balanced",
"multi/transcribe/balanced",
QWEN,
Transcribe,
)),
),
(
&["--speech", "multi", "--quality", "fast"],
Offline,
Ok((
"multi/transcribe/fast",
"multi/transcribe/fast",
QWEN_LIVE,
Transcribe,
)),
),
(
&["--speech", "multi", "--quality", "fast"],
Live,
Ok((
"multi/transcribe/fast",
"multi/transcribe/fast",
QWEN_LIVE,
Transcribe,
)),
),
(
&["--speech", "en", "--task", "translate"],
Offline,
Ok((
"en/transcribe/balanced",
"en/transcribe/balanced",
PHONON,
Transcribe,
)),
),
(
&["--language", "en", "--task", "translate"],
Live,
Ok((
"en/transcribe/balanced",
"en/transcribe/balanced",
PHONON,
Transcribe,
)),
),
(
&["--preset", "en", "--task", "translate"],
Offline,
Ok(("en", "en/transcribe/balanced", PHONON, Transcribe)),
),
(
&["--preset", "translate-en", "--speech", "en"],
Offline,
Ok((
"translate-en",
"en/transcribe/balanced",
LARGE_TRANSCRIBE,
Transcribe,
)),
),
(
&["--preset", "translate-en", "--language", "en"],
Live,
Ok((
"translate-en",
"en/transcribe/balanced",
TINY_EN,
Transcribe,
)),
),
(
&["--preset", "multi", "--quality", "fast"],
Offline,
Ok(("multi", "multi/transcribe/fast", QWEN_LIVE, Transcribe)),
),
(
&["--preset", "multi", "--speech", "en"],
Live,
Ok(("multi", "en/transcribe/balanced", QWEN_LIVE, Transcribe)),
),
(
&["--preset", "multi", "--language", "de"],
Offline,
Ok(("multi", "multi/transcribe/balanced", QWEN, Transcribe)),
),
(
&["--preset", "translate-en", "--language", "de"],
Offline,
Ok((
"translate-en",
"multi/translate/balanced",
LARGE_DE,
Translate,
)),
),
(
&["--preset", "en", "--speech", "multi"],
Live,
Err("preset en hears en"),
),
(
&["--preset", "en", "--language", "de"],
Offline,
Err("--language de needs another preset"),
),
(
&["--preset", "translate-en", "--task", "transcribe"],
Live,
Ok((
"translate-en",
"multi/transcribe/balanced",
TINY_TRANSCRIBE,
Transcribe,
)),
),
(
&[
"--preset",
"translate-en",
"--model",
"openai/whisper/small{task: Translate}",
],
Live,
Ok((
"translate-en",
"multi/translate/balanced",
"openai/whisper/small{task: Translate}",
Translate,
)),
),
(
&["--preset", "multi", "--task", "transcribe"],
Live,
Ok(("multi", "multi/transcribe/balanced", QWEN_LIVE, Transcribe)),
),
(
&["--preset", "multi", "--task", "translate"],
Live,
Ok(("multi", "multi/translate/balanced", TINY, Translate)),
),
];
for (line, mode, expect) in rows {
let got = ran(line, *mode);
match (expect, got) {
(Ok((preset, need, model, task)), Ok(got)) => assert_eq!(
(got.0.as_str(), got.1.as_str(), got.2.as_str(), got.3),
(*preset, *need, *model, *task),
"{line:?} {mode:?}"
),
(Err(message), Err(e)) => {
assert!(e.to_string().contains(message), "{line:?}: {e}")
}
(expect, got) => panic!("{line:?} {mode:?}: expected {expect:?}, got {got:?}"),
}
}
}
#[test]
fn test_rules_hold_everywhere() {
let mut ran_lines = 0;
for preset in [None, Some("en"), Some("multi"), Some("translate-en")] {
for speech in [None, Some("en"), Some("multi")] {
for task in [None, Some("transcribe"), Some("translate")] {
for language in [None, Some("en"), Some("de")] {
for mode in [Mode::Offline, Mode::Live] {
let mut line = Vec::new();
for (flag, value) in [
("--preset", preset),
("--speech", speech),
("--task", task),
("--language", language),
] {
if let Some(value) = value {
line.extend([flag, value]);
}
}
let r = match resolve(&line, mode) {
Ok(r) => r,
Err(e) => {
let e = e.to_string();
assert!(
e.contains("needs another preset")
|| e.contains("does not hear"),
"{line:?}: {e}"
);
continue;
}
};
ran_lines += 1;
let english = match (speech, language, preset) {
(Some(speech), _, _) => speech == "en",
(None, Some(language), _) => language == "en",
(None, None, Some(preset)) => preset == "en",
(None, None, None) => task != Some("translate"),
};
let asked = match (task, preset) {
(Some(task), _) => task == "translate",
(None, preset) => preset == Some("translate-en"),
};
let want = if asked && !english {
Task::Translate
} else {
Task::Transcribe
};
assert_eq!(r.task(), want, "{line:?} {mode:?}");
assert_eq!(r.need.task, want, "{line:?} {mode:?}");
if language == Some("de") {
assert_eq!(r.need.speech, Speech::Multi, "{line:?}");
assert_ne!(r.family, AsrFamily::Parakeet, "{line:?}");
}
}
}
}
}
}
assert_eq!(ran_lines, 2 * (108 - 24));
}
}