Struct Resolver 

pub struct Resolver { /* private fields */ }

Cache and download policy for one repository.

Implementations

impl Resolver

pub fn new(repository: Repository) -> Self

Resolve files from a repository, downloading cache misses by default.

Examples found in repository

examples/qualify_checkpoints.rs (lines 31-33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    let fetch = match args.as_slice() {
        [] => false,
        [argument] if argument == "--fetch" => true,
        _ => return Err("usage: qualify_checkpoints [--fetch]".into()),
    };
    let repositories: Vec<Repository> =
        serde_json::from_str(include_str!("../native/qualification/checkpoints.json"))?;
    let mut failures = 0;
    for repository in repositories {
        let resolver = hf::Resolver::new(
            hf::Repository::new(&repository.owner, &repository.repository).at(&repository.revision),
        )
        .offline(!fetch);
        for file in repository.files {
            eprintln!(
                "Checking {}/{} at {}: {}",
                repository.owner, repository.repository, repository.revision, file.name
            );
            let result = (|| -> hrx::Result<()> {
                let path = resolver.resolve(&hf::HubFile::new(file.name).sha256(file.sha256))?;
                // SAFETY: qualification requires completed, immutable cache files.
                // The Hub publishes downloads atomically; do not mutate these files
                // while this command is running.
                let view = unsafe { FileView::map(&path)? };
                println!("OK: {} tensors, {}", view.entries().len(), path.display());
                Ok(())
            })();
            if let Err(error) = result {
                failures += 1;
                eprintln!("FAILED: {error}");
            }
        }
    }
    if failures != 0 {
        return Err(format!("{failures} checkpoint(s) failed qualification").into());
    }
    Ok(())
}

pub fn offline(self, offline: bool) -> Self

Restrict resolution to local cache entries.

Examples found in repository

examples/qualify_checkpoints.rs (line 34)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    let fetch = match args.as_slice() {
        [] => false,
        [argument] if argument == "--fetch" => true,
        _ => return Err("usage: qualify_checkpoints [--fetch]".into()),
    };
    let repositories: Vec<Repository> =
        serde_json::from_str(include_str!("../native/qualification/checkpoints.json"))?;
    let mut failures = 0;
    for repository in repositories {
        let resolver = hf::Resolver::new(
            hf::Repository::new(&repository.owner, &repository.repository).at(&repository.revision),
        )
        .offline(!fetch);
        for file in repository.files {
            eprintln!(
                "Checking {}/{} at {}: {}",
                repository.owner, repository.repository, repository.revision, file.name
            );
            let result = (|| -> hrx::Result<()> {
                let path = resolver.resolve(&hf::HubFile::new(file.name).sha256(file.sha256))?;
                // SAFETY: qualification requires completed, immutable cache files.
                // The Hub publishes downloads atomically; do not mutate these files
                // while this command is running.
                let view = unsafe { FileView::map(&path)? };
                println!("OK: {} tensors, {}", view.entries().len(), path.display());
                Ok(())
            })();
            if let Err(error) = result {
                failures += 1;
                eprintln!("FAILED: {error}");
            }
        }
    }
    if failures != 0 {
        return Err(format!("{failures} checkpoint(s) failed qualification").into());
    }
    Ok(())
}

pub fn progress(self, progress: bool) -> Self

Force progress on or off. The default uses an interactive terminal and HF_HUB_DISABLE_PROGRESS_BARS.

pub fn resolve(&self, file: &HubFile) -> Result<PathBuf>

Resolve a required file, checking the cache before any network request.

Examples found in repository

examples/qualify_checkpoints.rs (line 41)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    let fetch = match args.as_slice() {
        [] => false,
        [argument] if argument == "--fetch" => true,
        _ => return Err("usage: qualify_checkpoints [--fetch]".into()),
    };
    let repositories: Vec<Repository> =
        serde_json::from_str(include_str!("../native/qualification/checkpoints.json"))?;
    let mut failures = 0;
    for repository in repositories {
        let resolver = hf::Resolver::new(
            hf::Repository::new(&repository.owner, &repository.repository).at(&repository.revision),
        )
        .offline(!fetch);
        for file in repository.files {
            eprintln!(
                "Checking {}/{} at {}: {}",
                repository.owner, repository.repository, repository.revision, file.name
            );
            let result = (|| -> hrx::Result<()> {
                let path = resolver.resolve(&hf::HubFile::new(file.name).sha256(file.sha256))?;
                // SAFETY: qualification requires completed, immutable cache files.
                // The Hub publishes downloads atomically; do not mutate these files
                // while this command is running.
                let view = unsafe { FileView::map(&path)? };
                println!("OK: {} tensors, {}", view.entries().len(), path.display());
                Ok(())
            })();
            if let Err(error) = result {
                failures += 1;
                eprintln!("FAILED: {error}");
            }
        }
    }
    if failures != 0 {
        return Err(format!("{failures} checkpoint(s) failed qualification").into());
    }
    Ok(())
}

pub fn local(&self, file: &HubFile) -> Result<Option<PathBuf>>

Return a cached file without contacting the network.

pub fn resolve_all(&self, files: &[HubFile]) -> Result<Vec<PathBuf>>

Resolve required files in request order.

Trait Implementations

impl Clone for Resolver

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Resolver

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.