Struct HubFile 

pub struct HubFile {
    pub name: String,
    pub sha256: Option<String>,
}

A repository-relative file and optional expected SHA-256 digest.

Fields

name: String

Repository-relative filename.

sha256: Option<String>

Expected lowercase SHA-256, when the publisher provides one.

Implementations

impl HubFile

pub fn new(name: impl Into<String>) -> Self

Name a file without an independent checksum.

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 sha256(self, digest: impl Into<String>) -> Self

Require an exact lowercase SHA-256 digest.

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(())
}

Trait Implementations

impl Clone for HubFile

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 HubFile

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

Formats the value using the given formatter.

impl Eq for HubFile

impl PartialEq for HubFile

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for HubFile