use std::{
io::Write,
sync::Arc,
time::Instant,
};
use bunsen::{
data::{
builds::{
BuildFactory,
BuildProvider,
BuildSummary,
ConstructInit,
DeferredBuild,
Loaded,
},
cache::verify_sha256,
catalog::{
ResolvedBuild,
lookup::LeafMatch,
},
formats::LoadPolicy,
resources::{
ResourceCache,
ResourceCacheOptions,
},
},
errors::{
BunsenResult,
sys_at,
},
kits::speech::{
asr::{
parakeet::{
ParakeetConstruct,
pretrained::{
DEFAULT_PARAKEET_MODEL,
default_parakeet_factory,
},
},
qwen3_asr::{
Qwen3AsrConstruct,
pretrained::{
DEFAULT_QWEN3_ASR_MODEL,
default_qwen3_asr_factory,
},
},
voxtral::{
VoxtralConstruct,
pretrained::{
DEFAULT_VOXTRAL_MODEL,
default_voxtral_factory,
},
},
whisper::{
driver::WhisperConstruct,
pretrained::default_whisper_factory,
},
},
diarization::sortformer::pretrained::{
DEFAULT_SORTFORMER_MODEL,
default_sortformer_factory,
},
},
};
use burn::tensor::Device;
use crate::asr::{
parakeet::ParakeetFlags,
qwen3_asr::Qwen3AsrFlags,
voxtral::VoxtralFlags,
whisper,
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum AsrFamily {
Parakeet,
Qwen3Asr,
Voxtral,
Whisper,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AsrKit {
Asr(AsrFamily),
Diarizer,
}
impl From<AsrFamily> for AsrKit {
fn from(family: AsrFamily) -> Self {
AsrKit::Asr(family)
}
}
#[derive(Clone, Debug)]
pub struct AsrFamilyListing {
pub rows: Vec<(String, ResolvedBuild)>,
pub providers: Vec<Arc<dyn BuildProvider>>,
pub unlisted: Vec<String>,
}
#[derive(Clone, Debug)]
pub enum AsrConstructWrapper {
Parakeet(Arc<ParakeetConstruct>),
Qwen3Asr(Arc<Qwen3AsrConstruct>),
Voxtral(Arc<VoxtralConstruct>),
Whisper(Arc<WhisperConstruct>),
}
impl<'de> serde::Deserialize<'de> for AsrFamily {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let name = String::deserialize(deserializer)?;
AsrFamily::from_name(&name).ok_or_else(|| {
let names: Vec<&str> = AsrFamily::ALL.iter().map(|f| f.name()).collect();
serde::de::Error::custom(format!("`{name}` is not a family: {}", names.join(", ")))
})
}
}
impl AsrFamily {
pub const ALL: [AsrFamily; 4] = [
AsrFamily::Parakeet,
AsrFamily::Qwen3Asr,
AsrFamily::Voxtral,
AsrFamily::Whisper,
];
pub fn from_name(name: &str) -> Option<AsrFamily> {
AsrFamily::ALL.into_iter().find(|f| f.name() == name)
}
pub fn name(self) -> &'static str {
match self {
AsrFamily::Parakeet => "parakeet",
AsrFamily::Qwen3Asr => "qwen3-asr",
AsrFamily::Voxtral => "voxtral",
AsrFamily::Whisper => "whisper",
}
}
pub fn default_model(self) -> &'static str {
match self {
AsrFamily::Parakeet => DEFAULT_PARAKEET_MODEL,
AsrFamily::Qwen3Asr => DEFAULT_QWEN3_ASR_MODEL,
AsrFamily::Voxtral => DEFAULT_VOXTRAL_MODEL,
AsrFamily::Whisper => "openai/base",
}
}
pub fn load<F: FamilyFlags>(
self,
spec: &str,
flags: &F,
cache: &ResourceCache,
device: &Device,
policy: LoadPolicy,
) -> BunsenResult<(AsrConstructWrapper, BuildSummary)> {
fn split<T>(
loaded: Loaded<T>,
wrap: impl FnOnce(Arc<T>) -> AsrConstructWrapper,
) -> (AsrConstructWrapper, BuildSummary) {
(wrap(loaded.handle), loaded.summary)
}
Ok(match self {
AsrFamily::Parakeet => split(
load_logged(
default_parakeet_factory()?.resolve(spec, cache)?,
cache,
device,
policy,
)?,
AsrConstructWrapper::Parakeet,
),
AsrFamily::Qwen3Asr => split(
load_logged(
default_qwen3_asr_factory()?.resolve(spec, cache)?,
cache,
device,
policy,
)?,
AsrConstructWrapper::Qwen3Asr,
),
AsrFamily::Voxtral => split(
load_logged(
default_voxtral_factory()?.resolve(spec, cache)?,
cache,
device,
policy,
)?,
AsrConstructWrapper::Voxtral,
),
AsrFamily::Whisper => split(
load_logged(
whisper::resolve(spec, flags.whisper(), cache)?,
cache,
device,
policy,
)?,
AsrConstructWrapper::Whisper,
),
})
}
}
impl AsrKit {
pub fn name(self) -> &'static str {
match self {
AsrKit::Asr(family) => family.name(),
AsrKit::Diarizer => "diarize",
}
}
pub fn default_model(self) -> &'static str {
match self {
AsrKit::Asr(family) => family.default_model(),
AsrKit::Diarizer => DEFAULT_SORTFORMER_MODEL,
}
}
pub fn lists(
self,
name: &str,
) -> BunsenResult<bool> {
let listing = self.listing()?;
Ok(listing.rows.iter().any(|(provider, row)| {
let bare = match name.split_once(':') {
Some((p, bare)) if p.eq_ignore_ascii_case(provider) => bare,
Some(_) => return false,
None => name,
};
row.name.matches_query(bare, LeafMatch::Exact) || row.answers_to(bare)
}))
}
pub fn listing(self) -> BunsenResult<AsrFamilyListing> {
fn split<H: ConstructInit>(factory: BuildFactory<H>) -> AsrFamilyListing {
let rows = factory.list();
let listed: Vec<&str> = rows.iter().map(|(p, _)| p.as_str()).collect();
let unlisted = factory
.providers()
.iter()
.map(|p| p.name().to_string())
.filter(|p| !listed.contains(&p.as_str()))
.collect();
AsrFamilyListing {
rows,
providers: factory.providers().to_vec(),
unlisted,
}
}
Ok(match self {
AsrKit::Asr(AsrFamily::Parakeet) => split(default_parakeet_factory()?),
AsrKit::Asr(AsrFamily::Qwen3Asr) => split(default_qwen3_asr_factory()?),
AsrKit::Asr(AsrFamily::Voxtral) => split(default_voxtral_factory()?),
AsrKit::Asr(AsrFamily::Whisper) => split(default_whisper_factory()?),
AsrKit::Diarizer => split(default_sortformer_factory()?),
})
}
pub fn fetch(
self,
names: &[String],
cache: &ResourceCache,
verify: bool,
out: &mut impl Write,
) -> BunsenResult<()> {
match self {
AsrKit::Asr(AsrFamily::Parakeet) => {
fetch_with(default_parakeet_factory()?, names, cache, verify, out)
}
AsrKit::Asr(AsrFamily::Qwen3Asr) => {
fetch_with(default_qwen3_asr_factory()?, names, cache, verify, out)
}
AsrKit::Asr(AsrFamily::Voxtral) => {
fetch_with(default_voxtral_factory()?, names, cache, verify, out)
}
AsrKit::Asr(AsrFamily::Whisper) => {
fetch_with(default_whisper_factory()?, names, cache, verify, out)
}
AsrKit::Diarizer => {
fetch_with(default_sortformer_factory()?, names, cache, verify, out)
}
}
}
}
pub fn fetch_with<H: ConstructInit>(
factory: BuildFactory<H>,
names: &[String],
cache: &ResourceCache,
verify: bool,
out: &mut impl Write,
) -> BunsenResult<()> {
let w = |e| sys_at("write to", "stdout")(e);
for name in names {
let model = factory.resolve(name, cache)?;
let map = model.plan(cache)?;
let loaded = cache.load(&map)?;
writeln!(out, "{}:", model.id()).map_err(w)?;
for (key, part) in loaded.iter() {
writeln!(
out,
" {key}: {} ({})",
part.path.display(),
part.provenance
)
.map_err(w)?;
if verify {
match map.get(key).and_then(|r| r.sha256.as_deref()) {
Some(sha256) => {
verify_sha256(&part.path, sha256)?;
writeln!(out, " sha256 {sha256} ok").map_err(w)?;
}
None => {
writeln!(out, " (unpinned; no digest to verify against)").map_err(w)?
}
}
}
}
}
Ok(())
}
pub fn load_logged<H: ConstructInit>(
deferred: DeferredBuild<H>,
cache: &ResourceCache,
device: &Device,
policy: LoadPolicy,
) -> BunsenResult<Loaded<H::Construct>> {
let t0 = Instant::now();
let loaded = deferred.load(cache, device, policy)?;
log::info!("model: {}", loaded.summary);
if let Some((_, row)) = deferred.model.build() {
log::info!(" {}", row.description);
if let Some(license) = &row.license {
log::info!(" license: {license}");
}
if let Some(origin) = &row.origin {
log::info!(" origin: {origin}");
}
}
for (key, part) in &loaded.resources.parts {
log::info!(" {key}: {} ({})", part.path.display(), part.provenance);
}
log::info!(" device: {device:?}; loaded in {:.1?}", t0.elapsed());
Ok(loaded)
}
pub trait FamilyFlags: std::fmt::Debug {
fn whisper(&self) -> Option<&whisper::WhisperFlags> {
None
}
fn cache_options(
&self,
options: ResourceCacheOptions,
) -> ResourceCacheOptions {
match self.whisper() {
Some(whisper) => whisper.cache_options(options),
None => options,
}
}
}
impl FamilyFlags for whisper::WhisperFlags {
fn whisper(&self) -> Option<&whisper::WhisperFlags> {
Some(self)
}
}
impl FamilyFlags for ParakeetFlags {}
impl FamilyFlags for Qwen3AsrFlags {}
impl FamilyFlags for VoxtralFlags {}
macro_rules! with_flags {
($family:expr, $flags:ident => $body:expr) => {
match $family {
$crate::asr::AsrFamily::Parakeet => {
let $flags = $crate::asr::parakeet::ParakeetFlags::default();
$body
}
$crate::asr::AsrFamily::Qwen3Asr => {
let $flags = $crate::asr::qwen3_asr::Qwen3AsrFlags::default();
$body
}
$crate::asr::AsrFamily::Voxtral => {
let $flags = $crate::asr::voxtral::VoxtralFlags::default();
$body
}
$crate::asr::AsrFamily::Whisper => {
let $flags = $crate::asr::whisper::WhisperFlags::default();
$body
}
}
};
}
pub(crate) use with_flags;
#[cfg(test)]
mod tests {
use bunsen_app::cache::WeightsCacheArgs;
use super::*;
#[test]
fn test_fetch_offline() {
let dir = tempfile::tempdir().unwrap();
let cache = WeightsCacheArgs {
cache_dir: Some(dir.path().to_path_buf()),
offline: true,
}
.init()
.unwrap();
let mut out = Vec::new();
for kit in [
AsrKit::Asr(AsrFamily::Parakeet),
AsrKit::Asr(AsrFamily::Qwen3Asr),
AsrKit::Asr(AsrFamily::Voxtral),
AsrKit::Asr(AsrFamily::Whisper),
AsrKit::Diarizer,
] {
let unknown = kit.fetch(&["no/such-model".into()], &cache, false, &mut out);
assert!(unknown.is_err(), "{}", kit.name());
let known = kit.fetch(&[kit.default_model().into()], &cache, false, &mut out);
assert!(known.is_err(), "{} fetched offline", kit.name());
}
assert!(cache.cached_files(&Default::default()).unwrap().is_empty());
}
}