1use crate::{
2 client::rpc::{ExecutionLocation, ParameterDefinitions, StateKeyData},
3 client::DecthingsParameter,
4 tensor::OwnedDecthingsTensor,
5};
6use serde::Deserialize;
7
8#[cfg(feature = "events")]
9#[derive(Debug, Clone, Deserialize)]
10#[serde(rename_all = "snake_case", tag = "code")]
11pub enum DebugSessionTerminatedReason {
12 TerminatedOnRequest,
13 LauncherTerminated,
14 InactiveTimeout,
15 Unknown,
16 #[serde(rename_all = "camelCase")]
17 CodeTerminated {
18 exit_code: Option<i32>,
19 signal: Option<String>,
20 oom: bool,
21 },
22 #[serde(rename_all = "camelCase")]
23 Exception {
24 exception_details: Option<String>,
25 },
26}
27
28#[cfg(feature = "events")]
29#[derive(Debug, Clone, Deserialize)]
30#[serde(rename_all = "camelCase", tag = "event", content = "params")]
31pub enum DebugEvent {
32 #[serde(rename_all = "camelCase")]
33 Exit {
34 debug_session_id: String,
35 reason: DebugSessionTerminatedReason,
36 },
37 #[serde(rename_all = "camelCase")]
38 Stdout {
39 debug_session_id: String,
40 #[serde(skip_deserializing)]
41 data: bytes::Bytes,
42 },
43 #[serde(rename_all = "camelCase")]
44 Stderr {
45 debug_session_id: String,
46 #[serde(skip_deserializing)]
47 data: bytes::Bytes,
48 },
49 #[serde(rename_all = "camelCase")]
50 Initialized { debug_session_id: String },
51 #[serde(rename_all = "camelCase")]
52 RemoteInspectorData {
53 debug_session_id: String,
54 #[serde(skip_deserializing)]
55 data: bytes::Bytes,
56 },
57}
58
59#[derive(Debug, Clone, Deserialize)]
60#[serde(rename_all = "camelCase")]
61pub struct LaunchDebugSessionResult {
62 pub debug_session_id: String,
64}
65
66#[derive(Debug, Clone, Deserialize)]
67#[serde(rename_all = "snake_case", tag = "code")]
68pub enum LaunchDebugSessionError {
69 ModelNotFound,
70 InvalidExecutorType,
71 PersistentLauncherNotFound,
72 QuotaExceeded,
73 ServerOverloaded,
74 InvalidExecutable,
75 ReadExecutableFileFailed,
76 BadCredentials,
77 TooManyRequests,
78 PaymentRequired,
79 Unknown,
80 #[serde(rename_all = "camelCase")]
81 InvalidParameter {
82 parameter_name: String,
83 reason: String,
84 },
85}
86
87#[derive(Debug, Clone, Deserialize)]
88#[serde(rename_all = "camelCase")]
89pub enum DebugTrainingSessionState {
90 Starting,
91 Running,
92 Completed,
93 Failed,
94}
95
96#[derive(Debug, Clone, Deserialize)]
97#[serde(rename_all = "camelCase")]
98pub struct DebugTrainingSession {
99 pub id: String,
100 pub created_at: i64,
101 pub state: DebugTrainingSessionState,
102}
103
104#[derive(Debug, Clone, Deserialize)]
105#[serde(rename_all = "camelCase")]
106pub struct DebugSession {
107 pub id: String,
108 pub started_at: i64,
109 pub model_id: String,
110 pub parameter_definitions: ParameterDefinitions,
111 pub training_sessions: Vec<DebugTrainingSession>,
112 pub execution_location: ExecutionLocation,
113}
114
115#[derive(Debug, Clone, Deserialize)]
116#[serde(rename_all = "camelCase")]
117pub struct GetDebugSessionsResult {
118 pub debug_sessions: Vec<DebugSession>,
119}
120
121#[derive(Debug, Clone, Deserialize)]
122#[serde(rename_all = "snake_case", tag = "code")]
123pub enum GetDebugSessionsError {
124 BadCredentials,
125 TooManyRequests,
126 PaymentRequired,
127 Unknown,
128 #[serde(rename_all = "camelCase")]
129 InvalidParameter {
130 parameter_name: String,
131 reason: String,
132 },
133}
134
135#[derive(Debug, Clone, Deserialize)]
136#[serde(rename_all = "camelCase")]
137pub struct TerminateDebugSessionResult {}
138
139#[derive(Debug, Clone, Deserialize)]
140#[serde(rename_all = "snake_case", tag = "code")]
141pub enum TerminateDebugSessionError {
142 DebugSessionNotFound,
143 BadCredentials,
144 TooManyRequests,
145 PaymentRequired,
146 Unknown,
147 #[serde(rename_all = "camelCase")]
148 InvalidParameter {
149 parameter_name: String,
150 reason: String,
151 },
152}
153
154#[derive(Debug, Clone, Deserialize)]
155#[serde(rename_all = "camelCase")]
156pub struct StateKey {
157 pub key: String,
158 pub byte_size: u64,
159}
160
161#[derive(Debug, Clone, Deserialize)]
162#[serde(rename_all = "camelCase")]
163pub struct CallCreateModelStateResult {
164 pub data_id: String,
165 pub state: Vec<StateKey>,
166}
167
168#[derive(Debug, Clone, Deserialize)]
169#[serde(rename_all = "snake_case", tag = "code")]
170pub enum CallCreateModelStateError {
171 DebugSessionNotFound,
172 DebugSessionTerminated,
173 #[serde(rename_all = "camelCase")]
174 DatasetNotFound {
175 dataset_id: String,
176 },
177 #[serde(rename_all = "camelCase")]
178 DatasetKeyNotFound {
179 dataset_id: String,
180 dataset_key: String,
181 },
182 #[serde(rename_all = "camelCase")]
183 Exception {
184 exception_details: Option<String>,
185 },
186 BadCredentials,
187 TooManyRequests,
188 PaymentRequired,
189 Unknown,
190 #[serde(rename_all = "camelCase")]
191 InvalidParameter {
192 parameter_name: String,
193 reason: String,
194 },
195}
196
197#[derive(Debug, Clone, Deserialize)]
198#[serde(rename_all = "camelCase")]
199pub struct CallInstantiateModelResult {
200 pub instantiated_model_id: String,
202}
203
204#[derive(Debug, Clone, Deserialize)]
205#[serde(rename_all = "snake_case", tag = "code")]
206pub enum CallInstantiateModelError {
207 DebugSessionNotFound,
208 DebugSessionTerminated,
209 StateDataNotFound,
210 #[serde(rename_all = "camelCase")]
211 Exception {
212 exception_details: Option<String>,
213 },
214 BadCredentials,
215 TooManyRequests,
216 PaymentRequired,
217 Unknown,
218 #[serde(rename_all = "camelCase")]
219 InvalidParameter {
220 parameter_name: String,
221 reason: String,
222 },
223}
224
225#[derive(Debug, Clone, Deserialize)]
226#[serde(rename_all = "camelCase")]
227pub struct CallTrainResult {
228 pub training_session_id: String,
230}
231
232#[derive(Debug, Clone, Deserialize)]
233#[serde(rename_all = "snake_case", tag = "code")]
234pub enum CallTrainError {
235 DebugSessionNotFound,
236 InstantiatedModelNotFound,
237 DebugSessionTerminated,
238 #[serde(rename_all = "camelCase")]
239 DatasetNotFound {
240 dataset_id: String,
241 },
242 #[serde(rename_all = "camelCase")]
243 DatasetKeyNotFound {
244 dataset_id: String,
245 dataset_key: String,
246 },
247 #[serde(rename_all = "camelCase")]
248 Exception {
249 exception_details: Option<String>,
250 },
251 BadCredentials,
252 TooManyRequests,
253 PaymentRequired,
254 Unknown,
255 #[serde(rename_all = "camelCase")]
256 InvalidParameter {
257 parameter_name: String,
258 reason: String,
259 },
260}
261
262#[derive(Debug, Clone, Deserialize)]
263#[serde(rename_all = "camelCase")]
264pub struct DebugTrainingSessionMetrics {
265 pub name: String,
266 pub amount: u32,
267}
268
269#[derive(Debug, Clone, Deserialize)]
270#[serde(rename_all = "snake_case", tag = "code")]
271pub enum DebugTrainingSessionFailReason {
272 Unknown,
273 Cancelled,
274 MaxDurationExceeded,
275 #[serde(rename_all = "camelCase")]
276 Exception {
277 exception_details: Option<String>,
278 },
279}
280
281#[derive(Debug, Clone, Deserialize)]
282#[serde(rename_all = "camelCase", tag = "state")]
283pub enum DebugTrainingSessionStatus {
284 #[serde(rename_all = "camelCase")]
285 Running { progress: f32 },
286 #[serde(rename_all = "camelCase")]
287 Completed {
288 finished_at: i64,
289 train_duration: u64,
290 },
291 #[serde(rename_all = "camelCase")]
292 Failed {
293 finished_at: i64,
294 train_duration: Option<u64>,
295 fail_reason: DebugTrainingSessionFailReason,
296 },
297}
298
299#[derive(Debug, Clone, Deserialize)]
300#[serde(rename_all = "camelCase")]
301pub struct DebugGetTrainingStatusResult {
302 pub id: String,
303 pub created_at: i64,
304 pub metrics: Vec<DebugTrainingSessionMetrics>,
305 pub status: DebugTrainingSessionStatus,
306}
307
308#[derive(Debug, Clone, Deserialize)]
309#[serde(rename_all = "snake_case", tag = "code")]
310pub enum DebugGetTrainingStatusError {
311 DebugSessionNotFound,
312 TrainingSessionNotFound,
313 BadCredentials,
314 TooManyRequests,
315 PaymentRequired,
316 Unknown,
317 #[serde(rename_all = "camelCase")]
318 InvalidParameter {
319 parameter_name: String,
320 reason: String,
321 },
322}
323
324#[derive(Debug, Clone, Deserialize)]
325#[serde(rename_all = "camelCase")]
326pub struct DebugFetchedTrainingMetric {
327 pub timestamp: i64,
328 #[serde(deserialize_with = "super::super::deserialize_empty_owned_decthings_tensor")]
329 pub data: OwnedDecthingsTensor,
330}
331
332#[derive(Debug, Clone, Deserialize)]
333#[serde(rename_all = "camelCase")]
334pub struct DebugFetchedTrainingMetrics {
335 pub name: String,
336 pub start_index: u32,
337 pub entries: Vec<DebugFetchedTrainingMetric>,
338}
339
340#[derive(Debug, Clone, Deserialize)]
341#[serde(rename_all = "camelCase")]
342pub struct DebugGetTrainingMetricsResult {
343 pub metrics: Vec<DebugFetchedTrainingMetrics>,
344}
345
346#[derive(Debug, Clone, Deserialize)]
347#[serde(rename_all = "snake_case", tag = "code")]
348pub enum DebugGetTrainingMetricsError {
349 DebugSessionNotFound,
350 TrainingSessionNotFound,
351 BadCredentials,
352 TooManyRequests,
353 PaymentRequired,
354 Unknown,
355 #[serde(rename_all = "camelCase")]
356 InvalidParameter {
357 parameter_name: String,
358 reason: String,
359 },
360}
361
362#[derive(Debug, Clone, Deserialize)]
363#[serde(rename_all = "camelCase")]
364pub struct DebugCancelTrainingSessionResult {}
365
366#[derive(Debug, Clone, Deserialize)]
367#[serde(rename_all = "snake_case", tag = "code")]
368pub enum DebugCancelTrainingSessionError {
369 DebugSessionNotFound,
370 TrainingSessionNotFound,
371 TrainingSessionNotRunning,
372 BadCredentials,
373 TooManyRequests,
374 PaymentRequired,
375 Unknown,
376 #[serde(rename_all = "camelCase")]
377 InvalidParameter {
378 parameter_name: String,
379 reason: String,
380 },
381}
382
383#[derive(Debug, Clone, Deserialize)]
384#[serde(rename_all = "camelCase")]
385pub struct CallEvaluateResult {
386 pub output: Vec<DecthingsParameter>,
387}
388
389#[derive(Debug, Clone, Deserialize)]
390#[serde(rename_all = "snake_case", tag = "code")]
391pub enum CallEvaluateError {
392 DebugSessionNotFound,
393 InstantiatedModelNotFound,
394 DebugSessionTerminated,
395 #[serde(rename_all = "camelCase")]
396 DatasetNotFound {
397 dataset_id: String,
398 },
399 #[serde(rename_all = "camelCase")]
400 DatasetKeyNotFound {
401 dataset_id: String,
402 dataset_key: String,
403 },
404 #[serde(rename_all = "camelCase")]
405 Exception {
406 exception_details: Option<String>,
407 },
408 BadCredentials,
409 TooManyRequests,
410 PaymentRequired,
411 Unknown,
412 #[serde(rename_all = "camelCase")]
413 InvalidParameter {
414 parameter_name: String,
415 reason: String,
416 },
417}
418
419#[derive(Debug, Clone, Deserialize)]
420#[serde(rename_all = "camelCase")]
421pub struct CallGetModelStateResult {
422 pub data_id: String,
423 pub state: Vec<StateKey>,
424}
425
426#[derive(Debug, Clone, Deserialize)]
427#[serde(rename_all = "snake_case", tag = "code")]
428pub enum CallGetModelStateError {
429 DebugSessionNotFound,
430 InstantiatedModelNotFound,
431 DebugSessionTerminated,
432 #[serde(rename_all = "camelCase")]
433 Exception {
434 exception_details: Option<String>,
435 },
436 BadCredentials,
437 TooManyRequests,
438 PaymentRequired,
439 Unknown,
440 #[serde(rename_all = "camelCase")]
441 InvalidParameter {
442 parameter_name: String,
443 reason: String,
444 },
445}
446
447#[derive(Debug, Clone, Deserialize)]
448#[serde(rename_all = "camelCase")]
449pub struct DownloadStateDataResult {
450 #[serde(rename = "stateKeyNames")]
451 pub data: Vec<StateKeyData>,
452}
453
454#[derive(Debug, Clone, Deserialize)]
455#[serde(rename_all = "snake_case", tag = "code")]
456pub enum DownloadStateDataError {
457 DebugSessionNotFound,
458 StateDataNotFound,
459 StateKeyNotFound,
460 BadCredentials,
461 TooManyRequests,
462 PaymentRequired,
463 Unknown,
464 #[serde(rename_all = "camelCase")]
465 InvalidParameter {
466 parameter_name: String,
467 reason: String,
468 },
469}
470
471#[derive(Debug, Clone, Deserialize)]
472#[serde(rename_all = "camelCase")]
473pub struct SendToRemoteInspectorResult {}
474
475#[derive(Debug, Clone, Deserialize)]
476#[serde(rename_all = "snake_case", tag = "code")]
477pub enum SendToRemoteInspectorError {
478 DebugSessionNotFound,
479 NotRemoteInspector,
480 BadCredentials,
481 TooManyRequests,
482 PaymentRequired,
483 Unknown,
484 #[serde(rename_all = "camelCase")]
485 InvalidParameter {
486 parameter_name: String,
487 reason: String,
488 },
489}
490
491#[cfg(feature = "events")]
492#[derive(Debug, Clone, Deserialize)]
493#[serde(rename_all = "camelCase")]
494pub struct DebugSubscribeToEventsResult {}
495
496#[cfg(feature = "events")]
497#[derive(Debug, Clone, Deserialize)]
498#[serde(rename_all = "snake_case", tag = "code")]
499pub enum DebugSubscribeToEventsError {
500 DebugSessionNotFound,
501 BadCredentials,
502 TooManyRequests,
503 PaymentRequired,
504 Unknown,
505 #[serde(rename_all = "camelCase")]
506 InvalidParameter {
507 parameter_name: String,
508 reason: String,
509 },
510}
511
512#[cfg(feature = "events")]
513#[derive(Debug, Clone, Deserialize)]
514#[serde(rename_all = "camelCase")]
515pub struct DebugUnsubscribeFromEventsResult {}
516
517#[cfg(feature = "events")]
518#[derive(Debug, Clone, Deserialize)]
519#[serde(rename_all = "snake_case", tag = "code")]
520pub enum DebugUnsubscribeFromEventsError {
521 NotSubscribed,
522 TooManyRequests,
523 Unknown,
524 #[serde(rename_all = "camelCase")]
525 InvalidParameter {
526 parameter_name: String,
527 reason: String,
528 },
529}