do-memory-core 0.1.31

Core episodic learning system for AI agents with pattern extraction, reward scoring, and dual storage backend
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Tests for real embedding model

#[cfg(test)]
#[allow(clippy::module_inception)]
mod tests {
    #[cfg(all(feature = "local-embeddings", feature = "reqwest"))]
    use crate::embeddings::real_model::download::validate_downloaded_file;

    #[test]
    fn test_url_construction() {
        let model_name = "sentence-transformers/all-MiniLM-L6-v2";
        let sanitized = model_name.replace('/', "_");
        let base_url = format!("https://huggingface.co/{model_name}/resolve/main");

        assert_eq!(sanitized, "sentence-transformers_all-MiniLM-L6-v2");
        assert_eq!(
            base_url,
            "https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2/resolve/main"
        );

        let files = [
            format!("{sanitized}.onnx"),
            format!("{sanitized}_tokenizer.json"),
            format!("{sanitized}_config.json"),
        ];

        assert_eq!(files[0], "sentence-transformers_all-MiniLM-L6-v2.onnx");
        assert_eq!(
            files[1],
            "sentence-transformers_all-MiniLM-L6-v2_tokenizer.json"
        );
        assert_eq!(
            files[2],
            "sentence-transformers_all-MiniLM-L6-v2_config.json"
        );
    }

    #[test]
    fn test_progress_calculation() {
        let total = 10_485_760u64; // 10 MB
        let downloaded = 5_242_880u64; // 5 MB
        let progress = (downloaded as f64 / total as f64) * 100.0;

        assert!((progress - 50.0).abs() < 0.01);

        let total_mb = total as f64 / 1_048_576.0;
        let downloaded_mb = downloaded as f64 / 1_048_576.0;

        assert!((total_mb - 10.0).abs() < 0.01);
        assert!((downloaded_mb - 5.0).abs() < 0.01);
    }

    #[test]
    fn test_retry_backoff() {
        let max_retries = 3;
        for retry_count in 0..max_retries {
            let backoff_duration = std::time::Duration::from_millis(100 * 2_u64.pow(retry_count));
            let expected_ms = 100 * 2_u64.pow(retry_count);

            assert_eq!(backoff_duration.as_millis() as u64, expected_ms);
        }

        // Verify exponential backoff: 100ms, 200ms, 400ms
        assert_eq!(
            std::time::Duration::from_millis(100 * 2_u64.pow(0)).as_millis(),
            100
        );
        assert_eq!(
            std::time::Duration::from_millis(100 * 2_u64.pow(1)).as_millis(),
            200
        );
        assert_eq!(
            std::time::Duration::from_millis(100 * 2_u64.pow(2)).as_millis(),
            400
        );
    }

    #[test]
    #[cfg(all(feature = "local-embeddings", feature = "reqwest"))]
    fn test_file_validation() {
        use std::io::Write;
        use tempfile::tempdir;

        let temp_dir = tempdir().unwrap();
        let file_path = temp_dir.path().join("test_file.txt");

        // Test with non-existent file
        let result = validate_downloaded_file(&file_path, "test_file.txt");
        assert!(result.is_err());

        // Test with empty file
        std::fs::File::create(&file_path)
            .unwrap()
            .write_all(b"")
            .unwrap();
        let result = validate_downloaded_file(&file_path, "test_file.txt");
        assert!(result.is_err());

        // Test with valid file
        std::fs::File::create(&file_path)
            .unwrap()
            .write_all(b"test content")
            .unwrap();
        let result = validate_downloaded_file(&file_path, "test_file.txt");
        assert!(result.is_ok());
    }

    #[test]
    fn test_speed_calculation() {
        // Test speed calculation
        let downloaded = 5_242_880u64; // 5 MB
        let elapsed = std::time::Duration::from_secs(2);
        let speed = (downloaded as f64 / 1_048_576.0) / elapsed.as_secs_f64();

        assert!((speed - 2.5).abs() < 0.01);

        // Test zero elapsed time handling
        let elapsed_zero = std::time::Duration::from_secs(0);
        let speed_zero = if elapsed_zero.as_secs_f64() > 0.0 {
            (downloaded as f64 / 1_048_576.0) / elapsed_zero.as_secs_f64()
        } else {
            0.0
        };

        assert_eq!(speed_zero, 0.0);
    }
}