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
//! Error types for MLML
use thiserror::Error;
/// Result type alias for MLML operations
pub type Result<T> = std::result::Result<T, Error>;
/// MLML error types
#[derive(Error, Debug)]
pub enum Error {
/// IO errors (file not found, permission denied, etc.)
#[error("IO error: {0}")]
Io(#[from] std::io::Error),
/// JSON parsing errors
#[error("JSON parse error: {0}")]
Json(#[from] serde_json::Error),
/// Candle errors
#[error("Candle error: {0}")]
Candle(#[from] candle_core::Error),
/// SafeTensors errors
#[error("SafeTensors error: {0}")]
SafeTensors(#[from] safetensors::SafeTensorError),
/// Regex compilation errors
#[error("Regex error: {0}")]
Regex(#[from] regex::Error),
/// Anyhow errors from external libraries
#[error("External library error: {0}")]
Anyhow(#[from] anyhow::Error),
/// Architecture detection failed
#[error("Could not detect model architecture from tensor names")]
UnknownArchitecture,
/// Tensor name mapping failed
#[error("Failed to map tensor name: {name}")]
TensorNameMapping {
/// The tensor name that could not be mapped
name: String,
},
/// Config validation errors
#[error("Invalid config: {message}")]
InvalidConfig {
/// Error message
message: String,
},
/// Device validation errors
#[error("Device validation failed: {message}")]
DeviceValidation {
/// Error message
message: String,
},
/// CUDA validation errors
#[error("CUDA validation failed: {message}")]
CudaValidation {
/// Error message
message: String,
},
/// File format validation errors
#[error("Invalid file format: {message}")]
InvalidFormat {
/// Error message
message: String,
},
/// Model loading errors
#[error("Model loading failed: {message}")]
ModelLoading {
/// Error message
message: String,
},
/// Invalid operation errors (e.g., quantizing already quantized model)
#[error("Invalid operation: {0}")]
InvalidOperation(String),
/// Generic error with context
#[error("Operation failed: {message}")]
Other {
/// Error message
message: String,
},
}
impl Error {
/// Create an InvalidConfig error
pub fn invalid_config(message: impl Into<String>) -> Self {
Self::InvalidConfig {
message: message.into(),
}
}
/// Create a DeviceValidation error
pub fn device_validation(message: impl Into<String>) -> Self {
Self::DeviceValidation {
message: message.into(),
}
}
/// Create a CudaValidation error
pub fn cuda_validation(message: impl Into<String>) -> Self {
Self::CudaValidation {
message: message.into(),
}
}
/// Create an InvalidFormat error
pub fn invalid_format(message: impl Into<String>) -> Self {
Self::InvalidFormat {
message: message.into(),
}
}
/// Create a ModelLoading error
pub fn model_loading(message: impl Into<String>) -> Self {
Self::ModelLoading {
message: message.into(),
}
}
/// Create an Other error
pub fn other(message: impl Into<String>) -> Self {
Self::Other {
message: message.into(),
}
}
/// Create a TensorNameMapping error
pub fn tensor_name_mapping(name: impl Into<String>) -> Self {
Self::TensorNameMapping { name: name.into() }
}
/// Create an IO error (alias for Other for backward compatibility)
pub fn io_error(message: impl Into<String>) -> Self {
Self::Other {
message: message.into(),
}
}
/// Create a model saving error (alias for Other)
pub fn model_saving(message: impl Into<String>) -> Self {
Self::Other {
message: message.into(),
}
}
/// Create an unsupported format error (alias for InvalidFormat)
pub fn unsupported_format(message: impl Into<String>) -> Self {
Self::InvalidFormat {
message: message.into(),
}
}
}