mii/openai-api-rs
1
0
Fork 0
mirror of https://github.com/mii443/openai-api-rs.git synced 2025-08-23 15:48:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: sync with minreq

Browse Source
This commit is contained in:
Anush008
2023-08-25 17:29:23 +05:30
parent eee3ae6153
commit ffe2bd49be
1 changed files with 128 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

269
src/v1/api.rs
View File

@ -24,7 +24,7 @@ use crate::v1::image::{
}; };
use crate::v1::moderation::{CreateModerationRequest, CreateModerationResponse}; use crate::v1::moderation::{CreateModerationRequest, CreateModerationResponse};
use reqwest::Response; use minreq::Response;
const API_URL_V1: &str = "https://api.openai.com/v1"; const API_URL_V1: &str = "https://api.openai.com/v1";
@ -57,31 +57,7 @@ impl Client {
} }
} }
pub async fn client_builder(&self) -> Result<reqwest::Client, reqwest::Error> { pub fn post<T: serde::ser::Serialize>(
let mut headers = reqwest::header::HeaderMap::new();
headers.insert(
reqwest::header::CONTENT_TYPE,
reqwest::header::HeaderValue::from_static("application/json"),
);
headers.insert(
reqwest::header::AUTHORIZATION,
reqwest::header::HeaderValue::from_str(&("Bearer ".to_owned() + &self.api_key))
.unwrap(),
);
match &self.organization {
Some(organization) => headers.insert(
reqwest::header::HeaderName::from_static("openai-organization"),
reqwest::header::HeaderValue::from_str(organization).unwrap(),
),
None => None,
};
let client = reqwest::Client::builder()
.default_headers(headers)
.build()?;
Ok(client)
}
pub async fn post<T: serde::ser::Serialize>(
&self, &self,
path: &str, path: &str,
params: &T, params: &T,
@ -91,311 +67,322 @@ impl Client {
api_endpoint = self.api_endpoint, api_endpoint = self.api_endpoint,
path = path path = path
); );
let client = match self.client_builder().await {
Ok(c) => c, let mut request = minreq::post(url)
Err(e) => return Err(self.new_error(e)), .with_header("Content-Type", "application/json")
}; .with_header("Authorization", format!("Bearer {}", self.api_key));
let res = client.post(&url).json(&params).send().await;
if let Some(organization) = &self.organization {
request = request.with_header("openai-organization", organization);
}
let res = request.with_json(params).unwrap().send();
match res { match res {
Ok(res) => match res.status().is_success() { Ok(res) => {
true => Ok(res), if (200..=299).contains(&res.status_code) {
false => Err(APIError { Ok(res)
message: format!("{}: {}", res.status(), res.text().await.unwrap()), } else {
}), Err(APIError {
}, message: format!("{}: {}", res.status_code, res.as_str().unwrap()),
})
}
}
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn get(&self, path: &str) -> Result<Response, APIError> { pub fn get(&self, path: &str) -> Result<Response, APIError> {
let url = format!( let url = format!(
"{api_endpoint}{path}", "{api_endpoint}{path}",
api_endpoint = self.api_endpoint, api_endpoint = self.api_endpoint,
path = path path = path
); );
let client = match self.client_builder().await {
Ok(c) => c, let mut request = minreq::get(url)
Err(e) => return Err(self.new_error(e)), .with_header("Content-Type", "application/json")
}; .with_header("Authorization", format!("Bearer {}", self.api_key));
let res = client.get(&url).send().await;
if let Some(organization) = &self.organization {
request = request.with_header("openai-organization", organization);
}
let res = request.send();
match res { match res {
Ok(res) => match res.status().is_success() { Ok(res) => {
true => Ok(res), if (200..=299).contains(&res.status_code) {
false => Err(APIError { Ok(res)
message: format!("{}: {}", res.status(), res.text().await.unwrap()), } else {
}), Err(APIError {
}, message: format!("{}: {}", res.status_code, res.as_str().unwrap()),
})
}
}
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn delete(&self, path: &str) -> Result<Response, APIError> { pub fn delete(&self, path: &str) -> Result<Response, APIError> {
let url = format!( let url = format!(
"{api_endpoint}{path}", "{api_endpoint}{path}",
api_endpoint = self.api_endpoint, api_endpoint = self.api_endpoint,
path = path path = path
); );
let client = match self.client_builder().await {
Ok(c) => c, let mut request = minreq::delete(url)
Err(e) => return Err(self.new_error(e)), .with_header("Content-Type", "application/json")
}; .with_header("Authorization", format!("Bearer {}", self.api_key));
let res = client.delete(&url).send().await;
if let Some(organization) = &self.organization {
request = request.with_header("openai-organization", organization);
}
let res = request.send();
match res { match res {
Ok(res) => match res.status().is_success() { Ok(res) => {
true => Ok(res), if (200..=299).contains(&res.status_code) {
false => Err(APIError { Ok(res)
message: format!("{}: {}", res.status(), res.text().await.unwrap()), } else {
}), Err(APIError {
}, message: format!("{}: {}", res.status_code, res.as_str().unwrap()),
})
}
}
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn completion(&self, req: CompletionRequest) -> Result<CompletionResponse, APIError> { pub fn completion(&self, req: CompletionRequest) -> Result<CompletionResponse, APIError> {
let res = self.post("/completions", &req).await?; let res = self.post("/completions", &req)?;
let r = res.json::<CompletionResponse>().await; let r = res.json::<CompletionResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn edit(&self, req: EditRequest) -> Result<EditResponse, APIError> { pub fn edit(&self, req: EditRequest) -> Result<EditResponse, APIError> {
let res = self.post("/edits", &req).await?; let res = self.post("/edits", &req)?;
let r = res.json::<EditResponse>().await; let r = res.json::<EditResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn image_generation( pub fn image_generation(
&self, &self,
req: ImageGenerationRequest, req: ImageGenerationRequest,
) -> Result<ImageGenerationResponse, APIError> { ) -> Result<ImageGenerationResponse, APIError> {
let res = self.post("/images/generations", &req).await?; let res = self.post("/images/generations", &req)?;
let r = res.json::<ImageGenerationResponse>().await; let r = res.json::<ImageGenerationResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn image_edit(&self, req: ImageEditRequest) -> Result<ImageEditResponse, APIError> { pub fn image_edit(&self, req: ImageEditRequest) -> Result<ImageEditResponse, APIError> {
let res = self.post("/images/edits", &req).await?; let res = self.post("/images/edits", &req)?;
let r = res.json::<ImageEditResponse>().await; let r = res.json::<ImageEditResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn image_variation( pub fn image_variation(
&self, &self,
req: ImageVariationRequest, req: ImageVariationRequest,
) -> Result<ImageVariationResponse, APIError> { ) -> Result<ImageVariationResponse, APIError> {
let res = self.post("/images/variations", &req).await?; let res = self.post("/images/variations", &req)?;
let r = res.json::<ImageVariationResponse>().await; let r = res.json::<ImageVariationResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn embedding(&self, req: EmbeddingRequest) -> Result<EmbeddingResponse, APIError> { pub fn embedding(&self, req: EmbeddingRequest) -> Result<EmbeddingResponse, APIError> {
let res = self.post("/embeddings", &req).await?; let res = self.post("/embeddings", &req)?;
let r = res.json::<EmbeddingResponse>().await; let r = res.json::<EmbeddingResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn file_list(&self) -> Result<FileListResponse, APIError> { pub fn file_list(&self) -> Result<FileListResponse, APIError> {
let res = self.get("/files").await?; let res = self.get("/files")?;
let r = res.json::<FileListResponse>().await; let r = res.json::<FileListResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn file_upload( pub fn file_upload(&self, req: FileUploadRequest) -> Result<FileUploadResponse, APIError> {
&self, let res = self.post("/files", &req)?;
req: FileUploadRequest, let r = res.json::<FileUploadResponse>();
) -> Result<FileUploadResponse, APIError> {
let res = self.post("/files", &req).await?;
let r = res.json::<FileUploadResponse>().await;
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn file_delete( pub fn file_delete(&self, req: FileDeleteRequest) -> Result<FileDeleteResponse, APIError> {
&self, let res = self.delete(&format!("{}/{}", "/files", req.file_id))?;
req: FileDeleteRequest, let r = res.json::<FileDeleteResponse>();
) -> Result<FileDeleteResponse, APIError> {
let res = self
.delete(&format!("{}/{}", "/files", req.file_id))
.await?;
let r = res.json::<FileDeleteResponse>().await;
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn file_retrieve( pub fn file_retrieve(
&self, &self,
req: FileRetrieveRequest, req: FileRetrieveRequest,
) -> Result<FileRetrieveResponse, APIError> { ) -> Result<FileRetrieveResponse, APIError> {
let res = self.get(&format!("{}/{}", "/files", req.file_id)).await?; let res = self.get(&format!("{}/{}", "/files", req.file_id))?;
let r = res.json::<FileRetrieveResponse>().await; let r = res.json::<FileRetrieveResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn file_retrieve_content( pub fn file_retrieve_content(
&self, &self,
req: FileRetrieveContentRequest, req: FileRetrieveContentRequest,
) -> Result<FileRetrieveContentResponse, APIError> { ) -> Result<FileRetrieveContentResponse, APIError> {
let res = self let res = self.get(&format!("{}/{}/content", "/files", req.file_id))?;
.get(&format!("{}/{}/content", "/files", req.file_id)) let r = res.json::<FileRetrieveContentResponse>();
.await?;
let r = res.json::<FileRetrieveContentResponse>().await;
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn chat_completion( pub fn chat_completion(
&self, &self,
req: ChatCompletionRequest, req: ChatCompletionRequest,
) -> Result<ChatCompletionResponse, APIError> { ) -> Result<ChatCompletionResponse, APIError> {
let res = self.post("/chat/completions", &req).await?; let res = self.post("/chat/completions", &req)?;
let r = res.json::<ChatCompletionResponse>().await; let r = res.json::<ChatCompletionResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn audio_transcription( pub fn audio_transcription(
&self, &self,
req: AudioTranscriptionRequest, req: AudioTranscriptionRequest,
) -> Result<AudioTranscriptionResponse, APIError> { ) -> Result<AudioTranscriptionResponse, APIError> {
let res = self.post("/audio/transcriptions", &req).await?; let res = self.post("/audio/transcriptions", &req)?;
let r = res.json::<AudioTranscriptionResponse>().await; let r = res.json::<AudioTranscriptionResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn audio_translation( pub fn audio_translation(
&self, &self,
req: AudioTranslationRequest, req: AudioTranslationRequest,
) -> Result<AudioTranslationResponse, APIError> { ) -> Result<AudioTranslationResponse, APIError> {
let res = self.post("/audio/translations", &req).await?; let res = self.post("/audio/translations", &req)?;
let r = res.json::<AudioTranslationResponse>().await; let r = res.json::<AudioTranslationResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn create_fine_tune( pub fn create_fine_tune(
&self, &self,
req: CreateFineTuneRequest, req: CreateFineTuneRequest,
) -> Result<CreateFineTuneResponse, APIError> { ) -> Result<CreateFineTuneResponse, APIError> {
let res = self.post("/fine-tunes", &req).await?; let res = self.post("/fine-tunes", &req)?;
let r = res.json::<CreateFineTuneResponse>().await; let r = res.json::<CreateFineTuneResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn list_fine_tune(&self) -> Result<ListFineTuneResponse, APIError> { pub fn list_fine_tune(&self) -> Result<ListFineTuneResponse, APIError> {
let res = self.get("/fine-tunes").await?; let res = self.get("/fine-tunes")?;
let r = res.json::<ListFineTuneResponse>().await; let r = res.json::<ListFineTuneResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn retrieve_fine_tune( pub fn retrieve_fine_tune(
&self, &self,
req: RetrieveFineTuneRequest, req: RetrieveFineTuneRequest,
) -> Result<RetrieveFineTuneResponse, APIError> { ) -> Result<RetrieveFineTuneResponse, APIError> {
let res = self let res = self.get(&format!("/fine_tunes/{}", req.fine_tune_id))?;
.get(&format!("/fine_tunes/{}", req.fine_tune_id)) let r = res.json::<RetrieveFineTuneResponse>();
.await?;
let r = res.json::<RetrieveFineTuneResponse>().await;
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn cancel_fine_tune( pub fn cancel_fine_tune(
&self, &self,
req: CancelFineTuneRequest, req: CancelFineTuneRequest,
) -> Result<CancelFineTuneResponse, APIError> { ) -> Result<CancelFineTuneResponse, APIError> {
let res = self let res = self.post(&format!("/fine_tunes/{}/cancel", req.fine_tune_id), &req)?;
.post(&format!("/fine_tunes/{}/cancel", req.fine_tune_id), &req) let r = res.json::<CancelFineTuneResponse>();
.await?;
let r = res.json::<CancelFineTuneResponse>().await;
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn list_fine_tune_events( pub fn list_fine_tune_events(
&self, &self,
req: ListFineTuneEventsRequest, req: ListFineTuneEventsRequest,
) -> Result<ListFineTuneEventsResponse, APIError> { ) -> Result<ListFineTuneEventsResponse, APIError> {
let res = self let res = self.get(&format!("/fine-tunes/{}/events", req.fine_tune_id))?;
.get(&format!("/fine-tunes/{}/events", req.fine_tune_id)) let r = res.json::<ListFineTuneEventsResponse>();
.await?;
let r = res.json::<ListFineTuneEventsResponse>().await;
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn delete_fine_tune( pub fn delete_fine_tune(
&self, &self,
req: DeleteFineTuneModelRequest, req: DeleteFineTuneModelRequest,
) -> Result<DeleteFineTuneModelResponse, APIError> { ) -> Result<DeleteFineTuneModelResponse, APIError> {
let res = self.delete(&format!("/models/{}", req.model_id)).await?; let res = self.delete(&format!("/models/{}", req.model_id))?;
let r = res.json::<DeleteFineTuneModelResponse>().await; let r = res.json::<DeleteFineTuneModelResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
pub async fn create_moderation( pub fn create_moderation(
&self, &self,
req: CreateModerationRequest, req: CreateModerationRequest,
) -> Result<CreateModerationResponse, APIError> { ) -> Result<CreateModerationResponse, APIError> {
let res = self.post("/moderations", &req).await?; let res = self.post("/moderations", &req)?;
let r = res.json::<CreateModerationResponse>().await; let r = res.json::<CreateModerationResponse>();
match r { match r {
Ok(r) => Ok(r), Ok(r) => Ok(r),
Err(e) => Err(self.new_error(e)), Err(e) => Err(self.new_error(e)),
} }
} }
fn new_error(&self, err: reqwest::Error) -> APIError { fn new_error(&self, err: minreq::Error) -> APIError {
APIError { APIError {
message: err.to_string(), message: err.to_string(),
} }