decthings_api/client/rpc/model/
response.rs

1use crate::{
2    client::rpc::{ExecutionLocation, LauncherSpec, ParameterDefinitions, StateKeyData, Tag},
3    client::DecthingsParameter,
4    tensor::OwnedDecthingsTensor,
5};
6use serde::{Deserialize, Serialize};
7
8#[derive(Debug, Clone, Deserialize)]
9#[serde(rename_all = "camelCase")]
10pub struct CreateModelResult {
11    /// A unique identifier which you should use in subsequent API calls.
12    pub model_id: String,
13    /// Will be true if an initial state is being create, which means the model is being created until the operation is
14    /// finished.
15    pub is_now_creating: bool,
16}
17
18#[derive(Debug, Clone, Deserialize)]
19#[serde(rename_all = "snake_case", tag = "code")]
20pub enum CreateModelError {
21    NameAlreadyUsed,
22    OrganizationNotFound,
23    AccessDenied,
24    ModelNotFound,
25    SnapshotNotFound,
26    QuotaExceeded,
27    ServerOverloaded,
28    InvalidExecutableFile,
29    ReadExecutableFileFailed,
30    #[serde(rename_all = "camelCase")]
31    DatasetNotFound {
32        dataset_id: String,
33    },
34    #[serde(rename_all = "camelCase")]
35    DatasetKeyNotFound {
36        dataset_id: String,
37        dataset_key: String,
38    },
39    BadCredentials,
40    TooManyRequests,
41    PaymentRequired,
42    Unknown,
43    #[serde(rename_all = "camelCase")]
44    InvalidParameter {
45        parameter_name: String,
46        reason: String,
47    },
48}
49
50#[derive(Debug, Clone, Deserialize)]
51#[serde(rename_all = "camelCase")]
52pub enum AtCodeStartupOrCreateState {
53    CodeStartup,
54    CreateState,
55}
56
57#[derive(Debug, Clone, Deserialize)]
58#[serde(rename_all = "snake_case", tag = "code")]
59pub enum CreateModelFailedCreateStateError {
60    InvalidExecutableFile,
61    ReadExecutableFileFailed,
62    LauncherTerminated,
63    #[serde(rename_all = "camelCase")]
64    MaxDurationExceeded {
65        at: AtCodeStartupOrCreateState,
66    },
67    #[serde(rename_all = "camelCase")]
68    CodeTerminated {
69        exit_code: Option<i32>,
70        signal: Option<String>,
71        oom: bool,
72    },
73    #[serde(rename_all = "camelCase")]
74    Exception {
75        at: AtCodeStartupOrCreateState,
76        exception_details: Option<String>,
77    },
78}
79
80#[derive(Debug, Clone, Deserialize)]
81#[serde(rename_all = "camelCase")]
82pub struct CreateModelFailedInitialStateDurations {
83    pub create_launcher: u64,
84    pub code_startup: Option<u64>,
85    pub create_state: Option<u64>,
86}
87
88#[derive(Debug, Clone, Deserialize)]
89#[serde(rename_all = "snake_case", tag = "code")]
90pub enum CreateModelFailedError {
91    Cancelled,
92    ServerOverloaded,
93    Unknown,
94    #[serde(rename_all = "camelCase")]
95    CreateStateError {
96        details: CreateModelFailedCreateStateError,
97        create_initial_state_durations: CreateModelFailedInitialStateDurations,
98    },
99}
100
101#[derive(Debug, Clone, Deserialize)]
102#[serde(rename_all = "camelCase")]
103pub struct CreateModelInitialStateDurations {
104    pub create_launcher: u64,
105    pub code_startup: u64,
106    pub create_state: u64,
107}
108
109#[derive(Debug, Clone, Deserialize)]
110#[serde(rename_all = "camelCase")]
111pub enum WaitForModelToBeCreatedResult {
112    #[serde(rename_all = "camelCase")]
113    CreateModelFailed { error: CreateModelFailedError },
114    #[serde(rename_all = "camelCase")]
115    CreateModelSuccess {
116        create_initial_state_durations: CreateModelInitialStateDurations,
117    },
118}
119
120#[derive(Debug, Clone, Deserialize)]
121#[serde(rename_all = "snake_case", tag = "code")]
122pub enum WaitForModelToBeCreatedError {
123    ModelNotFound,
124    ModelAlreadyCreated,
125    BadCredentials,
126    TooManyRequests,
127    PaymentRequired,
128    Unknown,
129    #[serde(rename_all = "camelCase")]
130    InvalidParameter {
131        parameter_name: String,
132        reason: String,
133    },
134}
135
136#[derive(Debug, Clone, Deserialize)]
137#[serde(rename_all = "camelCase")]
138pub struct DeleteModelResult {}
139
140#[derive(Debug, Clone, Deserialize)]
141#[serde(rename_all = "snake_case", tag = "code")]
142pub enum DeleteModelError {
143    ModelNotFound,
144    AccessDenied,
145    BadCredentials,
146    TooManyRequests,
147    PaymentRequired,
148    Unknown,
149    #[serde(rename_all = "camelCase")]
150    InvalidParameter {
151        parameter_name: String,
152        reason: String,
153    },
154}
155
156#[derive(Debug, Clone, Deserialize)]
157#[serde(rename_all = "camelCase")]
158pub struct SnapshotModelResult {
159    /// A unique identifier which you should use in subsequent API calls.
160    pub snapshot_id: String,
161}
162
163#[derive(Debug, Clone, Deserialize)]
164#[serde(rename_all = "snake_case", tag = "code")]
165pub enum SnapshotModelError {
166    ModelNotFound,
167    AccessDenied,
168    QuotaExceeded,
169    ServerOverloaded,
170    BadCredentials,
171    TooManyRequests,
172    PaymentRequired,
173    Unknown,
174    #[serde(rename_all = "camelCase")]
175    InvalidParameter {
176        parameter_name: String,
177        reason: String,
178    },
179}
180
181#[derive(Debug, Clone, Deserialize)]
182#[serde(rename_all = "camelCase")]
183pub struct UpdateSnapshotResult {}
184
185#[derive(Debug, Clone, Deserialize)]
186#[serde(rename_all = "snake_case", tag = "code")]
187pub enum UpdateSnapshotError {
188    ModelNotFound,
189    SnapshotNotFound,
190    AccessDenied,
191    BadCredentials,
192    TooManyRequests,
193    PaymentRequired,
194    Unknown,
195    #[serde(rename_all = "camelCase")]
196    InvalidParameter {
197        parameter_name: String,
198        reason: String,
199    },
200}
201
202#[derive(Debug, Clone, Deserialize)]
203#[serde(rename_all = "camelCase")]
204pub struct DeleteSnapshotResult {}
205
206#[derive(Debug, Clone, Deserialize)]
207#[serde(rename_all = "snake_case", tag = "code")]
208pub enum DeleteSnapshotError {
209    ModelNotFound,
210    SnapshotNotFound,
211    AccessDenied,
212    BadCredentials,
213    TooManyRequests,
214    PaymentRequired,
215    Unknown,
216    #[serde(rename_all = "camelCase")]
217    InvalidParameter {
218        parameter_name: String,
219        reason: String,
220    },
221}
222
223#[derive(Debug, Clone, Deserialize)]
224#[serde(rename_all = "camelCase")]
225pub struct UpdateModelResult {}
226
227#[derive(Debug, Clone, Deserialize)]
228#[serde(rename_all = "snake_case", tag = "code")]
229pub enum UpdateModelError {
230    ModelNotFound,
231    AccessDenied,
232    NameAlreadyUsed,
233    BadCredentials,
234    TooManyRequests,
235    PaymentRequired,
236    Unknown,
237    #[serde(rename_all = "camelCase")]
238    InvalidParameter {
239        parameter_name: String,
240        reason: String,
241    },
242}
243
244#[derive(Debug, Clone, Deserialize)]
245#[serde(rename_all = "camelCase", tag = "type")]
246pub enum ModelOwner {
247    #[serde(rename_all = "camelCase")]
248    User { user_id: String, username: String },
249    #[serde(rename_all = "camelCase")]
250    Organization {
251        organization_id: String,
252        organization_name: String,
253    },
254}
255
256#[derive(Debug, Clone, Deserialize)]
257#[serde(rename_all = "camelCase")]
258pub enum ModelAccess {
259    Read,
260    Readwrite,
261}
262
263#[derive(Debug, Clone, Serialize, Deserialize)]
264#[serde(rename_all = "camelCase")]
265pub enum Language {
266    Go,
267    Javascript,
268    Typescript,
269    Python,
270    Rust,
271}
272
273#[derive(Debug, Clone, Deserialize)]
274#[serde(rename_all = "camelCase")]
275pub struct ModelImageProgress {
276    pub total_bytes: u64,
277    pub copied_bytes: u64,
278}
279
280#[derive(Debug, Clone, Deserialize)]
281#[serde(rename_all = "camelCase")]
282pub struct ModelImage {
283    pub domain: String,
284    pub repository: String,
285    pub reference: String,
286    pub digest: String,
287    pub target_domain: String,
288    pub target_repository: String,
289    pub target_reference: String,
290    pub progress: Option<ModelImageProgress>,
291    pub target_error: Option<String>,
292}
293
294#[derive(Debug, Clone, Deserialize)]
295#[serde(rename_all = "camelCase")]
296pub struct DefaultLauncherSpecs {
297    pub create_state: LauncherSpec,
298    pub evaluate: LauncherSpec,
299}
300
301#[derive(Debug, Clone, Serialize, Deserialize)]
302#[serde(rename_all = "camelCase")]
303pub struct MaxDurationsSeconds {
304    pub code_startup: u32,
305    pub instantiate_model: u32,
306    pub create_state: u32,
307    pub train: u32,
308    pub evaluate: u32,
309}
310
311#[derive(Debug, Clone, Deserialize)]
312#[serde(rename_all = "camelCase")]
313pub struct StateKey {
314    pub key: String,
315    pub byte_size: u64,
316}
317
318#[derive(Debug, Clone, Deserialize)]
319#[serde(rename_all = "camelCase")]
320pub struct StateMountedModel {
321    pub model_id: String,
322    pub snapshot_id: Option<String>,
323}
324
325#[derive(Debug, Clone, Deserialize)]
326#[serde(rename_all = "camelCase")]
327pub struct ModelState {
328    pub id: String,
329    pub name: String,
330    /// Identifiers of all the training operations that have been performed to reach this state.
331    pub training_operations: Vec<String>,
332    pub created_at: i64,
333    pub being_deleted: bool,
334    pub state: Vec<StateKey>,
335    pub mounted_models: Vec<StateMountedModel>,
336}
337
338#[derive(Debug, Clone, Deserialize)]
339#[serde(rename_all = "camelCase")]
340pub struct SnapshotImage {
341    pub domain: String,
342    pub repository: String,
343    pub reference: String,
344    pub digest: String,
345}
346
347#[derive(Debug, Clone, Deserialize)]
348#[serde(rename_all = "camelCase")]
349pub struct SnapshotState {
350    pub name: String,
351    pub state: Vec<StateKey>,
352    pub mounted_models: Vec<StateMountedModel>,
353}
354
355#[derive(Debug, Clone, Deserialize)]
356#[serde(rename_all = "camelCase")]
357pub struct ModelSnapshot {
358    pub id: String,
359    pub name: String,
360    pub created_at: i64,
361    pub filesystem_size_mebibytes: u32,
362    pub parameter_definitions: ParameterDefinitions,
363    pub default_launcher_specs: DefaultLauncherSpecs,
364    pub max_durations_seconds: MaxDurationsSeconds,
365    pub image: SnapshotImage,
366    pub state: SnapshotState,
367}
368
369#[derive(Debug, Clone, Deserialize)]
370#[serde(rename_all = "camelCase")]
371pub struct BasedOnSnapshot {
372    pub model_id: String,
373    pub snapshot_id: String,
374    pub no_longer_exists: bool,
375}
376
377#[derive(Debug, Clone, Deserialize)]
378#[serde(rename_all = "camelCase")]
379pub struct Model {
380    pub id: String,
381    pub name: String,
382    pub description: String,
383    pub public_access: bool,
384    pub created_at: i64,
385    pub tags: Vec<Tag>,
386    pub owner: ModelOwner,
387    pub access: ModelAccess,
388    pub being_created: bool,
389    pub language: Language,
390    pub wasm: bool,
391    pub image: ModelImage,
392    pub parameter_definitions: ParameterDefinitions,
393    pub default_launcher_specs: DefaultLauncherSpecs,
394    pub max_durations_seconds: MaxDurationsSeconds,
395    pub filesystem_size_mebibytes: u32,
396    pub ongoing_training_sessions: Vec<String>,
397    pub training_sessions: Vec<String>,
398    pub states: Vec<ModelState>,
399    pub active_state: String,
400    pub snapshots: Vec<ModelSnapshot>,
401    pub based_on_snapshot: Option<BasedOnSnapshot>,
402}
403
404#[derive(Debug, Clone, Deserialize)]
405#[serde(rename_all = "camelCase")]
406pub struct GetModelsResult {
407    pub models: Vec<Model>,
408    /// The total number of models that matched the filter.
409    pub total: u32,
410    pub offset: u32,
411    pub limit: u32,
412}
413
414#[derive(Debug, Clone, Deserialize)]
415#[serde(rename_all = "snake_case", tag = "code")]
416pub enum GetModelsError {
417    BadCredentials,
418    TooManyRequests,
419    PaymentRequired,
420    Unknown,
421    #[serde(rename_all = "camelCase")]
422    InvalidParameter {
423        parameter_name: String,
424        reason: String,
425    },
426}
427
428#[derive(Debug, Clone, Deserialize)]
429#[serde(rename_all = "camelCase")]
430pub struct SetFilesystemSizeResult {}
431
432#[derive(Debug, Clone, Deserialize)]
433#[serde(rename_all = "snake_case", tag = "code")]
434pub enum SetFilesystemSizeError {
435    ModelNotFound,
436    InvalidExecutorType,
437    NotEnoughSpace,
438    AccessDenied,
439    QuotaExceeded,
440    ServerOverloaded,
441    BadCredentials,
442    TooManyRequests,
443    PaymentRequired,
444    Unknown,
445    #[serde(rename_all = "camelCase")]
446    InvalidParameter {
447        parameter_name: String,
448        reason: String,
449    },
450}
451
452#[derive(Debug, Clone, Deserialize)]
453#[serde(rename_all = "camelCase")]
454pub struct GetFilesystemUsageResult {
455    pub block_size: u64,
456    pub total_blocks: u64,
457    pub free_blocks: u64,
458    pub total_inodes: u64,
459    pub free_inodes: u64,
460}
461
462#[derive(Debug, Clone, Deserialize)]
463#[serde(rename_all = "snake_case", tag = "code")]
464pub enum GetFilesystemUsageError {
465    ModelNotFound,
466    NotEnoughSpace,
467    AccessDenied,
468    QuotaExceeded,
469    ServerOverloaded,
470    BadCredentials,
471    TooManyRequests,
472    PaymentRequired,
473    Unknown,
474    #[serde(rename_all = "camelCase")]
475    InvalidParameter {
476        parameter_name: String,
477        reason: String,
478    },
479}
480
481#[derive(Debug, Clone, Deserialize)]
482#[serde(rename_all = "camelCase")]
483pub struct SetImageResult {}
484
485#[derive(Debug, Clone, Deserialize)]
486#[serde(rename_all = "snake_case", tag = "code")]
487pub enum SetImageError {
488    ModelNotFound,
489    AccessDenied,
490    ImageNotFound,
491    BadCredentials,
492    TooManyRequests,
493    PaymentRequired,
494    Unknown,
495    #[serde(rename_all = "camelCase")]
496    InvalidParameter {
497        parameter_name: String,
498        reason: String,
499    },
500}
501
502#[derive(Debug, Clone, Deserialize)]
503#[serde(rename_all = "camelCase")]
504pub struct CreateStateFailedDurations {
505    pub total: u64,
506    pub create_launcher: Option<u64>,
507    pub code_startup: Option<u64>,
508    pub create_state: Option<u64>,
509}
510
511#[derive(Debug, Clone, Deserialize)]
512#[serde(rename_all = "snake_case", tag = "code")]
513pub enum CreateStateFailedReason {
514    LauncherTerminated,
515    Cancelled,
516    ServerOverloaded,
517    InvalidExecutableFile,
518    ReadExecutableFileFailed,
519    Unknown,
520    #[serde(rename_all = "camelCase")]
521    MaxDurationExceeded {
522        at: AtCodeStartupOrCreateState,
523    },
524    #[serde(rename_all = "camelCase")]
525    CodeTerminated {
526        exit_code: Option<i32>,
527        signal: Option<String>,
528        oom: bool,
529    },
530    #[serde(rename_all = "camelCase")]
531    Exception {
532        at: AtCodeStartupOrCreateState,
533        exception_details: Option<String>,
534    },
535}
536
537#[derive(Debug, Clone, Deserialize)]
538#[serde(rename_all = "camelCase")]
539pub struct CreateStateDurations {
540    pub total: u64,
541    pub create_launcher: Option<u64>,
542    pub code_startup: Option<u64>,
543    pub create_state: u64,
544}
545
546#[derive(Debug, Clone, Deserialize)]
547#[serde(rename_all = "camelCase")]
548pub enum CreateStateResult {
549    #[serde(rename_all = "camelCase")]
550    Failed {
551        durations: CreateStateFailedDurations,
552        error: CreateStateFailedReason,
553    },
554    #[serde(rename_all = "camelCase")]
555    Success {
556        durations: CreateStateDurations,
557        state_id: String,
558    },
559}
560
561#[derive(Debug, Clone, Deserialize)]
562#[serde(rename_all = "snake_case", tag = "code")]
563pub enum CreateStateError {
564    ModelNotFound,
565    ModelToMountNotFound,
566    StateForModelToMountNotFound,
567    SnapshotForModelToMountNotFound,
568    PersistentLauncherNotFound,
569    SnapshotNoLongerExists,
570    AccessDenied,
571    QuotaExceeded,
572    #[serde(rename_all = "camelCase")]
573    DatasetNotFound {
574        dataset_id: String,
575    },
576    #[serde(rename_all = "camelCase")]
577    DatasetKeyNotFound {
578        dataset_id: String,
579        dataset_key: String,
580    },
581    BadCredentials,
582    TooManyRequests,
583    PaymentRequired,
584    Unknown,
585    #[serde(rename_all = "camelCase")]
586    InvalidParameter {
587        parameter_name: String,
588        reason: String,
589    },
590}
591
592#[derive(Debug, Clone, Deserialize)]
593#[serde(rename_all = "camelCase")]
594pub struct UploadStateResult {
595    pub state_id: String,
596}
597
598#[derive(Debug, Clone, Deserialize)]
599#[serde(rename_all = "snake_case", tag = "code")]
600pub enum UploadStateError {
601    ModelNotFound,
602    ModelToMountNotFound,
603    SnapshotForModelToMountNotFound,
604    AccessDenied,
605    QuotaExceeded,
606    StateNotFound,
607    StateIsActive,
608    BadCredentials,
609    TooManyRequests,
610    PaymentRequired,
611    Unknown,
612    #[serde(rename_all = "camelCase")]
613    InvalidParameter {
614        parameter_name: String,
615        reason: String,
616    },
617}
618
619#[derive(Debug, Clone, Deserialize)]
620#[serde(rename_all = "camelCase")]
621pub struct CancelCreateStateResult {}
622
623#[derive(Debug, Clone, Deserialize)]
624#[serde(rename_all = "snake_case", tag = "code")]
625pub enum CancelCreateStateError {
626    ModelNotFound,
627    StateNotFound,
628    StateAlreadyCreated,
629    BadCredentials,
630    TooManyRequests,
631    PaymentRequired,
632    Unknown,
633    #[serde(rename_all = "camelCase")]
634    InvalidParameter {
635        parameter_name: String,
636        reason: String,
637    },
638}
639
640#[derive(Debug, Clone, Deserialize)]
641#[serde(rename_all = "camelCase")]
642pub struct CreatingState {
643    pub id: String,
644    pub name: String,
645    pub started_at: i64,
646}
647
648#[derive(Debug, Clone, Deserialize)]
649#[serde(rename_all = "camelCase")]
650pub struct GetCreatingStatesResult {
651    pub states: Vec<CreatingState>,
652}
653
654#[derive(Debug, Clone, Deserialize)]
655#[serde(rename_all = "snake_case", tag = "code")]
656pub enum GetCreatingStatesError {
657    ModelNotFound,
658    BadCredentials,
659    TooManyRequests,
660    PaymentRequired,
661    Unknown,
662    #[serde(rename_all = "camelCase")]
663    InvalidParameter {
664        parameter_name: String,
665        reason: String,
666    },
667}
668
669#[derive(Debug, Clone, Deserialize)]
670#[serde(rename_all = "camelCase")]
671pub enum WaitForStateToBeCreatedResult {
672    #[serde(rename_all = "camelCase")]
673    Failed {
674        durations: CreateStateFailedDurations,
675        error: CreateStateFailedReason,
676    },
677    #[serde(rename_all = "camelCase")]
678    Success {
679        durations: CreateStateDurations,
680        state_id: String,
681    },
682}
683
684#[derive(Debug, Clone, Deserialize)]
685#[serde(rename_all = "snake_case", tag = "code")]
686pub enum WaitForStateToBeCreatedError {
687    ModelNotFound,
688    StateNotFound,
689    StateAlreadyCreated,
690    BadCredentials,
691    TooManyRequests,
692    PaymentRequired,
693    Unknown,
694    #[serde(rename_all = "camelCase")]
695    InvalidParameter {
696        parameter_name: String,
697        reason: String,
698    },
699}
700
701#[derive(Debug, Clone, Deserialize)]
702#[serde(rename_all = "camelCase")]
703pub struct UpdateModelStateResult {}
704
705#[derive(Debug, Clone, Deserialize)]
706#[serde(rename_all = "snake_case", tag = "code")]
707pub enum UpdateModelStateError {
708    ModelNotFound,
709    StateNotFound,
710    AccessDenied,
711    BadCredentials,
712    TooManyRequests,
713    PaymentRequired,
714    Unknown,
715    #[serde(rename_all = "camelCase")]
716    InvalidParameter {
717        parameter_name: String,
718        reason: String,
719    },
720}
721
722#[derive(Debug, Clone, Deserialize)]
723#[serde(rename_all = "camelCase")]
724pub struct SetActiveModelStateResult {}
725
726#[derive(Debug, Clone, Deserialize)]
727#[serde(rename_all = "snake_case", tag = "code")]
728pub enum SetActiveModelStateError {
729    ModelNotFound,
730    StateNotFound,
731    AccessDenied,
732    BadCredentials,
733    TooManyRequests,
734    PaymentRequired,
735    Unknown,
736    #[serde(rename_all = "camelCase")]
737    InvalidParameter {
738        parameter_name: String,
739        reason: String,
740    },
741}
742
743#[derive(Debug, Clone, Deserialize)]
744#[serde(rename_all = "camelCase")]
745pub struct DeleteModelStateResult {}
746
747#[derive(Debug, Clone, Deserialize)]
748#[serde(rename_all = "snake_case", tag = "code")]
749pub enum DeleteModelStateError {
750    ModelNotFound,
751    StateNotFound,
752    StateIsActive,
753    AccessDenied,
754    BadCredentials,
755    TooManyRequests,
756    PaymentRequired,
757    Unknown,
758    #[serde(rename_all = "camelCase")]
759    InvalidParameter {
760        parameter_name: String,
761        reason: String,
762    },
763}
764
765#[derive(Debug, Clone, Deserialize)]
766#[serde(rename_all = "camelCase")]
767pub struct GetModelStateResult {
768    #[serde(rename = "stateKeyNames")]
769    pub data: Vec<StateKeyData>,
770}
771
772#[derive(Debug, Clone, Deserialize)]
773#[serde(rename_all = "snake_case", tag = "code")]
774pub enum GetModelStateError {
775    ModelNotFound,
776    StateNotFound,
777    StateKeyNotFound,
778    BadCredentials,
779    TooManyRequests,
780    PaymentRequired,
781    Unknown,
782    #[serde(rename_all = "camelCase")]
783    InvalidParameter {
784        parameter_name: String,
785        reason: String,
786    },
787}
788
789#[derive(Debug, Clone, Deserialize)]
790#[serde(rename_all = "camelCase")]
791pub struct GetSnapshotStateResult {
792    #[serde(rename = "stateKeyNames")]
793    pub data: Vec<StateKeyData>,
794}
795
796#[derive(Debug, Clone, Deserialize)]
797#[serde(rename_all = "snake_case", tag = "code")]
798pub enum GetSnapshotStateError {
799    ModelNotFound,
800    SnapshotNotFound,
801    StateKeyNotFound,
802    BadCredentials,
803    TooManyRequests,
804    PaymentRequired,
805    Unknown,
806    #[serde(rename_all = "camelCase")]
807    InvalidParameter {
808        parameter_name: String,
809        reason: String,
810    },
811}
812
813#[derive(Debug, Clone, Deserialize)]
814#[serde(rename_all = "camelCase")]
815pub struct TrainResult {
816    /// A unique identifier which you should use in subsequent API calls.
817    pub training_session_id: String,
818}
819
820#[derive(Debug, Clone, Deserialize)]
821#[serde(rename_all = "snake_case", tag = "code")]
822pub enum TrainError {
823    ModelNotFound,
824    PersistentLauncherNotFound,
825    SnapshotNoLongerExists,
826    AccessDenied,
827    QuotaExceeded,
828    #[serde(rename_all = "camelCase")]
829    DatasetNotFound {
830        dataset_id: String,
831    },
832    #[serde(rename_all = "camelCase")]
833    DatasetKeyNotFound {
834        dataset_id: String,
835        dataset_key: String,
836    },
837    ModelToMountNoLongerExists,
838    BadCredentials,
839    TooManyRequests,
840    PaymentRequired,
841    Unknown,
842    #[serde(rename_all = "camelCase")]
843    InvalidParameter {
844        parameter_name: String,
845        reason: String,
846    },
847}
848
849#[derive(Debug, Clone, Deserialize)]
850#[serde(rename_all = "camelCase")]
851pub struct TrainMetric {
852    pub name: String,
853    pub amount: u32,
854}
855
856#[derive(Debug, Clone, Deserialize)]
857#[serde(rename_all = "camelCase")]
858pub struct TrainingStartDurations {
859    pub create_launcher: Option<u64>,
860    pub code_startup: Option<u64>,
861    pub create_instantiated_model: Option<u64>,
862}
863
864#[derive(Debug, Clone, Deserialize)]
865#[serde(rename_all = "camelCase")]
866pub enum AtCodeStartupOrInstantiateModelOrTrainOrGetState {
867    CodeStartup,
868    InstantiateModel,
869    Train,
870    GetState,
871}
872
873#[derive(Debug, Clone, Deserialize)]
874#[serde(rename_all = "snake_case", tag = "code")]
875pub enum TrainingSessionFailReason {
876    Cancelled,
877    LauncherTerminated,
878    ServerOverloaded,
879    InvalidExecutableFile,
880    ReadExecutableFileFailed,
881    Unknown,
882    #[serde(rename_all = "camelCase")]
883    Exception {
884        at: AtCodeStartupOrInstantiateModelOrTrainOrGetState,
885        exception_details: Option<String>,
886    },
887    #[serde(rename_all = "camelCase")]
888    CodeTerminated {
889        exit_code: Option<i32>,
890        signal: Option<String>,
891        oom: bool,
892    },
893    #[serde(rename_all = "camelCase")]
894    MaxDurationExceeded {
895        at: AtCodeStartupOrInstantiateModelOrTrainOrGetState,
896    },
897}
898
899#[derive(Debug, Clone, Deserialize)]
900#[serde(rename_all = "camelCase", tag = "state")]
901pub enum TrainingStatus {
902    Starting,
903    #[serde(rename_all = "camelCase")]
904    Running {
905        start_durations: TrainingStartDurations,
906        progress: f32,
907    },
908    #[serde(rename_all = "camelCase")]
909    GettingState {
910        start_durations: TrainingStartDurations,
911        train_duration: u64,
912    },
913    #[serde(rename_all = "camelCase")]
914    Completed {
915        start_durations: TrainingStartDurations,
916        train_duration: u64,
917        get_state_duration: u64,
918        finished_at: i64,
919        created_state_id: String,
920    },
921    #[serde(rename_all = "camelCase")]
922    Failed {
923        start_durations: TrainingStartDurations,
924        train_duration: Option<u64>,
925        get_state_duration: Option<u64>,
926        finished_at: i64,
927        fail_reason: TrainingSessionFailReason,
928    },
929}
930
931#[derive(Debug, Clone, Deserialize)]
932#[serde(rename_all = "camelCase")]
933pub struct GetTrainingStatusResult {
934    pub id: String,
935    pub model_id: String,
936    pub new_state_name: String,
937    pub created_at: i64,
938    pub metrics: Vec<TrainMetric>,
939    pub execution_location: ExecutionLocation,
940    pub status: TrainingStatus,
941}
942
943#[derive(Debug, Clone, Deserialize)]
944#[serde(rename_all = "snake_case", tag = "code")]
945pub enum GetTrainingStatusError {
946    ModelNotFound,
947    TrainingSessionNotFound,
948    BadCredentials,
949    TooManyRequests,
950    PaymentRequired,
951    Unknown,
952    #[serde(rename_all = "camelCase")]
953    InvalidParameter {
954        parameter_name: String,
955        reason: String,
956    },
957}
958
959#[derive(Debug, Clone, Deserialize)]
960#[serde(rename_all = "camelCase")]
961pub struct FetchedTrainingMetricEntry {
962    pub timestamp: i64,
963    #[serde(deserialize_with = "super::super::deserialize_empty_owned_decthings_tensor")]
964    pub data: OwnedDecthingsTensor,
965}
966
967#[derive(Debug, Clone, Deserialize)]
968#[serde(rename_all = "camelCase")]
969pub struct FetchedTrainingMetric {
970    pub name: String,
971    pub start_index: u32,
972    pub entries: Vec<FetchedTrainingMetricEntry>,
973}
974
975#[derive(Debug, Clone, Deserialize)]
976#[serde(rename_all = "camelCase")]
977pub struct GetTrainingMetricsResult {
978    pub metrics: Vec<FetchedTrainingMetric>,
979}
980
981#[derive(Debug, Clone, Deserialize)]
982#[serde(rename_all = "snake_case", tag = "code")]
983pub enum GetTrainingMetricsError {
984    ModelNotFound,
985    TrainingSessionNotFound,
986    BadCredentials,
987    TooManyRequests,
988    PaymentRequired,
989    Unknown,
990    #[serde(rename_all = "camelCase")]
991    InvalidParameter {
992        parameter_name: String,
993        reason: String,
994    },
995}
996
997#[derive(Debug, Clone, Deserialize)]
998#[serde(rename_all = "camelCase")]
999pub struct SysinfoDataPoint {
1000    pub timestamp: i64,
1001    pub cpus: f32,
1002    pub memory: u32,
1003    pub disk: Option<u32>,
1004}
1005
1006#[derive(Debug, Clone, Deserialize)]
1007#[serde(rename_all = "camelCase")]
1008pub struct GetTrainingSysinfoResult {
1009    pub sysinfo: Vec<SysinfoDataPoint>,
1010}
1011
1012#[derive(Debug, Clone, Deserialize)]
1013#[serde(rename_all = "snake_case", tag = "code")]
1014pub enum GetTrainingSysinfoError {
1015    ModelNotFound,
1016    TrainingSessionNotFound,
1017    BadCredentials,
1018    TooManyRequests,
1019    PaymentRequired,
1020    Unknown,
1021    #[serde(rename_all = "camelCase")]
1022    InvalidParameter {
1023        parameter_name: String,
1024        reason: String,
1025    },
1026}
1027
1028#[derive(Debug, Clone, Deserialize)]
1029#[serde(rename_all = "camelCase")]
1030pub struct CancelTrainingSessionResult {}
1031
1032#[derive(Debug, Clone, Deserialize)]
1033#[serde(rename_all = "snake_case", tag = "code")]
1034pub enum CancelTrainingSessionError {
1035    ModelNotFound,
1036    TrainingSessionNotFound,
1037    TrainingSessionNotRunning,
1038    AccessDenied,
1039    BadCredentials,
1040    TooManyRequests,
1041    PaymentRequired,
1042    Unknown,
1043    #[serde(rename_all = "camelCase")]
1044    InvalidParameter {
1045        parameter_name: String,
1046        reason: String,
1047    },
1048}
1049
1050#[derive(Debug, Clone, Deserialize)]
1051#[serde(rename_all = "camelCase")]
1052pub struct ClearPreviousTrainingSessionResult {}
1053
1054#[derive(Debug, Clone, Deserialize)]
1055#[serde(rename_all = "snake_case", tag = "code")]
1056pub enum ClearPreviousTrainingSessionError {
1057    ModelNotFound,
1058    TrainingSessionNotFound,
1059    TrainingSessionRunning,
1060    AccessDenied,
1061    BadCredentials,
1062    TooManyRequests,
1063    PaymentRequired,
1064    Unknown,
1065    #[serde(rename_all = "camelCase")]
1066    InvalidParameter {
1067        parameter_name: String,
1068        reason: String,
1069    },
1070}
1071
1072#[derive(Debug, Clone, Deserialize)]
1073#[serde(rename_all = "camelCase")]
1074pub struct FailedEvaluationDurations {
1075    pub create_launcher: Option<u64>,
1076    pub code_startup: Option<u64>,
1077    pub create_instantiated_model: Option<u64>,
1078    pub evaluate: Option<u64>,
1079}
1080
1081#[derive(Debug, Clone, Deserialize)]
1082#[serde(rename_all = "camelCase")]
1083pub enum AtCodeStartupOrInstantiateModelOrEvaluate {
1084    CodeStartup,
1085    InstantiateModel,
1086    Evaluate,
1087}
1088
1089#[derive(Debug, Clone, Deserialize)]
1090#[serde(rename_all = "snake_case")]
1091pub enum InvalidOutputType {
1092    Invalid,
1093    NotApplicableToParameterDefinitions,
1094}
1095
1096#[derive(Debug, Clone, Deserialize)]
1097#[serde(rename_all = "snake_case", tag = "code")]
1098pub enum FailedEvaluationError {
1099    LauncherTerminated,
1100    Cancelled,
1101    ServerOverloaded,
1102    InvalidExecutableFile,
1103    ReadExecutableFileFailed,
1104    Unknown,
1105    #[serde(rename_all = "camelCase")]
1106    MaxDurationExceeded {
1107        at: AtCodeStartupOrInstantiateModelOrEvaluate,
1108    },
1109    #[serde(rename_all = "camelCase")]
1110    CodeTerminated {
1111        exit_code: Option<i32>,
1112        signal: Option<String>,
1113        oom: bool,
1114    },
1115    #[serde(rename_all = "camelCase")]
1116    Exception {
1117        at: AtCodeStartupOrInstantiateModelOrEvaluate,
1118        exception_details: Option<String>,
1119    },
1120    #[serde(rename_all = "camelCase")]
1121    InvalidOutput {
1122        reason: InvalidOutputType,
1123        details: String,
1124    },
1125}
1126
1127#[derive(Debug, Clone, Deserialize)]
1128#[serde(rename_all = "camelCase")]
1129pub struct EvaluationDurations {
1130    pub create_launcher: Option<u64>,
1131    pub code_startup: Option<u64>,
1132    pub create_instantiated_model: Option<u64>,
1133    pub evaluate: u64,
1134}
1135
1136#[derive(Debug, Clone, Deserialize)]
1137#[serde(rename_all = "camelCase")]
1138pub enum EvaluateResult {
1139    #[serde(rename_all = "camelCase")]
1140    Failed {
1141        total_duration: u64,
1142        durations: FailedEvaluationDurations,
1143        executed_on_launcher: ExecutionLocation,
1144        error: FailedEvaluationError,
1145    },
1146    #[serde(rename_all = "camelCase")]
1147    Success {
1148        total_duration: u64,
1149        durations: EvaluationDurations,
1150        executed_on_launcher: ExecutionLocation,
1151        output: Vec<DecthingsParameter>,
1152    },
1153}
1154
1155#[derive(Debug, Clone, Deserialize)]
1156#[serde(rename_all = "snake_case", tag = "code")]
1157pub enum EvaluateError {
1158    ModelNotFound,
1159    SnapshotNotFound,
1160    QuotaExceeded,
1161    #[serde(rename_all = "camelCase")]
1162    DatasetNotFound {
1163        dataset_id: String,
1164    },
1165    #[serde(rename_all = "camelCase")]
1166    DatasetKeyNotFound {
1167        dataset_id: String,
1168        dataset_key: String,
1169    },
1170    ModelToMountNoLongerExists,
1171    BadCredentials,
1172    TooManyRequests,
1173    PaymentRequired,
1174    Unknown,
1175    #[serde(rename_all = "camelCase")]
1176    InvalidParameter {
1177        parameter_name: String,
1178        reason: String,
1179    },
1180}
1181
1182#[derive(Debug, Clone, Deserialize)]
1183#[serde(rename_all = "camelCase")]
1184pub struct RunningEvaluation {
1185    pub id: String,
1186    pub started_at: i64,
1187}
1188
1189#[derive(Debug, Clone, Deserialize)]
1190#[serde(rename_all = "camelCase")]
1191pub struct FinishedEvaluation {
1192    pub id: String,
1193    pub started_at: i64,
1194    pub finished_at: i64,
1195    pub success: bool,
1196}
1197
1198#[derive(Debug, Clone, Deserialize)]
1199#[serde(rename_all = "camelCase")]
1200pub struct GetEvaluationsResult {
1201    pub running: Vec<RunningEvaluation>,
1202    pub finished: Vec<FinishedEvaluation>,
1203}
1204
1205#[derive(Debug, Clone, Deserialize)]
1206#[serde(rename_all = "snake_case", tag = "code")]
1207pub enum GetEvaluationsError {
1208    ModelNotFound,
1209    BadCredentials,
1210    TooManyRequests,
1211    PaymentRequired,
1212    Unknown,
1213    #[serde(rename_all = "camelCase")]
1214    InvalidParameter {
1215        parameter_name: String,
1216        reason: String,
1217    },
1218}
1219
1220#[derive(Debug, Clone, Deserialize)]
1221#[serde(rename_all = "camelCase")]
1222pub enum GetFinishedEvaluationResultResult {
1223    #[serde(rename_all = "camelCase")]
1224    Failed {
1225        total_duration: u64,
1226        durations: FailedEvaluationDurations,
1227        executed_on_launcher: ExecutionLocation,
1228        error: FailedEvaluationError,
1229    },
1230    #[serde(rename_all = "camelCase")]
1231    Success {
1232        total_duration: u64,
1233        durations: EvaluationDurations,
1234        executed_on_launcher: ExecutionLocation,
1235        output: Vec<DecthingsParameter>,
1236    },
1237}
1238
1239#[derive(Debug, Clone, Deserialize)]
1240#[serde(rename_all = "snake_case", tag = "code")]
1241pub enum GetFinishedEvaluationResultError {
1242    ModelNotFound,
1243    EvaluationNotFound,
1244    BadCredentials,
1245    TooManyRequests,
1246    PaymentRequired,
1247    Unknown,
1248    #[serde(rename_all = "camelCase")]
1249    InvalidParameter {
1250        parameter_name: String,
1251        reason: String,
1252    },
1253}
1254
1255#[derive(Debug, Clone, Deserialize)]
1256#[serde(rename_all = "camelCase")]
1257pub struct CancelEvaluationResult {}
1258
1259#[derive(Debug, Clone, Deserialize)]
1260#[serde(rename_all = "snake_case", tag = "code")]
1261pub enum CancelEvaluationError {
1262    ModelNotFound,
1263    EvaluationNotFound,
1264    BadCredentials,
1265    TooManyRequests,
1266    PaymentRequired,
1267    Unknown,
1268    #[serde(rename_all = "camelCase")]
1269    InvalidParameter {
1270        parameter_name: String,
1271        reason: String,
1272    },
1273}
1274
1275#[derive(Debug, Clone, Deserialize)]
1276#[serde(rename_all = "camelCase")]
1277pub struct SetUsedPersistentLaunchersForEvaluateResult {}
1278
1279#[derive(Debug, Clone, Deserialize)]
1280#[serde(rename_all = "snake_case", tag = "code")]
1281pub enum SetUsedPersistentLaunchersForEvaluateError {
1282    PersistentLauncherNotFound,
1283    ModelNotFound,
1284    SnapshotNoLongerExists,
1285    AccessDenied,
1286    BadCredentials,
1287    TooManyRequests,
1288    PaymentRequired,
1289    Unknown,
1290    #[serde(rename_all = "camelCase")]
1291    InvalidParameter {
1292        parameter_name: String,
1293        reason: String,
1294    },
1295}
1296
1297#[derive(Debug, Clone, Serialize, Deserialize)]
1298#[serde(rename_all = "camelCase")]
1299pub enum UsedPersistentLauncherLevel {
1300    Launcher,
1301    CodeStart,
1302    InstantiatedModel,
1303}
1304
1305#[derive(Debug, Clone, Deserialize)]
1306#[serde(rename_all = "camelCase")]
1307pub struct UsedPersistentLauncher {
1308    pub persistent_launcher_id: String,
1309    pub level: UsedPersistentLauncherLevel,
1310}
1311
1312#[derive(Debug, Clone, Deserialize)]
1313#[serde(rename_all = "camelCase")]
1314pub struct GetUsedPersistentLaunchersForEvaluateResult {
1315    pub used_persistent_launchers: Vec<UsedPersistentLauncher>,
1316}
1317
1318#[derive(Debug, Clone, Deserialize)]
1319#[serde(rename_all = "snake_case", tag = "code")]
1320pub enum GetUsedPersistentLaunchersForEvaluateError {
1321    ModelNotFound,
1322    BadCredentials,
1323    TooManyRequests,
1324    PaymentRequired,
1325    Unknown,
1326    #[serde(rename_all = "camelCase")]
1327    InvalidParameter {
1328        parameter_name: String,
1329        reason: String,
1330    },
1331}
decthings_api/client/rpc/model/response.rs

decthings_api/client/rpc/model/
response.rs
