entrenar 0.7.13

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
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
106

//! Decision trace types for CITL trainer

use super::SourceSpan;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// A single decision in the compiler trace
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DecisionTrace {
    /// Unique ID for this decision
    pub id: String,
    /// Type of decision (e.g., "type_inference", "borrow_check", "lifetime_resolution")
    pub decision_type: String,
    /// Description of the decision
    pub description: String,
    /// Source span where this decision was made
    pub span: Option<SourceSpan>,
    /// Timestamp (nanoseconds since session start)
    pub timestamp_ns: u64,
    /// Dependencies on other decisions
    pub depends_on: Vec<String>,
    /// Additional metadata
    pub metadata: HashMap<String, String>,
}

impl DecisionTrace {
    /// Create a new decision trace
    #[must_use]
    pub fn new(
        id: impl Into<String>,
        decision_type: impl Into<String>,
        description: impl Into<String>,
    ) -> Self {
        Self {
            id: id.into(),
            decision_type: decision_type.into(),
            description: description.into(),
            span: None,
            timestamp_ns: 0,
            depends_on: Vec::new(),
            metadata: HashMap::new(),
        }
    }

    /// Set the source span
    #[must_use]
    pub fn with_span(mut self, span: SourceSpan) -> Self {
        self.span = Some(span);
        self
    }

    /// Set the timestamp
    #[must_use]
    pub fn with_timestamp(mut self, timestamp_ns: u64) -> Self {
        self.timestamp_ns = timestamp_ns;
        self
    }

    /// Add a dependency
    #[must_use]
    pub fn with_dependency(mut self, dep_id: impl Into<String>) -> Self {
        self.depends_on.push(dep_id.into());
        self
    }

    /// Add dependencies
    #[must_use]
    pub fn with_dependencies(mut self, deps: Vec<String>) -> Self {
        self.depends_on.extend(deps);
        self
    }
}

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

    #[test]
    fn test_decision_trace_new() {
        let trace = DecisionTrace::new("d1", "type_inference", "Inferred type i32");
        assert_eq!(trace.id, "d1");
        assert_eq!(trace.decision_type, "type_inference");
        assert_eq!(trace.description, "Inferred type i32");
    }

    #[test]
    fn test_decision_trace_with_span() {
        let trace =
            DecisionTrace::new("d1", "type", "desc").with_span(SourceSpan::line("main.rs", 5));
        assert!(trace.span.is_some());
    }

    #[test]
    fn test_decision_trace_with_timestamp() {
        let trace = DecisionTrace::new("d1", "type", "desc").with_timestamp(1000);
        assert_eq!(trace.timestamp_ns, 1000);
    }

    #[test]
    fn test_decision_trace_with_dependencies() {
        let trace = DecisionTrace::new("d1", "type", "desc")
            .with_dependency("d0")
            .with_dependencies(vec!["d2".to_string(), "d3".to_string()]);
        assert_eq!(trace.depends_on.len(), 3);
    }
}