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}