decthings_api/client/rpc/
mod.rs

1use serde::{ser::SerializeSeq, Deserialize, Serialize, Serializer};
2
3use crate::tensor::DecthingsParameterDefinition;
4
5pub mod dataset;
6pub mod debug;
7pub mod fs;
8pub mod image;
9
10#[cfg(feature = "events")]
11pub mod language;
12
13pub mod model;
14pub mod persistent_launcher;
15pub mod spawned;
16pub mod terminal;
17
18#[derive(Debug, Clone, PartialEq, Serialize)]
19#[serde(rename_all = "camelCase")]
20pub struct TagProvider<'a> {
21    pub tag: &'a str,
22    pub value: &'a str,
23}
24
25#[derive(Debug, Clone, PartialEq, Deserialize)]
26#[serde(rename_all = "camelCase")]
27pub struct Tag {
28    pub tag: String,
29    pub value: String,
30}
31
32fn serialize_option_asref_str_seq<S: Serializer, T: AsRef<str>>(
33    values: &Option<&[T]>,
34    serializer: S,
35) -> Result<S::Ok, S::Error> {
36    let Some(values) = values else {
37        return serializer.serialize_none();
38    };
39    let mut seq = serializer.serialize_seq(Some(values.len()))?;
40    for value in *values {
41        seq.serialize_element(value.as_ref())?;
42    }
43    seq.end()
44}
45
46fn serialize_asref_str_seq<S: Serializer, T: AsRef<str>>(
47    values: &&[T],
48    serializer: S,
49) -> Result<S::Ok, S::Error> {
50    let mut seq = serializer.serialize_seq(Some(values.len()))?;
51    for value in *values {
52        seq.serialize_element(value.as_ref())?;
53    }
54    seq.end()
55}
56
57#[derive(Deserialize)]
58#[serde(rename_all = "camelCase")]
59pub(super) enum Response<R, E> {
60    Result(R),
61    Error(E),
62}
63
64#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
65#[serde(rename_all = "camelCase")]
66pub struct LauncherSpecGpus {
67    /// GPU type, such as "L4" or "A100 80GB"
68    pub model: String,
69    pub count: u32,
70}
71
72#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
73#[serde(rename_all = "camelCase")]
74pub struct LauncherSpec {
75    pub cpus: f64,
76    pub memory_mebibytes: u32,
77    #[serde(skip_serializing_if = "Option::is_none")]
78    pub disk_mebibytes: Option<u32>,
79    #[serde(skip_serializing_if = "Option::is_none")]
80    pub swap_mebibytes: Option<u32>,
81    #[serde(skip_serializing_if = "Option::is_none")]
82    pub gpus: Option<LauncherSpecGpus>,
83}
84
85#[derive(Debug, Clone, PartialEq, Serialize)]
86#[serde(rename_all = "camelCase", tag = "type")]
87pub enum ExecutionLocationProvider<'a> {
88    #[serde(rename_all = "camelCase")]
89    PersistentLauncher { persistent_launcher_id: &'a str },
90    #[serde(rename_all = "camelCase")]
91    TemporaryLauncher { spec: &'a LauncherSpec },
92}
93
94#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
95#[serde(tag = "type", rename_all = "camelCase")]
96pub enum ExecutionLocation {
97    #[serde(rename_all = "camelCase")]
98    PersistentLauncher {
99        persistent_launcher_id: String,
100        spec: LauncherSpec,
101    },
102    #[serde(rename_all = "camelCase")]
103    TemporaryLauncher { spec: LauncherSpec },
104}
105
106#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
107#[serde(rename_all = "camelCase")]
108pub struct ParameterDefinitions {
109    pub create_state: Vec<DecthingsParameterDefinition>,
110    pub train: Vec<DecthingsParameterDefinition>,
111    pub evaluate_input: Vec<DecthingsParameterDefinition>,
112    pub evaluate_output: Vec<DecthingsParameterDefinition>,
113}
114
115#[derive(Debug, Clone)]
116pub struct StateKeyData {
117    pub key: String,
118    pub data: bytes::Bytes,
119}
120
121impl<'de> Deserialize<'de> for StateKeyData {
122    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
123    where
124        D: serde::Deserializer<'de>,
125    {
126        let s = String::deserialize(deserializer)?;
127        Ok(Self {
128            key: s,
129            data: vec![].into(),
130        })
131    }
132}
133
134fn many_decthings_tensors_from_bytes(
135    data: bytes::Bytes,
136) -> Result<Vec<crate::tensor::OwnedDecthingsTensor>, ()> {
137    let mut res = vec![];
138    let mut pos = 0;
139    while data.len() > pos {
140        let val =
141            crate::tensor::OwnedDecthingsTensor::from_bytes(data.slice(pos..)).map_err(|_| ())?;
142        pos += val.byte_size();
143        res.push(val);
144    }
145    Ok(res)
146}
147
148pub(crate) fn deserialize_empty_owned_decthings_tensor<'de, D: serde::Deserializer<'de>>(
149    _: D,
150) -> Result<crate::tensor::OwnedDecthingsTensor, D::Error> {
151    Ok(crate::tensor::OwnedDecthingsTensor {
152        data: vec![].into(),
153    })
154}
decthings_api/client/rpc/mod.rs

decthings_api/client/rpc/
mod.rs
