entrenar 0.7.11

Training & Optimization library with autograd, LoRA, quantization, and model merging
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

//! Crate specification for Nix packaging

use serde::{Deserialize, Serialize};
use std::path::PathBuf;

/// Crate specification for Nix packaging
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CrateSpec {
    /// Crate name
    pub name: String,
    /// Local path (if building from source)
    pub path: Option<PathBuf>,
    /// Crates.io version (if using published version)
    pub version: Option<String>,
    /// Git repository URL (if using git source)
    pub git: Option<String>,
    /// Git revision/tag
    pub rev: Option<String>,
}

impl CrateSpec {
    /// Create a crate spec for a local path
    pub fn local(name: impl Into<String>, path: impl Into<PathBuf>) -> Self {
        Self { name: name.into(), path: Some(path.into()), version: None, git: None, rev: None }
    }

    /// Create a crate spec for crates.io version
    pub fn crates_io(name: impl Into<String>, version: impl Into<String>) -> Self {
        Self { name: name.into(), path: None, version: Some(version.into()), git: None, rev: None }
    }

    /// Create a crate spec for git source
    pub fn git(name: impl Into<String>, url: impl Into<String>, rev: impl Into<String>) -> Self {
        Self {
            name: name.into(),
            path: None,
            version: None,
            git: Some(url.into()),
            rev: Some(rev.into()),
        }
    }

    /// Check if this is a local source
    pub fn is_local(&self) -> bool {
        self.path.is_some()
    }

    /// Check if this is a crates.io source
    pub fn is_crates_io(&self) -> bool {
        self.version.is_some() && self.git.is_none()
    }

    /// Check if this is a git source
    pub fn is_git(&self) -> bool {
        self.git.is_some()
    }

    /// Get source string for Nix
    pub fn nix_source(&self) -> String {
        if let Some(path) = &self.path {
            format!("./{}", path.display())
        } else if let Some(version) = &self.version {
            format!("crates.io:{version}")
        } else if let (Some(git), Some(rev)) = (&self.git, &self.rev) {
            format!("git:{git}?rev={rev}")
        } else {
            "unknown".to_string()
        }
    }
}