use std::collections::BTreeMap;
use anyhow::{Context, Result};
use serde::Deserialize;
use super::client::HttpStatusError;
use super::oci;
#[derive(Debug, Clone, Deserialize)]
pub struct HfFile {
pub path: String,
#[serde(default)]
pub size: i64,
#[serde(default, rename = "type")]
pub kind: String, #[serde(default)]
pub lfs: Option<HfLfs>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct HfLfs {
pub oid: String,
}
pub(crate) async fn get_json<T: serde::de::DeserializeOwned>(
client: &reqwest::Client,
url: &str,
token: Option<&str>,
) -> Result<T> {
let body = super::client::probe(&format!("GET {url}"), || async {
send_ok(client, url, token)
.await?
.bytes()
.await
.with_context(|| format!("read body of GET {url}"))
})
.await?;
serde_json::from_slice(&body).with_context(|| format!("decode JSON from {url}"))
}
pub(crate) async fn get_json_quiet<T: serde::de::DeserializeOwned>(
client: &reqwest::Client,
url: &str,
token: Option<&str>,
) -> Option<T> {
let body = send_ok(client, url, token).await.ok()?.bytes().await.ok()?;
serde_json::from_slice(&body).ok()
}
pub(crate) async fn get_prefix(
client: &reqwest::Client,
url: &str,
token: Option<&str>,
max: usize,
) -> Result<Vec<u8>> {
super::client::probe(&format!("GET {url}"), || async {
let mut resp = send_ok(client, url, token).await?;
let mut body = Vec::new();
while body.len() < max {
let chunk = resp
.chunk()
.await
.with_context(|| format!("read body of GET {url}"))?;
let Some(chunk) = chunk else { break };
body.extend_from_slice(&chunk);
}
body.truncate(max);
Ok(body)
})
.await
}
async fn send_ok(
client: &reqwest::Client,
url: &str,
token: Option<&str>,
) -> Result<reqwest::Response> {
let mut req = client.get(url);
if let Some(t) = token {
req = req.bearer_auth(t);
}
let resp = req.send().await.with_context(|| format!("GET {url}"))?;
let status = resp.status();
if status != reqwest::StatusCode::OK {
let headers = resp.headers().clone();
return Err(HttpStatusError::new(format!("GET {url}"), status.as_u16(), &headers).into());
}
Ok(resp)
}
#[derive(Debug, Deserialize, Default)]
pub struct ModelInfo {
#[serde(default)]
sha: String,
#[serde(default)]
pub tags: Vec<String>,
#[serde(default, rename = "cardData")]
card_data: CardData,
#[serde(default)]
pub downloads: Option<u64>,
#[serde(default)]
pub likes: Option<u64>,
#[serde(default, rename = "lastModified")]
pub last_modified: Option<String>,
#[serde(default)]
pub pipeline_tag: Option<String>,
#[serde(default)]
gated: serde_json::Value,
}
#[derive(Debug, Deserialize, Default)]
struct CardData {
#[serde(default)]
license: String,
}
impl ModelInfo {
pub fn gated(&self) -> bool {
!matches!(
self.gated,
serde_json::Value::Null | serde_json::Value::Bool(false)
)
}
pub fn sha(&self) -> &str {
&self.sha
}
pub fn commit(&self) -> &str {
if self.sha.is_empty() {
"main"
} else {
&self.sha
}
}
pub fn license(&self) -> Option<String> {
if !self.card_data.license.is_empty() {
if let Some(id) = normalize_spdx_license(&self.card_data.license) {
return Some(id);
}
}
for tag in &self.tags {
if let Some(slug) = tag.strip_prefix("license:") {
if !slug.is_empty() {
if let Some(id) = normalize_spdx_license(slug) {
return Some(id);
}
}
}
}
None
}
}
fn normalize_spdx_license(slug: &str) -> Option<String> {
let slug = slug.trim().to_lowercase();
match slug.as_str() {
"apache-2.0" => Some("Apache-2.0".to_string()),
"mit" => Some("MIT".to_string()),
"bsd-2-clause" => Some("BSD-2-Clause".to_string()),
"bsd-3-clause" => Some("BSD-3-Clause".to_string()),
"gpl-2.0" => Some("GPL-2.0-only".to_string()),
"gpl-3.0" => Some("GPL-3.0-only".to_string()),
"lgpl-2.1" => Some("LGPL-2.1-only".to_string()),
"lgpl-3.0" => Some("LGPL-3.0-only".to_string()),
"mpl-2.0" => Some("MPL-2.0".to_string()),
"cc-by-4.0" => Some("CC-BY-4.0".to_string()),
"cc-by-sa-4.0" => Some("CC-BY-SA-4.0".to_string()),
"cc0-1.0" => Some("CC0-1.0".to_string()),
"other" | "unknown" => None,
other => Some(other.to_string()),
}
}
pub async fn fetch_model_info(
client: &reqwest::Client,
endpoint: &str,
owner: &str,
repo: &str,
token: Option<&str>,
) -> Result<ModelInfo> {
let url = format!("{endpoint}api/models/{owner}/{repo}");
get_json(client, &url, token)
.await
.context("HF model info")
.map_err(|e| {
if repo_is_missing(&e, token.is_some()) {
crate::storage::oci::source_not_found(e)
} else {
e
}
})
}
fn repo_is_missing(err: &anyhow::Error, had_token: bool) -> bool {
err.chain()
.filter_map(|e| e.downcast_ref::<HttpStatusError>())
.any(|e| e.status == 404 || (e.status == 401 && !had_token))
}
pub async fn fetch_files(
client: &reqwest::Client,
endpoint: &str,
owner: &str,
repo: &str,
commit: &str,
token: Option<&str>,
) -> Result<Vec<HfFile>> {
let url = files_url(endpoint, owner, repo, commit);
get_json(client, &url, token).await.context("HF file list")
}
pub(crate) fn files_url(endpoint: &str, owner: &str, repo: &str, commit: &str) -> String {
format!("{endpoint}api/models/{owner}/{repo}/tree/{commit}?recursive=true")
}
#[derive(Debug, Clone, Deserialize)]
pub struct SearchHit {
pub id: String,
#[serde(default)]
pub likes: u64,
#[serde(default)]
pub downloads: u64,
#[serde(default, rename = "lastModified")]
pub last_modified: Option<String>,
}
pub async fn search_models(
client: &reqwest::Client,
endpoint: &str,
query: &str,
limit: u32,
token: Option<&str>,
) -> Result<Vec<SearchHit>> {
let limit = limit.to_string();
let url = reqwest::Url::parse_with_params(
&format!("{endpoint}api/models"),
[
("search", query),
("limit", limit.as_str()),
("sort", "downloads"),
("direction", "-1"),
("expand[]", "lastModified"),
("expand[]", "downloads"),
("expand[]", "likes"),
],
)
.context("build HF search URL")?;
get_json(client, url.as_str(), token)
.await
.context("HF model search")
}
const QUANT_PREFERENCE: &[&str] = &[
"Q4_K_M", "Q4_K_S", "Q5_K_M", "Q5_K_S", "Q8_0", "Q4_0", "Q6_K", "Q2_K",
];
fn is_model_gguf(path: &str) -> bool {
let lower = path.to_lowercase();
lower.ends_with(".gguf") && !lower.contains("mmproj") && !lower.contains("imatrix")
}
fn parse_gguf_shard(path: &str) -> Option<(String, u32, u32)> {
let base = path.rsplit('/').next().unwrap_or(path).to_lowercase();
let base = base.strip_suffix(".gguf")?;
let (rest, total_str) = base.rsplit_once("-of-")?;
let total: u32 = total_str.parse().ok()?;
let (prefix, index_str) = rest.rsplit_once('-')?;
let index: u32 = index_str.parse().ok()?;
Some((prefix.to_string(), index, total))
}
fn dirname(path: &str) -> &str {
path.rsplit_once('/').map(|(d, _)| d).unwrap_or("")
}
fn gguf_shards(models: &[HfFile], chosen: &HfFile) -> Result<Vec<HfFile>> {
let Some((prefix, _, total)) = parse_gguf_shard(&chosen.path) else {
return Ok(vec![chosen.clone()]);
};
let chosen_dir = dirname(&chosen.path);
let mut shards: Vec<(u32, HfFile)> = models
.iter()
.filter_map(|f| {
let (p, idx, t) = parse_gguf_shard(&f.path)?;
(p == prefix && t == total && dirname(&f.path) == chosen_dir).then(|| (idx, f.clone()))
})
.collect();
shards.sort_by_key(|(idx, _)| *idx);
shards.dedup_by_key(|(idx, _)| *idx);
if shards.len() as u32 != total {
anyhow::bail!(
"incomplete GGUF split {prefix:?}: found {} of {total} shards",
shards.len()
);
}
Ok(shards.into_iter().map(|(_, f)| f).collect())
}
pub fn select_gguf(files: &[HfFile], tag: &str) -> Result<Vec<HfFile>> {
let models: Vec<HfFile> = files
.iter()
.filter(|f| f.kind == "file" && is_model_gguf(&f.path))
.cloned()
.collect();
if models.is_empty() {
anyhow::bail!("no GGUF model files found in repository");
}
if !tag.is_empty() && tag != "latest" {
let upper = tag.to_uppercase();
if let Some(f) = models
.iter()
.find(|f| f.path.to_uppercase().contains(&upper))
{
return gguf_shards(&models, f);
}
let list: String = models.iter().map(|f| format!(" {}\n", f.path)).collect();
anyhow::bail!("no GGUF file matching {tag:?} found; available:\n{list}");
}
for pref in QUANT_PREFERENCE {
if let Some(f) = models.iter().find(|f| f.path.to_uppercase().contains(pref)) {
return gguf_shards(&models, f);
}
}
let smallest = models
.iter()
.min_by_key(|f| f.size)
.expect("models is non-empty");
gguf_shards(&models, smallest)
}
fn is_weights_file(lower: &str) -> bool {
lower.ends_with(".gguf") || lower.ends_with(".safetensors")
}
pub fn is_diffusion_repo(files: &[HfFile]) -> bool {
files.iter().any(|f| {
let name = basename_lower(&f.path);
f.kind == "file"
&& is_weights_file(&name)
&& (name.contains("video_vae")
|| name.contains("_vae.")
|| name.contains("embeddings_connectors"))
})
}
fn basename_lower(path: &str) -> String {
path.rsplit('/').next().unwrap_or(path).to_lowercase()
}
pub fn is_diffusers_repo(files: &[HfFile]) -> bool {
files
.iter()
.any(|f| f.kind == "file" && f.path == crate::modelpack::DIFFUSERS_MODEL_INDEX)
&& files
.iter()
.any(|f| f.kind == "file" && basename_lower(&f.path).ends_with(".safetensors"))
}
const VIDEO_PIPELINE_HINTS: &[&str] = &[
"video",
"omni",
"cosmos",
"wan",
"ltx",
"magi",
"helios",
"lingbot",
"longcat",
"minimaxh3",
];
pub fn diffusers_outputs(class_name: Option<&str>) -> Vec<&'static str> {
let lower = class_name.unwrap_or("").to_lowercase();
if VIDEO_PIPELINE_HINTS.iter().any(|h| lower.contains(h)) {
vec!["image", "video"]
} else {
vec!["image"]
}
}
pub async fn fetch_diffusers_pipeline_class(
client: &reqwest::Client,
endpoint: &str,
owner: &str,
repo: &str,
commit: &str,
token: Option<&str>,
) -> Option<String> {
let url = format!(
"{endpoint}{owner}/{repo}/resolve/{commit}/{}",
crate::modelpack::DIFFUSERS_MODEL_INDEX
);
pipeline_class(&get_json(client, &url, token).await.ok()?)
}
fn pipeline_class(index: &serde_json::Value) -> Option<String> {
index.get("_class_name")?.as_str().map(str::to_string)
}
pub fn diffusers_pipeline_class(
layout_dir: &std::path::Path,
layers: &[oci::Descriptor],
) -> Option<String> {
let index = layers.iter().find(|d| {
d.annotations
.as_ref()
.and_then(|a| a.get(oci::ANNOTATION_FILEPATH))
.is_some_and(|p| p == crate::modelpack::DIFFUSERS_MODEL_INDEX)
})?;
let hex = index.digest.strip_prefix("sha256:")?;
let bytes = std::fs::read(layout_dir.join("blobs").join("sha256").join(hex)).ok()?;
pipeline_class(&serde_json::from_slice(&bytes).ok()?)
}
pub fn select_diffusion_gguf(files: &[HfFile], tag: &str) -> Result<Vec<HfFile>> {
let files: Vec<HfFile> = files
.iter()
.filter(|f| !is_diffusion_sidecar(&basename_lower(&f.path)))
.cloned()
.collect();
if tag.is_empty() || tag == "latest" {
let models: Vec<&HfFile> = files
.iter()
.filter(|f| {
f.kind == "file" && is_model_gguf(&f.path) && parse_gguf_shard(&f.path).is_none()
})
.collect();
for pref in QUANT_PREFERENCE {
let matching: Vec<&&HfFile> = models
.iter()
.filter(|f| f.path.to_uppercase().contains(pref))
.collect();
if let Some(f) = matching
.iter()
.find(|f| f.path.to_lowercase().contains("distilled"))
.or(matching.first())
{
return Ok(vec![(**f).clone()]);
}
}
}
select_gguf(&files, tag)
}
fn is_diffusion_sidecar(name: &str) -> bool {
["vae", "connector", "text_encoder", "embeddings"]
.iter()
.any(|k| name.contains(k))
}
pub struct DiffusionPlan {
pub sidecars: Vec<(&'static str, HfFile)>,
pub outputs: Vec<&'static str>,
pub text_encoder: Option<&'static str>,
}
pub fn diffusion_plan(files: &[HfFile], model_path: &str) -> DiffusionPlan {
let pick = |k| select_diffusion_sidecar(files, model_path, k);
let candidates = [
(
"vae",
pick("video_vae")
.or_else(|| pick("_vae.").filter(|f| !f.path.to_lowercase().contains("audio_vae"))),
),
("audio_vae", pick("audio_vae")),
("text_proj", pick("embeddings_connectors")),
];
let mut plan = DiffusionPlan {
sidecars: Vec::new(),
outputs: Vec::new(),
text_encoder: diffusion_default_text_encoder(model_path),
};
for (role, file) in candidates {
let Some(file) = file else { continue };
match role {
"vae" => plan.outputs.extend(["image", "video"]),
"audio_vae" => plan.outputs.push("audio"),
_ => {}
}
plan.sidecars.push((role, file));
}
plan
}
pub fn sidecar_layer(mut d: oci::Descriptor, file: &HfFile, role: &str) -> oci::Descriptor {
d.media_type = safetensors_media_type(&file.path).to_string();
let name = file
.path
.rsplit('/')
.next()
.unwrap_or(&file.path)
.to_string();
d.annotations = Some(BTreeMap::from([
(oci::ANNOTATION_FILEPATH.to_string(), name),
(oci::ANNOTATION_ROLE.to_string(), role.to_string()),
]));
d
}
pub fn select_diffusion_sidecar(
files: &[HfFile],
model_path: &str,
keyword: &str,
) -> Option<HfFile> {
let model_name = basename_lower(model_path);
let mut best: Option<(usize, &HfFile)> = None;
for f in files.iter().filter(|f| f.kind == "file") {
let name = basename_lower(&f.path);
if !is_weights_file(&name) || !name.contains(keyword) {
continue;
}
let common = name
.bytes()
.zip(model_name.bytes())
.take_while(|(a, b)| a == b)
.count();
if best.is_none_or(|(c, _)| common > c) {
best = Some((common, f));
}
}
best.map(|(_, f)| f.clone())
}
pub fn diffusion_default_text_encoder(model_path: &str) -> Option<&'static str> {
let name = basename_lower(model_path);
if name.contains("ltx-2.5") || name.contains("ltx-2-5") {
return None;
}
if name.contains("ltx-2") || name.contains("ltx2") {
return Some("ggml-org/gemma-3-12b-it-GGUF:Q4_K_M");
}
None
}
const MMPROJ_PREFERENCE: &[&str] = &["F16", "BF16", "F32"];
pub fn select_mmproj(files: &[HfFile]) -> Option<HfFile> {
let candidates: Vec<&HfFile> = files
.iter()
.filter(|f| {
f.kind == "file"
&& f.path.to_lowercase().contains("mmproj")
&& f.path.to_lowercase().ends_with(".gguf")
})
.collect();
for pref in MMPROJ_PREFERENCE {
for f in &candidates {
let base = f.path.rsplit('/').next().unwrap_or(&f.path).to_uppercase();
if base == format!("{pref}.GGUF") || base.ends_with(&format!("-{pref}.GGUF")) {
return Some((*f).clone());
}
}
}
candidates.first().map(|f| (*f).clone())
}
const LICENSE_FILENAMES: &[&str] = &["LICENSE", "LICENSE.txt", "LICENSE.md"];
pub fn select_license_file(files: &[HfFile]) -> Option<HfFile> {
for want in LICENSE_FILENAMES {
if let Some(f) = files
.iter()
.find(|f| f.kind == "file" && f.path.eq_ignore_ascii_case(want))
{
return Some(f.clone());
}
}
None
}
pub fn safetensors_media_type(path: &str) -> &'static str {
let ext = path.rsplit('.').next().unwrap_or("").to_lowercase();
match ext.as_str() {
"safetensors" | "bin" | "pt" | "pth" => oci::MEDIA_TYPE_MODEL_WEIGHT_RAW,
"json" | "model" | "txt" | "tiktoken" | "jinja" => oci::MEDIA_TYPE_MODEL_WEIGHT_CONFIG_RAW,
_ => oci::MEDIA_TYPE_MODEL_DOC_RAW,
}
}
fn should_download_safetensors(path: &str) -> bool {
let base = path.rsplit('/').next().unwrap_or(path).to_lowercase();
if base.starts_with('.') {
return false;
}
let ext = base.rsplit('.').next().unwrap_or("");
if matches!(
ext,
"safetensors" | "bin" | "pt" | "pth" | "json" | "model" | "txt" | "tiktoken" | "jinja"
) {
return true;
}
matches!(
base.as_str(),
"readme.md" | "license" | "licence" | "license.txt" | "licence.txt"
)
}
pub fn select_downloadable_hf_files(files: &[HfFile]) -> Vec<HfFile> {
files
.iter()
.filter(|f| f.kind == "file" && should_download_safetensors(&f.path))
.cloned()
.collect()
}
pub fn parse_hf_ref(reference: &str) -> Result<(String, String, String, String)> {
let last_colon = reference.rfind(':').map(|i| i as isize).unwrap_or(-1);
let last_slash = reference.rfind('/').map(|i| i as isize).unwrap_or(-1);
let (rest, tag) = if last_colon > last_slash {
(
&reference[..last_colon as usize],
reference[last_colon as usize + 1..].to_string(),
)
} else {
(reference, String::new())
};
let parts: Vec<&str> = rest.splitn(3, '/').collect();
let [host, owner, repo] = parts[..] else {
anyhow::bail!("invalid HuggingFace reference {reference:?}: expected host/owner/repo");
};
Ok((host.to_string(), owner.to_string(), repo.to_string(), tag))
}
#[allow(dead_code)]
pub type Annotations = BTreeMap<String, String>;
#[cfg(test)]
mod tests {
use super::*;
fn file(path: &str, size: i64) -> HfFile {
HfFile {
path: path.to_string(),
size,
kind: "file".to_string(),
lfs: None,
}
}
async fn hub_answering(status: u16) -> String {
let status = axum::http::StatusCode::from_u16(status).unwrap();
let app = axum::Router::new().fallback(move || async move { (status, "{}") });
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
format!("http://127.0.0.1:{port}/")
}
#[tokio::test]
async fn a_repo_the_hub_says_is_missing_is_marked_as_such() {
let client = reqwest::Client::new();
for (status, token, missing) in [
(404, None, true),
(404, Some("hf_token"), true),
(401, None, true),
(401, Some("hf_token"), false),
(403, None, false),
(500, None, false),
] {
let endpoint = hub_answering(status).await;
let err = fetch_model_info(&client, &endpoint, "owner", "repo", token)
.await
.unwrap_err();
assert_eq!(
crate::storage::oci::is_source_not_found(&err),
missing,
"HTTP {status}, token {token:?}"
);
let message = format!("{err:#}");
assert!(
message.starts_with("HF model info: GET http://127.0.0.1:")
&& message.ends_with(&format!("/api/models/owner/repo: HTTP {status}")),
"{message}"
);
assert_eq!(
crate::hf::client::is_permanent(&err),
matches!(status, 401 | 403 | 404),
"HTTP {status}"
);
}
}
#[test]
fn select_gguf_prefers_q4_k_m() {
let files = vec![file("model-Q8_0.gguf", 100), file("model-Q4_K_M.gguf", 50)];
let got = select_gguf(&files, "").unwrap();
assert_eq!(got.len(), 1);
assert_eq!(got[0].path, "model-Q4_K_M.gguf");
}
#[test]
fn select_gguf_falls_back_to_smallest() {
let files = vec![
file("model-weird1.gguf", 100),
file("model-weird2.gguf", 50),
];
let got = select_gguf(&files, "").unwrap();
assert_eq!(got[0].path, "model-weird2.gguf");
}
#[test]
fn select_gguf_excludes_mmproj_and_imatrix() {
let files = vec![
file("mmproj-F16.gguf", 10),
file("model.imatrix.gguf", 10),
file("model-Q4_K_M.gguf", 50),
];
let got = select_gguf(&files, "").unwrap();
assert_eq!(got.len(), 1);
assert_eq!(got[0].path, "model-Q4_K_M.gguf");
}
#[test]
fn select_gguf_by_explicit_tag() {
let files = vec![file("model-Q4_K_M.gguf", 50), file("model-Q8_0.gguf", 100)];
let got = select_gguf(&files, "Q8_0").unwrap();
assert_eq!(got[0].path, "model-Q8_0.gguf");
}
#[test]
fn select_gguf_returns_every_shard_of_a_split_in_order() {
let files = vec![
file("model-Q4_K_M-00002-of-00003.gguf", 10),
file("model-Q4_K_M-00001-of-00003.gguf", 10),
file("model-Q4_K_M-00003-of-00003.gguf", 10),
file("model-Q8_0-00001-of-00002.gguf", 10),
];
let got = select_gguf(&files, "Q4_K_M").unwrap();
assert_eq!(got.len(), 3);
assert_eq!(got[0].path, "model-Q4_K_M-00001-of-00003.gguf");
assert_eq!(got[1].path, "model-Q4_K_M-00002-of-00003.gguf");
assert_eq!(got[2].path, "model-Q4_K_M-00003-of-00003.gguf");
}
#[test]
fn select_gguf_errors_on_no_gguf_files() {
let files = vec![file("config.json", 10)];
assert!(select_gguf(&files, "").is_err());
}
#[test]
fn select_mmproj_prefers_f16() {
let files = vec![file("mmproj-BF16.gguf", 10), file("mmproj-F16.gguf", 10)];
assert_eq!(select_mmproj(&files).unwrap().path, "mmproj-F16.gguf");
}
#[test]
fn select_mmproj_absent_returns_none() {
assert!(select_mmproj(&[file("model.gguf", 10)]).is_none());
}
#[test]
fn select_license_file_case_insensitive() {
let files = vec![file("license", 10)];
assert!(select_license_file(&files).is_some());
}
#[test]
fn normalize_spdx_license_maps_known_slugs() {
assert_eq!(
normalize_spdx_license("apache-2.0"),
Some("Apache-2.0".to_string())
);
assert_eq!(normalize_spdx_license("other"), None);
assert_eq!(normalize_spdx_license("unknown"), None);
assert_eq!(
normalize_spdx_license("some-custom-license"),
Some("some-custom-license".to_string())
);
}
#[test]
fn parse_hf_ref_splits_host_owner_repo_tag() {
let (host, owner, repo, tag) = parse_hf_ref("huggingface.co/owner/repo:Q4_K_M").unwrap();
assert_eq!(
(host.as_str(), owner.as_str(), repo.as_str(), tag.as_str()),
("huggingface.co", "owner", "repo", "Q4_K_M")
);
}
#[test]
fn parse_hf_ref_without_tag() {
let (host, owner, repo, tag) = parse_hf_ref("huggingface.co/owner/repo").unwrap();
assert_eq!(
(host.as_str(), owner.as_str(), repo.as_str(), tag.as_str()),
("huggingface.co", "owner", "repo", "")
);
}
#[test]
fn parse_hf_ref_rejects_malformed_ref() {
assert!(parse_hf_ref("not-enough-parts").is_err());
}
#[test]
fn safetensors_media_type_classifies_chat_template_jinja_as_config() {
assert_eq!(
safetensors_media_type("chat_template.jinja"),
oci::MEDIA_TYPE_MODEL_WEIGHT_CONFIG_RAW
);
}
fn ltx_repo() -> Vec<HfFile> {
vec![
file("README.md", 10),
file("ltx-2.3-22b-dev-Q4_K_M.gguf", 14),
file("ltx-2.3-22b-dev-Q8_0.gguf", 22),
file("distilled/ltx-2.3-22b-distilled-Q4_K_M.gguf", 14),
file("distilled-1.1/ltx-2.3-22b-distilled-1.1-Q4_K_M.gguf", 14),
file("vae/ltx-2.3-22b-dev_video_vae.safetensors", 1),
file("vae/ltx-2.3-22b-distilled_video_vae.safetensors", 1),
file("vae/ltx-2.3-22b-dev_audio_vae.safetensors", 1),
file("vae/ltx-2.3-22b-distilled_audio_vae.safetensors", 1),
file(
"text_encoders/ltx-2.3-22b-dev_embeddings_connectors.safetensors",
2,
),
file(
"text_encoders/ltx-2.3-22b-distilled_embeddings_connectors.safetensors",
2,
),
]
}
#[test]
fn diffusion_repo_is_detected_by_its_sidecars() {
assert!(is_diffusion_repo(<x_repo()));
assert!(!is_diffusion_repo(&[
file("model-Q4_K_M.gguf", 1),
file("mmproj-F16.gguf", 1)
]));
}
#[test]
fn diffusion_gguf_prefers_distilled_without_a_tag() {
let picked = select_diffusion_gguf(<x_repo(), "").unwrap();
assert_eq!(picked.len(), 1);
assert!(picked[0].path.contains("distilled"), "{}", picked[0].path);
assert!(picked[0].path.contains("Q4_K_M"));
let dev = select_diffusion_gguf(<x_repo(), "dev-Q8_0").unwrap();
assert_eq!(dev[0].path, "ltx-2.3-22b-dev-Q8_0.gguf");
}
#[test]
fn diffusion_sidecars_follow_the_transformer_variant() {
let files = ltx_repo();
let model = "distilled-1.1/ltx-2.3-22b-distilled-1.1-Q4_K_M.gguf";
let vae = select_diffusion_sidecar(&files, model, "video_vae").unwrap();
assert_eq!(vae.path, "vae/ltx-2.3-22b-distilled_video_vae.safetensors");
let conn = select_diffusion_sidecar(&files, model, "embeddings_connectors").unwrap();
assert_eq!(
conn.path,
"text_encoders/ltx-2.3-22b-distilled_embeddings_connectors.safetensors"
);
let dev_vae =
select_diffusion_sidecar(&files, "ltx-2.3-22b-dev-Q8_0.gguf", "audio_vae").unwrap();
assert_eq!(dev_vae.path, "vae/ltx-2.3-22b-dev_audio_vae.safetensors");
assert!(select_diffusion_sidecar(&files, model, "nothing").is_none());
}
#[test]
fn ltx2_defaults_to_gemma3_text_encoder() {
assert_eq!(
diffusion_default_text_encoder("distilled-1.1/ltx-2.3-22b-distilled-1.1-Q4_K_M.gguf"),
Some("ggml-org/gemma-3-12b-it-GGUF:Q4_K_M")
);
assert_eq!(
diffusion_default_text_encoder("ltx-2.5-22b-dev-Q8_0.gguf"),
None
);
assert_eq!(diffusion_default_text_encoder("flux-dev-Q8_0.gguf"), None);
}
fn cosmos3_repo() -> Vec<HfFile> {
vec![
file("README.md", 10),
file("config.json", 1),
file("model_index.json", 1),
file("model.safetensors.index.json", 1),
file("scheduler/scheduler_config.json", 1),
file("transformer/config.json", 1),
file(
"transformer/diffusion_pytorch_model-00001-of-00002.safetensors",
5,
),
file(
"transformer/diffusion_pytorch_model-00002-of-00002.safetensors",
2,
),
file("vae/config.json", 1),
file("vae/diffusion_pytorch_model.safetensors", 1),
file("vision_encoder/model.safetensors", 1),
file("assets/example_i2v_input.jpg", 1),
]
}
#[test]
fn diffusers_repo_is_detected_by_its_root_pipeline_index() {
let files = cosmos3_repo();
assert!(is_diffusers_repo(&files));
assert!(!is_diffusion_repo(&files));
assert!(select_gguf(&files, "").is_err());
let picked = select_downloadable_hf_files(&files);
let paths: Vec<&str> = picked.iter().map(|f| f.path.as_str()).collect();
assert!(paths.contains(&"model_index.json"));
assert!(paths.contains(&"vae/diffusion_pytorch_model.safetensors"));
assert!(paths.contains(&"transformer/config.json"));
assert!(!paths.contains(&"assets/example_i2v_input.jpg"));
assert!(!is_diffusers_repo(&[
file("config.json", 1),
file("model.safetensors", 1)
]));
assert!(!is_diffusers_repo(&[file("model_index.json", 1)]));
assert!(!is_diffusers_repo(&[
file("model.safetensors", 1),
file("demo/model_index.json", 1)
]));
}
#[test]
fn diffusers_outputs_follow_the_pipeline_class() {
assert_eq!(
diffusers_outputs(Some("Cosmos3OmniPipeline")),
vec!["image", "video"]
);
for video in [
"WanPipeline",
"LTX2Pipeline",
"HunyuanVideo15Pipeline",
"Magi2Pipeline",
] {
assert_eq!(
diffusers_outputs(Some(video)),
vec!["image", "video"],
"{video}"
);
}
for image in ["QwenImagePipeline", "FluxPipeline", "LancePipeline"] {
assert_eq!(diffusers_outputs(Some(image)), vec!["image"], "{image}");
}
assert_eq!(
diffusers_outputs(None),
vec!["image"],
"unknown: at least an image model"
);
}
}