hf2q 0.1.7

Pure Rust CLI for converting HuggingFace models to hardware-optimized formats and serving them over an OpenAI-compatible API on Apple Silicon
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

#[cfg(target_os = "macos")]
use std::ffi::CString;

use super::schema::MacOsVersion;
use super::InstallStateError;

pub(super) fn require_compatible_host(required: &MacOsVersion) -> Result<(), InstallStateError> {
    let floor = MacOsVersion::parse("minimum_macos", "14.0".to_owned())
        .expect("the v1 macOS floor is valid");
    let host = host_macos_version()?;
    require_version_supported(&host, &floor, required)
}

fn require_version_supported(
    host: &MacOsVersion,
    floor: &MacOsVersion,
    required: &MacOsVersion,
) -> Result<(), InstallStateError> {
    if required < floor {
        return Err(InstallStateError::InvalidLayout(
            "release manifest predates the v1 macOS deployment floor",
        ));
    }
    if host < required {
        return Err(InstallStateError::InvalidLayout(
            "host macOS version is below the release requirement",
        ));
    }
    Ok(())
}

#[cfg(target_os = "macos")]
fn host_macos_version() -> Result<MacOsVersion, InstallStateError> {
    let name = CString::new("kern.osproductversion").expect("static sysctl name");
    let mut length = 0_usize;
    // SAFETY: `name` is NUL-terminated, the first call supplies no output
    // buffer as required by sysctlbyname, and `length` is a valid out pointer.
    let status = unsafe {
        libc::sysctlbyname(
            name.as_ptr(),
            std::ptr::null_mut(),
            &mut length,
            std::ptr::null_mut(),
            0,
        )
    };
    if status != 0 || length == 0 || length > 64 {
        return Err(InstallStateError::std_io(
            "read host macOS version size",
            std::io::Error::last_os_error(),
        ));
    }
    let mut bytes = vec![0_u8; length];
    // SAFETY: `bytes` owns `length` writable bytes and the remaining pointers
    // follow sysctlbyname's read-only query contract.
    let status = unsafe {
        libc::sysctlbyname(
            name.as_ptr(),
            bytes.as_mut_ptr().cast(),
            &mut length,
            std::ptr::null_mut(),
            0,
        )
    };
    if status != 0 || length == 0 || length > bytes.len() {
        return Err(InstallStateError::std_io(
            "read host macOS version",
            std::io::Error::last_os_error(),
        ));
    }
    bytes.truncate(length);
    if bytes.last() == Some(&0) {
        bytes.pop();
    }
    let text = std::str::from_utf8(&bytes).map_err(|_| {
        InstallStateError::InvalidLayout("host macOS version is not canonical UTF-8")
    })?;
    MacOsVersion::parse("host_macos", text.to_owned())
        .map_err(|_| InstallStateError::InvalidLayout("host macOS version is not canonical"))
}

#[cfg(not(target_os = "macos"))]
fn host_macos_version() -> Result<MacOsVersion, InstallStateError> {
    Err(InstallStateError::InvalidLayout(
        "standalone installation requires macOS",
    ))
}

#[cfg(test)]
mod tests {
    use super::*;

    fn version(value: &str) -> MacOsVersion {
        MacOsVersion::parse("test", value.to_owned()).expect("test macOS version")
    }

    #[test]
    fn host_must_satisfy_floor_and_release_requirement() {
        let floor = version("14.0");
        assert!(require_version_supported(&version("14.0"), &floor, &version("14.0")).is_ok());
        assert!(require_version_supported(&version("14.9"), &floor, &version("14.10")).is_err());
        assert!(require_version_supported(&version("26.5.2"), &floor, &version("99.0")).is_err());
        assert!(require_version_supported(&version("26.5.2"), &floor, &version("13.0")).is_err());
    }
}