pacha 0.2.5

Model, Data and Recipe Registry with full lineage tracking
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Error types for Pacha registry operations.

use std::path::PathBuf;
use thiserror::Error;

/// Result type alias for Pacha operations.
pub type Result<T> = std::result::Result<T, PachaError>;

/// Errors that can occur during Pacha registry operations.
#[derive(Error, Debug)]
pub enum PachaError {
    /// Database operation failed.
    #[error("database error: {0}")]
    Database(#[from] rusqlite::Error),

    /// IO operation failed.
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),

    /// JSON serialization/deserialization failed.
    #[error("JSON error: {0}")]
    Json(#[from] serde_json::Error),

    /// TOML serialization/deserialization failed.
    #[error("TOML error: {0}")]
    TomlDeserialize(#[from] toml::de::Error),

    /// TOML serialization failed.
    #[error("TOML serialization error: {0}")]
    TomlSerialize(#[from] toml::ser::Error),

    /// `MessagePack` serialization/deserialization failed.
    #[error("MessagePack error: {0}")]
    MessagePack(String),

    /// Artifact not found.
    #[error("artifact not found: {kind} '{name}' version {version}")]
    NotFound {
        /// Kind of artifact (model, dataset, recipe).
        kind: String,
        /// Name of the artifact.
        name: String,
        /// Version requested.
        version: String,
    },

    /// Artifact already exists.
    #[error("artifact already exists: {kind} '{name}' version {version}")]
    AlreadyExists {
        /// Kind of artifact.
        kind: String,
        /// Name of the artifact.
        name: String,
        /// Version that exists.
        version: String,
    },

    /// Invalid version string.
    #[error("invalid version string: {0}")]
    InvalidVersion(String),

    /// Content hash mismatch.
    #[error("content hash mismatch: expected {expected}, got {actual}")]
    HashMismatch {
        /// Expected hash.
        expected: String,
        /// Actual hash computed.
        actual: String,
    },

    /// Storage path error.
    #[error("storage path error: {0}")]
    StoragePath(PathBuf),

    /// Compression error.
    #[error("compression error: {0}")]
    Compression(String),

    /// Invalid artifact state transition.
    #[error("invalid stage transition from {from} to {to}")]
    InvalidStageTransition {
        /// Current stage.
        from: String,
        /// Attempted target stage.
        to: String,
    },

    /// Validation error.
    #[error("validation error: {0}")]
    Validation(String),

    /// Registry not initialized.
    #[error("registry not initialized at {0}")]
    NotInitialized(PathBuf),

    /// Invalid URI format.
    #[error("invalid URI: {0}")]
    InvalidUri(String),

    /// Operation not supported.
    #[error("unsupported operation '{operation}': {reason}")]
    UnsupportedOperation {
        /// Operation that was attempted.
        operation: String,
        /// Reason it's not supported.
        reason: String,
    },

    /// Signature verification failed.
    #[error("signature verification failed")]
    SignatureInvalid,

    /// Remote registry error.
    #[error("remote registry error: {0}")]
    RemoteRegistry(String),

    /// Invalid format (encryption, file structure).
    #[error("invalid format: {0}")]
    InvalidFormat(String),
}

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

    #[test]
    fn test_error_display_not_found() {
        let err = PachaError::NotFound {
            kind: "model".to_string(),
            name: "fraud-detector".to_string(),
            version: "1.0.0".to_string(),
        };
        assert_eq!(
            err.to_string(),
            "artifact not found: model 'fraud-detector' version 1.0.0"
        );
    }

    #[test]
    fn test_error_display_hash_mismatch() {
        let err = PachaError::HashMismatch {
            expected: "abc123".to_string(),
            actual: "def456".to_string(),
        };
        assert_eq!(
            err.to_string(),
            "content hash mismatch: expected abc123, got def456"
        );
    }

    #[test]
    fn test_error_display_invalid_stage() {
        let err = PachaError::InvalidStageTransition {
            from: "development".to_string(),
            to: "archived".to_string(),
        };
        assert_eq!(
            err.to_string(),
            "invalid stage transition from development to archived"
        );
    }
}