1use super::{configuration, Error};
12use crate::{apis::ResponseContent, models};
13use reqwest;
14use serde::{Deserialize, Serialize};
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum DatasetsCreateError {
20 Status400(serde_json::Value),
21 Status401(serde_json::Value),
22 Status403(serde_json::Value),
23 Status404(serde_json::Value),
24 Status405(serde_json::Value),
25 UnknownValue(serde_json::Value),
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum DatasetsGetError {
32 Status400(serde_json::Value),
33 Status401(serde_json::Value),
34 Status403(serde_json::Value),
35 Status404(serde_json::Value),
36 Status405(serde_json::Value),
37 UnknownValue(serde_json::Value),
38}
39
40#[derive(Debug, Clone, Serialize, Deserialize)]
42#[serde(untagged)]
43pub enum DatasetsGetRunError {
44 Status400(serde_json::Value),
45 Status401(serde_json::Value),
46 Status403(serde_json::Value),
47 Status404(serde_json::Value),
48 Status405(serde_json::Value),
49 UnknownValue(serde_json::Value),
50}
51
52#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum DatasetsGetRunsError {
56 Status400(serde_json::Value),
57 Status401(serde_json::Value),
58 Status403(serde_json::Value),
59 Status404(serde_json::Value),
60 Status405(serde_json::Value),
61 UnknownValue(serde_json::Value),
62}
63
64#[derive(Debug, Clone, Serialize, Deserialize)]
66#[serde(untagged)]
67pub enum DatasetsListError {
68 Status400(serde_json::Value),
69 Status401(serde_json::Value),
70 Status403(serde_json::Value),
71 Status404(serde_json::Value),
72 Status405(serde_json::Value),
73 UnknownValue(serde_json::Value),
74}
75
76pub async fn datasets_create(
78 configuration: &configuration::Configuration,
79 create_dataset_request: models::CreateDatasetRequest,
80) -> Result<models::Dataset, Error<DatasetsCreateError>> {
81 let p_create_dataset_request = create_dataset_request;
83
84 let uri_str = format!("{}/api/public/v2/datasets", configuration.base_path);
85 let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
86
87 if let Some(ref user_agent) = configuration.user_agent {
88 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
89 }
90 if let Some(ref auth_conf) = configuration.basic_auth {
91 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
92 };
93 req_builder = req_builder.json(&p_create_dataset_request);
94
95 let req = req_builder.build()?;
96 let resp = configuration.client.execute(req).await?;
97
98 let status = resp.status();
99
100 if !status.is_client_error() && !status.is_server_error() {
101 let content = resp.text().await?;
102 serde_json::from_str(&content).map_err(Error::from)
103 } else {
104 let content = resp.text().await?;
105 let entity: Option<DatasetsCreateError> = serde_json::from_str(&content).ok();
106 Err(Error::ResponseError(ResponseContent { status, content, entity }))
107 }
108}
109
110pub async fn datasets_get(configuration: &configuration::Configuration, dataset_name: &str) -> Result<models::Dataset, Error<DatasetsGetError>> {
112 let p_dataset_name = dataset_name;
114
115 let uri_str = format!(
116 "{}/api/public/v2/datasets/{datasetName}",
117 configuration.base_path,
118 datasetName = crate::apis::urlencode(p_dataset_name)
119 );
120 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
121
122 if let Some(ref user_agent) = configuration.user_agent {
123 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
124 }
125 if let Some(ref auth_conf) = configuration.basic_auth {
126 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
127 };
128
129 let req = req_builder.build()?;
130 let resp = configuration.client.execute(req).await?;
131
132 let status = resp.status();
133
134 if !status.is_client_error() && !status.is_server_error() {
135 let content = resp.text().await?;
136 serde_json::from_str(&content).map_err(Error::from)
137 } else {
138 let content = resp.text().await?;
139 let entity: Option<DatasetsGetError> = serde_json::from_str(&content).ok();
140 Err(Error::ResponseError(ResponseContent { status, content, entity }))
141 }
142}
143
144pub async fn datasets_get_run(
146 configuration: &configuration::Configuration,
147 dataset_name: &str,
148 run_name: &str,
149) -> Result<models::DatasetRunWithItems, Error<DatasetsGetRunError>> {
150 let p_dataset_name = dataset_name;
152 let p_run_name = run_name;
153
154 let uri_str = format!(
155 "{}/api/public/datasets/{datasetName}/runs/{runName}",
156 configuration.base_path,
157 datasetName = crate::apis::urlencode(p_dataset_name),
158 runName = crate::apis::urlencode(p_run_name)
159 );
160 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
161
162 if let Some(ref user_agent) = configuration.user_agent {
163 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
164 }
165 if let Some(ref auth_conf) = configuration.basic_auth {
166 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
167 };
168
169 let req = req_builder.build()?;
170 let resp = configuration.client.execute(req).await?;
171
172 let status = resp.status();
173
174 if !status.is_client_error() && !status.is_server_error() {
175 let content = resp.text().await?;
176 serde_json::from_str(&content).map_err(Error::from)
177 } else {
178 let content = resp.text().await?;
179 let entity: Option<DatasetsGetRunError> = serde_json::from_str(&content).ok();
180 Err(Error::ResponseError(ResponseContent { status, content, entity }))
181 }
182}
183
184pub async fn datasets_get_runs(
186 configuration: &configuration::Configuration,
187 dataset_name: &str,
188 page: Option<i32>,
189 limit: Option<i32>,
190) -> Result<models::PaginatedDatasetRuns, Error<DatasetsGetRunsError>> {
191 let p_dataset_name = dataset_name;
193 let p_page = page;
194 let p_limit = limit;
195
196 let uri_str = format!(
197 "{}/api/public/datasets/{datasetName}/runs",
198 configuration.base_path,
199 datasetName = crate::apis::urlencode(p_dataset_name)
200 );
201 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
202
203 if let Some(ref param_value) = p_page {
204 req_builder = req_builder.query(&[("page", ¶m_value.to_string())]);
205 }
206 if let Some(ref param_value) = p_limit {
207 req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]);
208 }
209 if let Some(ref user_agent) = configuration.user_agent {
210 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
211 }
212 if let Some(ref auth_conf) = configuration.basic_auth {
213 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
214 };
215
216 let req = req_builder.build()?;
217 let resp = configuration.client.execute(req).await?;
218
219 let status = resp.status();
220
221 if !status.is_client_error() && !status.is_server_error() {
222 let content = resp.text().await?;
223 serde_json::from_str(&content).map_err(Error::from)
224 } else {
225 let content = resp.text().await?;
226 let entity: Option<DatasetsGetRunsError> = serde_json::from_str(&content).ok();
227 Err(Error::ResponseError(ResponseContent { status, content, entity }))
228 }
229}
230
231pub async fn datasets_list(
233 configuration: &configuration::Configuration,
234 page: Option<i32>,
235 limit: Option<i32>,
236) -> Result<models::PaginatedDatasets, Error<DatasetsListError>> {
237 let p_page = page;
239 let p_limit = limit;
240
241 let uri_str = format!("{}/api/public/v2/datasets", configuration.base_path);
242 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
243
244 if let Some(ref param_value) = p_page {
245 req_builder = req_builder.query(&[("page", ¶m_value.to_string())]);
246 }
247 if let Some(ref param_value) = p_limit {
248 req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]);
249 }
250 if let Some(ref user_agent) = configuration.user_agent {
251 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
252 }
253 if let Some(ref auth_conf) = configuration.basic_auth {
254 req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
255 };
256
257 let req = req_builder.build()?;
258 let resp = configuration.client.execute(req).await?;
259
260 let status = resp.status();
261
262 if !status.is_client_error() && !status.is_server_error() {
263 let content = resp.text().await?;
264 serde_json::from_str(&content).map_err(Error::from)
265 } else {
266 let content = resp.text().await?;
267 let entity: Option<DatasetsListError> = serde_json::from_str(&content).ok();
268 Err(Error::ResponseError(ResponseContent { status, content, entity }))
269 }
270}