overbrainer 0.10.0

Distill a large LLM into a smaller open-weights model: generate questions, collect answers, fine-tune, visualize.
Documentation 
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

//! `runs/<id>/hub/push.json`: what the last push of a run sent where.

use std::path::{Path, PathBuf};
use std::{fs, io};

use serde::{Deserialize, Serialize};

use crate::runs::{RunsError, write_atomic};

/// The directory of a run that holds what concerns the Hub.
pub const HUB_DIR: &str = "hub";
/// The record of the last push, in [`HUB_DIR`].
pub const PUSH_FILE: &str = "push.json";

/// Errors writing a [`PushRecord`].
#[derive(Debug, thiserror::Error)]
pub enum RecordError {
    /// The `hub/` directory of the run could not be created.
    #[error("cannot create {}", path.display())]
    Dir {
        /// The directory.
        path: PathBuf,
        /// Underlying I/O error.
        #[source]
        source: io::Error,
    },
    /// The record could not be serialized.
    #[error("cannot serialize the push record")]
    Serialize(#[from] serde_json::Error),
    /// The record file could not be written.
    #[error(transparent)]
    Write(#[from] RunsError),
}

/// The last push of a run.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct PushRecord {
    /// `NAMESPACE/NAME`.
    pub repo: String,
    /// The commit id.
    pub commit: String,
    /// The commit URL.
    pub url: String,
    /// The paths in the repo the commit wrote.
    pub files: Vec<String>,
    /// The repo's visibility after the push.
    pub private: bool,
    /// When it was pushed, RFC 3339 UTC.
    pub pushed: String,
}

impl PushRecord {
    /// Writes the record to `run_dir/hub/push.json`, atomically like `run.json`.
    ///
    /// # Errors
    ///
    /// Returns a [`RecordError`] when the directory or the file cannot be
    /// written.
    pub fn save(&self, run_dir: &Path) -> Result<(), RecordError> {
        let dir = run_dir.join(HUB_DIR);
        fs::create_dir_all(&dir).map_err(|source| RecordError::Dir {
            path: dir.clone(),
            source,
        })?;
        let mut content = serde_json::to_vec_pretty(self)?;
        content.push(b'\n');
        write_atomic(&dir, PUSH_FILE, &content)?;
        Ok(())
    }
}

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

    /// A saved record reads back as it was written.
    #[test]
    fn a_saved_record_reads_back() -> Result<(), Box<dyn std::error::Error>> {
        let dir = tempfile::tempdir()?;
        let record = PushRecord {
            repo: "me/x".into(),
            commit: "1".into(),
            url: "https://hf.co/me/x/commit/1".into(),
            files: vec!["adapter_config.json".into(), "README.md".into()],
            private: true,
            pushed: "2026-10-04T12:00:00Z".into(),
        };
        record.save(dir.path())?;
        let text = fs::read_to_string(dir.path().join("hub/push.json"))?;
        assert_eq!(serde_json::from_str::<PushRecord>(&text)?, record);
        Ok(())
    }
}