Struct Repository 

pub struct Repository {
    pub owner: String,
    pub name: String,
    pub revision: Option<String>,
}

One model repository and optional immutable revision.

Fields

owner: String

Repository owner or organization.

name: String

Repository name.

revision: Option<String>

Commit, tag, or branch; None uses the Hub default.

Implementations

impl Repository

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

Select a repository at its default revision.

Examples found in repository

examples/qualify_checkpoints.rs (line 32)

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

Pin a revision.

Examples found in repository

examples/qualify_checkpoints.rs (line 32)

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 Repository

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 Repository

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

Formats the value using the given formatter.

impl Eq for Repository

impl PartialEq for Repository

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Repository