overbrainer 0.8.2

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
94
95
96
97
98
99
100
101
102
103

use super::SecretError;

const PREFIX: &str = "vault:";

/// Location of a secret in a Vault or `OpenBao` KV v2 engine.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VaultRef {
    /// KV v2 mount point, e.g. `secret`.
    pub mount: String,
    /// Path within the mount, e.g. `overbrainer/nanogpt`.
    pub path: String,
    /// Field name within the secret's data.
    pub field: String,
}

impl std::fmt::Display for VaultRef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{PREFIX}{}/{}#{}", self.mount, self.path, self.field)
    }
}

/// Whether `raw` is a `vault:` reference, well formed or not. Only its prefix
/// is looked at.
#[must_use]
pub fn is_reference(raw: &str) -> bool {
    raw.starts_with(PREFIX)
}

/// Parses `vault:<mount>/<path>#<field>`. Returns `Ok(None)` for literal values.
///
/// Error messages never include the raw value, since a malformed literal may be a secret.
///
/// # Errors
///
/// Returns [`SecretError::InvalidReference`] when `raw` starts with the `vault:` prefix
/// but does not match the expected shape.
pub fn parse_reference(raw: &str) -> Result<Option<VaultRef>, SecretError> {
    let Some(rest) = raw.strip_prefix(PREFIX) else {
        return Ok(None);
    };
    let invalid =
        || SecretError::InvalidReference("expected vault:<mount>/<path>#<field>".to_string());
    let (location, field) = rest.split_once('#').ok_or_else(invalid)?;
    let (mount, path) = location.split_once('/').ok_or_else(invalid)?;
    if mount.is_empty() || path.is_empty() || field.is_empty() {
        return Err(invalid());
    }
    Ok(Some(VaultRef {
        mount: mount.to_string(),
        path: path.to_string(),
        field: field.to_string(),
    }))
}

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

    #[test]
    fn a_reference_is_told_by_its_prefix_alone() {
        assert!(is_reference("vault:secret/overbrainer/nanogpt#api_key"));
        assert!(is_reference("vault:"), "malformed, still a reference");
        assert!(!is_reference("sk-abc"));
        assert!(!is_reference(" vault:x/y#z"));
    }

    #[test]
    fn literal_values_are_not_references() -> Result<(), SecretError> {
        assert_eq!(parse_reference("sk-abc")?, None);
        Ok(())
    }

    #[test]
    fn full_reference_is_parsed() -> Result<(), SecretError> {
        let parsed = parse_reference("vault:secret/overbrainer/nanogpt#api_key")?;
        assert_eq!(
            parsed,
            Some(VaultRef {
                mount: "secret".into(),
                path: "overbrainer/nanogpt".into(),
                field: "api_key".into(),
            })
        );
        Ok(())
    }

    #[test]
    fn malformed_references_are_rejected() {
        for raw in [
            "vault:",
            "vault:secret#k",
            "vault:secret/path",
            "vault:/path#k",
            "vault:secret/#k",
            "vault:secret/p#",
        ] {
            assert!(
                matches!(parse_reference(raw), Err(SecretError::InvalidReference(_))),
                "{raw}"
            );
        }
    }
}