use hf_hub::api::sync::Api;
use incin_core::prelude::*;
use std::path::PathBuf;
pub struct HubApi {
inner: Api,
}
impl HubApi {
pub fn new() -> Result<Self> {
let mut builder = hf_hub::api::sync::ApiBuilder::new();
if let Ok(dir) = std::env::var("INCIN_HUB_CACHE_DIR") {
builder = builder.with_cache_dir(PathBuf::from(dir));
}
if let Ok(token) = std::env::var("INCIN_HUB_TOKEN") {
builder = builder.with_token(Some(token));
}
let api = builder.build().map_err(anyhow::Error::from)?;
Ok(Self { inner: api })
}
pub fn model(&self, repo_id: &str) -> HubRepo {
HubRepo {
inner: self.inner.model(repo_id.to_string()),
}
}
}
pub struct HubRepo {
inner: hf_hub::api::sync::ApiRepo,
}
impl HubRepo {
pub fn get(&self, filename: &str) -> Result<PathBuf> {
let path = self.inner.get(filename).map_err(anyhow::Error::from)?;
Ok(path)
}
pub fn load_safetensors<B: Backend<FloatElem = f32> + SupportsDType<f32>>(
&self,
filename: Option<&str>,
device: &DeviceId,
) -> Result<alloc::collections::BTreeMap<String, B::Storage<f32>>> {
let file = filename.unwrap_or("model.safetensors");
let path = self.get(file)?;
incin_core::prelude::load_safetensors_map::<B, _>(&path, device)
}
}
pub fn download(repo_id: &str, filename: &str) -> Result<PathBuf> {
HubApi::new()?.model(repo_id).get(filename)
}
pub fn from_pretrained<B: Backend<FloatElem = f32> + SupportsDType<f32>>(
repo_id: &str,
filename: Option<&str>,
device: &DeviceId,
) -> Result<alloc::collections::BTreeMap<String, B::Storage<f32>>> {
HubApi::new()?
.model(repo_id)
.load_safetensors::<B>(filename, device)
}