mistral_rouille/apis/
default_api.rs

1#![allow(unused)]
2/*
3 * Mistral AI API
4 *
5 * Our Chat Completion and Embeddings APIs specification. Create your account on [La Plateforme](https://console.mistral.ai) to get access and read the [docs](https://docs.mistral.ai) to learn how to use it.
6 *
7 * Build date: 2024-06-15T23:41:00.377209-06:00[America/Mexico_City]
8 * Generated using: https://openapi-generator.tech
9 * Open API specification v0.0.2 provided by Mistral @ https://docs.mistral.ai/redocusaurus/plugin-redoc-0.yaml
10 * Custom generation templates by [GovCraft Ai](https://www.govcraft.ai)
11 * Contact: roland@govcraft.ai
12 */
13
14use super::{configuration, Error};
15use crate::{apis::ResponseContent, models};
16use reqwest;
17use serde::{Deserialize, Serialize};
18
19/// struct for passing parameters to the method [`create_chat_completion`]
20#[derive(Clone, Debug)]
21pub struct CreateChatCompletionParams {
22    pub chat_request: models::ChatRequest,
23}
24
25/// struct for passing parameters to the method [`create_embedding`]
26#[derive(Clone, Debug)]
27pub struct CreateEmbeddingParams {
28    pub embedding_request: models::EmbeddingRequest,
29}
30
31/// struct for passing parameters to the method [`create_fim_completion`]
32#[derive(Clone, Debug)]
33pub struct CreateFimCompletionParams {
34    pub fim_completion_request: models::FimCompletionRequest,
35}
36
37/// struct for passing parameters to the method [`files_api_routes_delete_file`]
38#[derive(Clone, Debug)]
39pub struct FilesApiRoutesDeleteFileParams {
40    pub file_id: String,
41}
42
43/// struct for passing parameters to the method [`files_api_routes_retrieve_file`]
44#[derive(Clone, Debug)]
45pub struct FilesApiRoutesRetrieveFileParams {
46    pub file_id: String,
47}
48
49/// struct for passing parameters to the method [`files_api_routes_upload_file`]
50#[derive(Clone, Debug)]
51pub struct FilesApiRoutesUploadFileParams {
52    pub purpose: Option<models::serde_json::Value>,
53    /// The File object (not file name) to be uploaded.   To upload a file and specify a custom file name you should format your request as such:   ```   file=@path/to/your/file.jsonl;filename=custom_name.jsonl   ```  Otherwise, you can just keep the original file name:   ```   file=@path/to/your/file.jsonl   ```
54    pub file: std::path::PathBuf,
55}
56
57/// struct for passing parameters to the method [`jobs_api_routes_fine_tuning_cancel_fine_tuning_job`]
58#[derive(Clone, Debug)]
59pub struct JobsApiRoutesFineTuningCancelFineTuningJobParams {
60    pub job_id: String,
61}
62
63/// struct for passing parameters to the method [`jobs_api_routes_fine_tuning_create_fine_tuning_job`]
64#[derive(Clone, Debug)]
65pub struct JobsApiRoutesFineTuningCreateFineTuningJobParams {
66    pub job_in: models::JobIn,
67    pub dry_run: Option<bool>,
68}
69
70/// struct for passing parameters to the method [`jobs_api_routes_fine_tuning_get_fine_tuning_job`]
71#[derive(Clone, Debug)]
72pub struct JobsApiRoutesFineTuningGetFineTuningJobParams {
73    pub job_id: String,
74}
75
76/// struct for passing parameters to the method [`jobs_api_routes_fine_tuning_get_fine_tuning_jobs`]
77#[derive(Clone, Debug)]
78pub struct JobsApiRoutesFineTuningGetFineTuningJobsParams {
79    /// The page number of the results to be returned.
80    pub page: Option<i32>,
81    /// The number of items to return per page.
82    pub page_size: Option<i32>,
83    /// The model name used for fine-tuning to filter on. When set, the other results are not displayed.
84    pub model: Option<String>,
85    /// The current job state to filter on. When set, the other results are not displayed.
86    pub status: Option<String>,
87    pub created_after: Option<String>,
88    pub created_by_me: Option<bool>,
89    pub wandb_project: Option<String>,
90    pub wandb_name: Option<String>,
91    pub suffix: Option<String>,
92}
93
94/// struct for typed successes of method [`create_chat_completion`]
95#[derive(Debug, Clone, Serialize, Deserialize)]
96#[serde(untagged)]
97pub enum CreateChatCompletionSuccess {
98    Status200(models::ChatResponse),
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed successes of method [`create_embedding`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum CreateEmbeddingSuccess {
106    Status200(models::EmbeddingResponse),
107    UnknownValue(serde_json::Value),
108}
109
110/// struct for typed successes of method [`create_fim_completion`]
111#[derive(Debug, Clone, Serialize, Deserialize)]
112#[serde(untagged)]
113pub enum CreateFimCompletionSuccess {
114    Status200(models::FimCompletionResponse),
115    UnknownValue(serde_json::Value),
116}
117
118/// struct for typed successes of method [`files_api_routes_delete_file`]
119#[derive(Debug, Clone, Serialize, Deserialize)]
120#[serde(untagged)]
121pub enum FilesApiRoutesDeleteFileSuccess {
122    Status200(models::DeleteFileOut),
123    UnknownValue(serde_json::Value),
124}
125
126/// struct for typed successes of method [`files_api_routes_list_files`]
127#[derive(Debug, Clone, Serialize, Deserialize)]
128#[serde(untagged)]
129pub enum FilesApiRoutesListFilesSuccess {
130    Status200(models::ListFilesOut),
131    UnknownValue(serde_json::Value),
132}
133
134/// struct for typed successes of method [`files_api_routes_retrieve_file`]
135#[derive(Debug, Clone, Serialize, Deserialize)]
136#[serde(untagged)]
137pub enum FilesApiRoutesRetrieveFileSuccess {
138    Status200(models::RetrieveFileOut),
139    UnknownValue(serde_json::Value),
140}
141
142/// struct for typed successes of method [`files_api_routes_upload_file`]
143#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum FilesApiRoutesUploadFileSuccess {
146    Status200(models::UploadFileOut),
147    UnknownValue(serde_json::Value),
148}
149
150/// struct for typed successes of method [`jobs_api_routes_fine_tuning_cancel_fine_tuning_job`]
151#[derive(Debug, Clone, Serialize, Deserialize)]
152#[serde(untagged)]
153pub enum JobsApiRoutesFineTuningCancelFineTuningJobSuccess {
154    Status200(models::DetailedJobOut),
155    UnknownValue(serde_json::Value),
156}
157
158/// struct for typed successes of method [`jobs_api_routes_fine_tuning_create_fine_tuning_job`]
159#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum JobsApiRoutesFineTuningCreateFineTuningJobSuccess {
162    Status200(models::FineTuningJobResponse),
163    UnknownValue(serde_json::Value),
164}
165
166/// struct for typed successes of method [`jobs_api_routes_fine_tuning_get_fine_tuning_job`]
167#[derive(Debug, Clone, Serialize, Deserialize)]
168#[serde(untagged)]
169pub enum JobsApiRoutesFineTuningGetFineTuningJobSuccess {
170    Status200(models::DetailedJobOut),
171    UnknownValue(serde_json::Value),
172}
173
174/// struct for typed successes of method [`jobs_api_routes_fine_tuning_get_fine_tuning_jobs`]
175#[derive(Debug, Clone, Serialize, Deserialize)]
176#[serde(untagged)]
177pub enum JobsApiRoutesFineTuningGetFineTuningJobsSuccess {
178    Status200(models::JobsOut),
179    UnknownValue(serde_json::Value),
180}
181
182/// struct for typed successes of method [`list_models`]
183#[derive(Debug, Clone, Serialize, Deserialize)]
184#[serde(untagged)]
185pub enum ListModelsSuccess {
186    Status200(models::ModelList),
187    UnknownValue(serde_json::Value),
188}
189
190/// struct for typed errors of method [`create_chat_completion`]
191#[derive(Debug, Clone, Serialize, Deserialize)]
192#[serde(untagged)]
193pub enum CreateChatCompletionError {
194    UnknownValue(serde_json::Value),
195}
196
197/// struct for typed errors of method [`create_embedding`]
198#[derive(Debug, Clone, Serialize, Deserialize)]
199#[serde(untagged)]
200pub enum CreateEmbeddingError {
201    UnknownValue(serde_json::Value),
202}
203
204/// struct for typed errors of method [`create_fim_completion`]
205#[derive(Debug, Clone, Serialize, Deserialize)]
206#[serde(untagged)]
207pub enum CreateFimCompletionError {
208    UnknownValue(serde_json::Value),
209}
210
211/// struct for typed errors of method [`files_api_routes_delete_file`]
212#[derive(Debug, Clone, Serialize, Deserialize)]
213#[serde(untagged)]
214pub enum FilesApiRoutesDeleteFileError {
215    UnknownValue(serde_json::Value),
216}
217
218/// struct for typed errors of method [`files_api_routes_list_files`]
219#[derive(Debug, Clone, Serialize, Deserialize)]
220#[serde(untagged)]
221pub enum FilesApiRoutesListFilesError {
222    UnknownValue(serde_json::Value),
223}
224
225/// struct for typed errors of method [`files_api_routes_retrieve_file`]
226#[derive(Debug, Clone, Serialize, Deserialize)]
227#[serde(untagged)]
228pub enum FilesApiRoutesRetrieveFileError {
229    UnknownValue(serde_json::Value),
230}
231
232/// struct for typed errors of method [`files_api_routes_upload_file`]
233#[derive(Debug, Clone, Serialize, Deserialize)]
234#[serde(untagged)]
235pub enum FilesApiRoutesUploadFileError {
236    UnknownValue(serde_json::Value),
237}
238
239/// struct for typed errors of method [`jobs_api_routes_fine_tuning_cancel_fine_tuning_job`]
240#[derive(Debug, Clone, Serialize, Deserialize)]
241#[serde(untagged)]
242pub enum JobsApiRoutesFineTuningCancelFineTuningJobError {
243    UnknownValue(serde_json::Value),
244}
245
246/// struct for typed errors of method [`jobs_api_routes_fine_tuning_create_fine_tuning_job`]
247#[derive(Debug, Clone, Serialize, Deserialize)]
248#[serde(untagged)]
249pub enum JobsApiRoutesFineTuningCreateFineTuningJobError {
250    UnknownValue(serde_json::Value),
251}
252
253/// struct for typed errors of method [`jobs_api_routes_fine_tuning_get_fine_tuning_job`]
254#[derive(Debug, Clone, Serialize, Deserialize)]
255#[serde(untagged)]
256pub enum JobsApiRoutesFineTuningGetFineTuningJobError {
257    UnknownValue(serde_json::Value),
258}
259
260/// struct for typed errors of method [`jobs_api_routes_fine_tuning_get_fine_tuning_jobs`]
261#[derive(Debug, Clone, Serialize, Deserialize)]
262#[serde(untagged)]
263pub enum JobsApiRoutesFineTuningGetFineTuningJobsError {
264    UnknownValue(serde_json::Value),
265}
266
267/// struct for typed errors of method [`list_models`]
268#[derive(Debug, Clone, Serialize, Deserialize)]
269#[serde(untagged)]
270pub enum ListModelsError {
271    UnknownValue(serde_json::Value),
272}
273
274pub async fn create_chat_completion(
275    configuration: &configuration::Configuration,
276    params: CreateChatCompletionParams,
277) -> Result<ResponseContent<CreateChatCompletionSuccess>, Error<CreateChatCompletionError>> {
278    let configuration = configuration;
279
280    // unbox the parameters
281    let chat_request = params.chat_request;
282
283    let client = &configuration.client;
284
285    let uri_str = format!("{}/chat/completions", configuration.base_path);
286    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
287
288    if let Some(ref user_agent) = configuration.user_agent {
289        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
290    }
291    if let Some(ref token) = configuration.bearer_access_token {
292        req_builder = req_builder.bearer_auth(token.to_owned());
293    };
294    req_builder = req_builder.json(&chat_request);
295
296    let req = req_builder.build()?;
297    let resp = client.execute(req).await?;
298
299    let status = resp.status();
300    let content = resp.text().await?;
301
302    if !status.is_client_error() && !status.is_server_error() {
303        let entity: Option<CreateChatCompletionSuccess> = serde_json::from_str(&content).ok();
304        let result = ResponseContent {
305            status: status,
306            content: content,
307            entity: entity,
308        };
309        Ok(result)
310    } else {
311        let entity: Option<CreateChatCompletionError> = serde_json::from_str(&content).ok();
312        let error = ResponseContent {
313            status: status,
314            content: content,
315            entity: entity,
316        };
317        Err(Error::ResponseError(error))
318    }
319}
320
321pub async fn create_embedding(
322    configuration: &configuration::Configuration,
323    params: CreateEmbeddingParams,
324) -> Result<ResponseContent<CreateEmbeddingSuccess>, Error<CreateEmbeddingError>> {
325    let configuration = configuration;
326
327    // unbox the parameters
328    let embedding_request = params.embedding_request;
329
330    let client = &configuration.client;
331
332    let uri_str = format!("{}/embeddings", configuration.base_path);
333    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
334
335    if let Some(ref user_agent) = configuration.user_agent {
336        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
337    }
338    if let Some(ref token) = configuration.bearer_access_token {
339        req_builder = req_builder.bearer_auth(token.to_owned());
340    };
341    req_builder = req_builder.json(&embedding_request);
342
343    let req = req_builder.build()?;
344    let resp = client.execute(req).await?;
345
346    let status = resp.status();
347    let content = resp.text().await?;
348
349    if !status.is_client_error() && !status.is_server_error() {
350        let entity: Option<CreateEmbeddingSuccess> = serde_json::from_str(&content).ok();
351        let result = ResponseContent {
352            status: status,
353            content: content,
354            entity: entity,
355        };
356        Ok(result)
357    } else {
358        let entity: Option<CreateEmbeddingError> = serde_json::from_str(&content).ok();
359        let error = ResponseContent {
360            status: status,
361            content: content,
362            entity: entity,
363        };
364        Err(Error::ResponseError(error))
365    }
366}
367
368pub async fn create_fim_completion(
369    configuration: &configuration::Configuration,
370    params: CreateFimCompletionParams,
371) -> Result<ResponseContent<CreateFimCompletionSuccess>, Error<CreateFimCompletionError>> {
372    let configuration = configuration;
373
374    // unbox the parameters
375    let fim_completion_request = params.fim_completion_request;
376
377    let client = &configuration.client;
378
379    let uri_str = format!("{}/fim/completions", configuration.base_path);
380    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
381
382    if let Some(ref user_agent) = configuration.user_agent {
383        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
384    }
385    if let Some(ref token) = configuration.bearer_access_token {
386        req_builder = req_builder.bearer_auth(token.to_owned());
387    };
388    req_builder = req_builder.json(&fim_completion_request);
389
390    let req = req_builder.build()?;
391    let resp = client.execute(req).await?;
392
393    let status = resp.status();
394    let content = resp.text().await?;
395
396    if !status.is_client_error() && !status.is_server_error() {
397        let entity: Option<CreateFimCompletionSuccess> = serde_json::from_str(&content).ok();
398        let result = ResponseContent {
399            status: status,
400            content: content,
401            entity: entity,
402        };
403        Ok(result)
404    } else {
405        let entity: Option<CreateFimCompletionError> = serde_json::from_str(&content).ok();
406        let error = ResponseContent {
407            status: status,
408            content: content,
409            entity: entity,
410        };
411        Err(Error::ResponseError(error))
412    }
413}
414
415/// Delete a file.
416pub async fn files_api_routes_delete_file(
417    configuration: &configuration::Configuration,
418    params: FilesApiRoutesDeleteFileParams,
419) -> Result<ResponseContent<FilesApiRoutesDeleteFileSuccess>, Error<FilesApiRoutesDeleteFileError>>
420{
421    let configuration = configuration;
422
423    // unbox the parameters
424    let file_id = params.file_id;
425
426    let client = &configuration.client;
427
428    let uri_str = format!(
429        "{}/files/{file_id}",
430        configuration.base_path,
431        file_id = crate::apis::urlencode(file_id)
432    );
433    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
434
435    if let Some(ref user_agent) = configuration.user_agent {
436        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
437    }
438    if let Some(ref token) = configuration.bearer_access_token {
439        req_builder = req_builder.bearer_auth(token.to_owned());
440    };
441
442    let req = req_builder.build()?;
443    let resp = client.execute(req).await?;
444
445    let status = resp.status();
446    let content = resp.text().await?;
447
448    if !status.is_client_error() && !status.is_server_error() {
449        let entity: Option<FilesApiRoutesDeleteFileSuccess> = serde_json::from_str(&content).ok();
450        let result = ResponseContent {
451            status: status,
452            content: content,
453            entity: entity,
454        };
455        Ok(result)
456    } else {
457        let entity: Option<FilesApiRoutesDeleteFileError> = serde_json::from_str(&content).ok();
458        let error = ResponseContent {
459            status: status,
460            content: content,
461            entity: entity,
462        };
463        Err(Error::ResponseError(error))
464    }
465}
466
467/// Returns a list of files that belong to the user's organization.
468pub async fn files_api_routes_list_files(
469    configuration: &configuration::Configuration,
470) -> Result<ResponseContent<FilesApiRoutesListFilesSuccess>, Error<FilesApiRoutesListFilesError>> {
471    let configuration = configuration;
472
473    // unbox the parameters
474
475    let client = &configuration.client;
476
477    let uri_str = format!("{}/files", configuration.base_path);
478    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
479
480    if let Some(ref user_agent) = configuration.user_agent {
481        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
482    }
483    if let Some(ref token) = configuration.bearer_access_token {
484        req_builder = req_builder.bearer_auth(token.to_owned());
485    };
486
487    let req = req_builder.build()?;
488    let resp = client.execute(req).await?;
489
490    let status = resp.status();
491    let content = resp.text().await?;
492
493    if !status.is_client_error() && !status.is_server_error() {
494        let entity: Option<FilesApiRoutesListFilesSuccess> = serde_json::from_str(&content).ok();
495        let result = ResponseContent {
496            status: status,
497            content: content,
498            entity: entity,
499        };
500        Ok(result)
501    } else {
502        let entity: Option<FilesApiRoutesListFilesError> = serde_json::from_str(&content).ok();
503        let error = ResponseContent {
504            status: status,
505            content: content,
506            entity: entity,
507        };
508        Err(Error::ResponseError(error))
509    }
510}
511
512/// Returns information about a specific file.
513pub async fn files_api_routes_retrieve_file(
514    configuration: &configuration::Configuration,
515    params: FilesApiRoutesRetrieveFileParams,
516) -> Result<
517    ResponseContent<FilesApiRoutesRetrieveFileSuccess>,
518    Error<FilesApiRoutesRetrieveFileError>,
519> {
520    let configuration = configuration;
521
522    // unbox the parameters
523    let file_id = params.file_id;
524
525    let client = &configuration.client;
526
527    let uri_str = format!(
528        "{}/files/{file_id}",
529        configuration.base_path,
530        file_id = crate::apis::urlencode(file_id)
531    );
532    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
533
534    if let Some(ref user_agent) = configuration.user_agent {
535        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
536    }
537    if let Some(ref token) = configuration.bearer_access_token {
538        req_builder = req_builder.bearer_auth(token.to_owned());
539    };
540
541    let req = req_builder.build()?;
542    let resp = client.execute(req).await?;
543
544    let status = resp.status();
545    let content = resp.text().await?;
546
547    if !status.is_client_error() && !status.is_server_error() {
548        let entity: Option<FilesApiRoutesRetrieveFileSuccess> = serde_json::from_str(&content).ok();
549        let result = ResponseContent {
550            status: status,
551            content: content,
552            entity: entity,
553        };
554        Ok(result)
555    } else {
556        let entity: Option<FilesApiRoutesRetrieveFileError> = serde_json::from_str(&content).ok();
557        let error = ResponseContent {
558            status: status,
559            content: content,
560            entity: entity,
561        };
562        Err(Error::ResponseError(error))
563    }
564}
565
566/// Upload a file that can be used across various endpoints.  The size of individual files can be a maximum of 512 MB. The Fine-tuning API only supports .jsonl files.  Please contact us if you need to increase these storage limits.
567pub async fn files_api_routes_upload_file(
568    configuration: &configuration::Configuration,
569    params: FilesApiRoutesUploadFileParams,
570) -> Result<ResponseContent<FilesApiRoutesUploadFileSuccess>, Error<FilesApiRoutesUploadFileError>>
571{
572    let configuration = configuration;
573
574    // unbox the parameters
575    let purpose = params.purpose;
576    let file = params.file;
577
578    let client = &configuration.client;
579
580    let uri_str = format!("{}/files", configuration.base_path);
581    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
582
583    if let Some(ref user_agent) = configuration.user_agent {
584        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
585    }
586    if let Some(ref token) = configuration.bearer_access_token {
587        req_builder = req_builder.bearer_auth(token.to_owned());
588    };
589    let mut form = reqwest::multipart::Form::new();
590    match purpose {
591        Some(param_value) => {
592            form = form.text("purpose", param_value.to_string());
593        }
594        None => {
595            form = form.text("purpose", "");
596        }
597    }
598    // TODO: support file upload for 'file' parameter
599    req_builder = req_builder.multipart(form);
600
601    let req = req_builder.build()?;
602    let resp = client.execute(req).await?;
603
604    let status = resp.status();
605    let content = resp.text().await?;
606
607    if !status.is_client_error() && !status.is_server_error() {
608        let entity: Option<FilesApiRoutesUploadFileSuccess> = serde_json::from_str(&content).ok();
609        let result = ResponseContent {
610            status: status,
611            content: content,
612            entity: entity,
613        };
614        Ok(result)
615    } else {
616        let entity: Option<FilesApiRoutesUploadFileError> = serde_json::from_str(&content).ok();
617        let error = ResponseContent {
618            status: status,
619            content: content,
620            entity: entity,
621        };
622        Err(Error::ResponseError(error))
623    }
624}
625
626/// Request the cancellation of a fine tuning job.
627pub async fn jobs_api_routes_fine_tuning_cancel_fine_tuning_job(
628    configuration: &configuration::Configuration,
629    params: JobsApiRoutesFineTuningCancelFineTuningJobParams,
630) -> Result<
631    ResponseContent<JobsApiRoutesFineTuningCancelFineTuningJobSuccess>,
632    Error<JobsApiRoutesFineTuningCancelFineTuningJobError>,
633> {
634    let configuration = configuration;
635
636    // unbox the parameters
637    let job_id = params.job_id;
638
639    let client = &configuration.client;
640
641    let uri_str = format!(
642        "{}/fine_tuning/jobs/{job_id}/cancel",
643        configuration.base_path,
644        job_id = crate::apis::urlencode(job_id)
645    );
646    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
647
648    if let Some(ref user_agent) = configuration.user_agent {
649        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
650    }
651    if let Some(ref token) = configuration.bearer_access_token {
652        req_builder = req_builder.bearer_auth(token.to_owned());
653    };
654
655    let req = req_builder.build()?;
656    let resp = client.execute(req).await?;
657
658    let status = resp.status();
659    let content = resp.text().await?;
660
661    if !status.is_client_error() && !status.is_server_error() {
662        let entity: Option<JobsApiRoutesFineTuningCancelFineTuningJobSuccess> =
663            serde_json::from_str(&content).ok();
664        let result = ResponseContent {
665            status: status,
666            content: content,
667            entity: entity,
668        };
669        Ok(result)
670    } else {
671        let entity: Option<JobsApiRoutesFineTuningCancelFineTuningJobError> =
672            serde_json::from_str(&content).ok();
673        let error = ResponseContent {
674            status: status,
675            content: content,
676            entity: entity,
677        };
678        Err(Error::ResponseError(error))
679    }
680}
681
682/// Create a new fine tuning job, it will be queued for processing.
683pub async fn jobs_api_routes_fine_tuning_create_fine_tuning_job(
684    configuration: &configuration::Configuration,
685    params: JobsApiRoutesFineTuningCreateFineTuningJobParams,
686) -> Result<
687    ResponseContent<JobsApiRoutesFineTuningCreateFineTuningJobSuccess>,
688    Error<JobsApiRoutesFineTuningCreateFineTuningJobError>,
689> {
690    let configuration = configuration;
691
692    // unbox the parameters
693    let job_in = params.job_in;
694    let dry_run = params.dry_run;
695
696    let client = &configuration.client;
697
698    let uri_str = format!("{}/fine_tuning/jobs", configuration.base_path);
699    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
700
701    if let Some(ref str) = dry_run {
702        req_builder = req_builder.query(&[("dry_run", &str.to_string())]);
703    }
704    if let Some(ref user_agent) = configuration.user_agent {
705        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
706    }
707    if let Some(ref token) = configuration.bearer_access_token {
708        req_builder = req_builder.bearer_auth(token.to_owned());
709    };
710    req_builder = req_builder.json(&job_in);
711
712    let req = req_builder.build()?;
713    let resp = client.execute(req).await?;
714
715    let status = resp.status();
716    let content = resp.text().await?;
717
718    if !status.is_client_error() && !status.is_server_error() {
719        let entity: Option<JobsApiRoutesFineTuningCreateFineTuningJobSuccess> =
720            serde_json::from_str(&content).ok();
721        let result = ResponseContent {
722            status: status,
723            content: content,
724            entity: entity,
725        };
726        Ok(result)
727    } else {
728        let entity: Option<JobsApiRoutesFineTuningCreateFineTuningJobError> =
729            serde_json::from_str(&content).ok();
730        let error = ResponseContent {
731            status: status,
732            content: content,
733            entity: entity,
734        };
735        Err(Error::ResponseError(error))
736    }
737}
738
739/// Get a fine tuned job details by its UUID.
740pub async fn jobs_api_routes_fine_tuning_get_fine_tuning_job(
741    configuration: &configuration::Configuration,
742    params: JobsApiRoutesFineTuningGetFineTuningJobParams,
743) -> Result<
744    ResponseContent<JobsApiRoutesFineTuningGetFineTuningJobSuccess>,
745    Error<JobsApiRoutesFineTuningGetFineTuningJobError>,
746> {
747    let configuration = configuration;
748
749    // unbox the parameters
750    let job_id = params.job_id;
751
752    let client = &configuration.client;
753
754    let uri_str = format!(
755        "{}/fine_tuning/jobs/{job_id}",
756        configuration.base_path,
757        job_id = crate::apis::urlencode(job_id)
758    );
759    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
760
761    if let Some(ref user_agent) = configuration.user_agent {
762        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
763    }
764    if let Some(ref token) = configuration.bearer_access_token {
765        req_builder = req_builder.bearer_auth(token.to_owned());
766    };
767
768    let req = req_builder.build()?;
769    let resp = client.execute(req).await?;
770
771    let status = resp.status();
772    let content = resp.text().await?;
773
774    if !status.is_client_error() && !status.is_server_error() {
775        let entity: Option<JobsApiRoutesFineTuningGetFineTuningJobSuccess> =
776            serde_json::from_str(&content).ok();
777        let result = ResponseContent {
778            status: status,
779            content: content,
780            entity: entity,
781        };
782        Ok(result)
783    } else {
784        let entity: Option<JobsApiRoutesFineTuningGetFineTuningJobError> =
785            serde_json::from_str(&content).ok();
786        let error = ResponseContent {
787            status: status,
788            content: content,
789            entity: entity,
790        };
791        Err(Error::ResponseError(error))
792    }
793}
794
795/// Get a list of fine tuning jobs for your organization and user.
796pub async fn jobs_api_routes_fine_tuning_get_fine_tuning_jobs(
797    configuration: &configuration::Configuration,
798    params: JobsApiRoutesFineTuningGetFineTuningJobsParams,
799) -> Result<
800    ResponseContent<JobsApiRoutesFineTuningGetFineTuningJobsSuccess>,
801    Error<JobsApiRoutesFineTuningGetFineTuningJobsError>,
802> {
803    let configuration = configuration;
804
805    // unbox the parameters
806    let page = params.page;
807    let page_size = params.page_size;
808    let model = params.model;
809    let status = params.status;
810    let created_after = params.created_after;
811    let created_by_me = params.created_by_me;
812    let wandb_project = params.wandb_project;
813    let wandb_name = params.wandb_name;
814    let suffix = params.suffix;
815
816    let client = &configuration.client;
817
818    let uri_str = format!("{}/fine_tuning/jobs", configuration.base_path);
819    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
820
821    if let Some(ref str) = page {
822        req_builder = req_builder.query(&[("page", &str.to_string())]);
823    }
824    if let Some(ref str) = page_size {
825        req_builder = req_builder.query(&[("page_size", &str.to_string())]);
826    }
827    if let Some(ref str) = model {
828        req_builder = req_builder.query(&[("model", &str.to_string())]);
829    }
830    if let Some(ref str) = status {
831        req_builder = req_builder.query(&[("status", &str.to_string())]);
832    }
833    if let Some(ref str) = created_after {
834        req_builder = req_builder.query(&[("created_after", &str.to_string())]);
835    }
836    if let Some(ref str) = created_by_me {
837        req_builder = req_builder.query(&[("created_by_me", &str.to_string())]);
838    }
839    if let Some(ref str) = wandb_project {
840        req_builder = req_builder.query(&[("wandb_project", &str.to_string())]);
841    }
842    if let Some(ref str) = wandb_name {
843        req_builder = req_builder.query(&[("wandb_name", &str.to_string())]);
844    }
845    if let Some(ref str) = suffix {
846        req_builder = req_builder.query(&[("suffix", &str.to_string())]);
847    }
848    if let Some(ref user_agent) = configuration.user_agent {
849        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
850    }
851    if let Some(ref token) = configuration.bearer_access_token {
852        req_builder = req_builder.bearer_auth(token.to_owned());
853    };
854
855    let req = req_builder.build()?;
856    let resp = client.execute(req).await?;
857
858    let status = resp.status();
859    let content = resp.text().await?;
860
861    if !status.is_client_error() && !status.is_server_error() {
862        let entity: Option<JobsApiRoutesFineTuningGetFineTuningJobsSuccess> =
863            serde_json::from_str(&content).ok();
864        let result = ResponseContent {
865            status: status,
866            content: content,
867            entity: entity,
868        };
869        Ok(result)
870    } else {
871        let entity: Option<JobsApiRoutesFineTuningGetFineTuningJobsError> =
872            serde_json::from_str(&content).ok();
873        let error = ResponseContent {
874            status: status,
875            content: content,
876            entity: entity,
877        };
878        Err(Error::ResponseError(error))
879    }
880}
881
882pub async fn list_models(
883    configuration: &configuration::Configuration,
884) -> Result<ResponseContent<ListModelsSuccess>, Error<ListModelsError>> {
885    let configuration = configuration;
886
887    // unbox the parameters
888
889    let client = &configuration.client;
890
891    let uri_str = format!("{}/models", configuration.base_path);
892    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
893
894    if let Some(ref user_agent) = configuration.user_agent {
895        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
896    }
897    if let Some(ref token) = configuration.bearer_access_token {
898        req_builder = req_builder.bearer_auth(token.to_owned());
899    };
900
901    let req = req_builder.build()?;
902    let resp = client.execute(req).await?;
903
904    let status = resp.status();
905    let content = resp.text().await?;
906
907    if !status.is_client_error() && !status.is_server_error() {
908        let entity: Option<ListModelsSuccess> = serde_json::from_str(&content).ok();
909        let result = ResponseContent {
910            status: status,
911            content: content,
912            entity: entity,
913        };
914        Ok(result)
915    } else {
916        let entity: Option<ListModelsError> = serde_json::from_str(&content).ok();
917        let error = ResponseContent {
918            status: status,
919            content: content,
920            entity: entity,
921        };
922        Err(Error::ResponseError(error))
923    }
924}
mistral_rouille/apis/default_api.rs

mistral_rouille/apis/
default_api.rs
