Skip to content

Commit 95bef4a

Browse files
author
Dongri Jin
committed
Change error type
1 parent 6a68775 commit 95bef4a

File tree

3 files changed

+93
-125
lines changed

3 files changed

+93
-125
lines changed

‎Cargo.toml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
[package]
22
name = "openai-api-rs"
3-
version = "0.1.2"
3+
version = "0.1.3"
44
edition = "2021"
55
authors = ["Dongri Jin <[email protected]>"]
66
license = "MIT"

‎README.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
Cargo.toml
55
```toml
66
[dependencies]
7-
openai-api-rs = "0.1.2"
7+
openai-api-rs = "0.1.3"
88
```
99

1010
## Example:

‎src/v1/api.rs‎

Lines changed: 91 additions & 123 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ use crate::v1::image::{
1212
ImageVariationRequest, ImageVariationResponse,
1313
};
1414
use reqwest::Response;
15+
use std::io::Error;
1516

1617
const APU_URL_V1: &str = "https://api.openai.com/v1";
1718

@@ -28,7 +29,7 @@ impl Client {
2829
&self,
2930
path: &str,
3031
params: &T,
31-
) -> Result<Response, Box<dyn std::error::Error>> {
32+
) -> Result<Response, Error> {
3233
let client = reqwest::Client::new();
3334
let url = format!("{APU_URL_V1}{path}");
3435
let res = client
@@ -44,16 +45,16 @@ impl Client {
4445
match res {
4546
Ok(res) => match res.status().is_success() {
4647
true => Ok(res),
47-
false => Err(Box::new(std::io::Error::new(
48+
false => Err(Error::new(
4849
std::io::ErrorKind::Other,
4950
format!("{}: {}", res.status(), res.text().await.unwrap()),
50-
))),
51+
)),
5152
},
52-
Err(e) => Err(Box::new(e)),
53+
Err(e) => Err(self.new_error(e)),
5354
}
5455
}
5556

56-
pub async fn get(&self, path: &str) -> Result<Response, Box<dyn std::error::Error>> {
57+
pub async fn get(&self, path: &str) -> Result<Response, Error> {
5758
let client = reqwest::Client::new();
5859
let url = format!("{APU_URL_V1}{path}");
5960
let res = client
@@ -68,16 +69,16 @@ impl Client {
6869
match res {
6970
Ok(res) => match res.status().is_success() {
7071
true => Ok(res),
71-
false => Err(Box::new(std::io::Error::new(
72+
false => Err(Error::new(
7273
std::io::ErrorKind::Other,
7374
format!("{}: {}", res.status(), res.text().await.unwrap()),
74-
))),
75+
)),
7576
},
76-
Err(e) => Err(Box::new(e)),
77+
Err(e) => Err(self.new_error(e)),
7778
}
7879
}
7980

80-
pub async fn delete(&self, path: &str) -> Result<Response, Box<dyn std::error::Error>> {
81+
pub async fn delete(&self, path: &str) -> Result<Response, Error> {
8182
let client = reqwest::Client::new();
8283
let url = format!("{APU_URL_V1}{path}");
8384
let res = client
@@ -92,176 +93,143 @@ impl Client {
9293
match res {
9394
Ok(res) => match res.status().is_success() {
9495
true => Ok(res),
95-
false => Err(Box::new(std::io::Error::new(
96+
false => Err(Error::new(
9697
std::io::ErrorKind::Other,
9798
format!("{}: {}", res.status(), res.text().await.unwrap()),
98-
))),
99+
)),
99100
},
100-
Err(e) => Err(Box::new(e)),
101+
Err(e) => Err(self.new_error(e)),
101102
}
102103
}
103104

104-
pub async fn completion(
105-
&self,
106-
req: CompletionRequest,
107-
) -> Result<CompletionResponse, Box<dyn std::error::Error>> {
108-
let res = self.post("/completions", &req).await;
109-
match res {
110-
Ok(res) => {
111-
let r = res.json::<CompletionResponse>().await?;
112-
Ok(r)
113-
}
114-
Err(e) => Err(e),
105+
pub async fn completion(&self, req: CompletionRequest) -> Result<CompletionResponse, Error> {
106+
let res = self.post("/completions", &req).await?;
107+
let r = res.json::<CompletionResponse>().await;
108+
match r {
109+
Ok(r) => Ok(r),
110+
Err(e) => Err(self.new_error(e)),
115111
}
116112
}
117113

118-
pub async fn edit(&self, req: EditRequest) -> Result<EditResponse, Box<dyn std::error::Error>> {
119-
let res = self.post("/edits", &req).await;
120-
match res {
121-
Ok(res) => {
122-
let r = res.json::<EditResponse>().await?;
123-
Ok(r)
124-
}
125-
Err(e) => Err(e),
114+
pub async fn edit(&self, req: EditRequest) -> Result<EditResponse, Error> {
115+
let res = self.post("/edits", &req).await?;
116+
let r = res.json::<EditResponse>().await;
117+
match r {
118+
Ok(r) => Ok(r),
119+
Err(e) => Err(self.new_error(e)),
126120
}
127121
}
128122

129123
pub async fn image_generation(
130124
&self,
131125
req: ImageGenerationRequest,
132-
) -> Result<ImageGenerationResponse, Box<dyn std::error::Error>> {
133-
let res = self.post("/images/generations", &req).await;
134-
match res {
135-
Ok(res) => {
136-
let r = res.json::<ImageGenerationResponse>().await?;
137-
Ok(r)
138-
}
139-
Err(e) => Err(e),
126+
) -> Result<ImageGenerationResponse, Error> {
127+
let res = self.post("/images/generations", &req).await?;
128+
let r = res.json::<ImageGenerationResponse>().await;
129+
match r {
130+
Ok(r) => Ok(r),
131+
Err(e) => Err(self.new_error(e)),
140132
}
141133
}
142134

143-
pub async fn image_edit(
144-
&self,
145-
req: ImageEditRequest,
146-
) -> Result<ImageEditResponse, Box<dyn std::error::Error>> {
147-
let res = self.post("/images/edits", &req).await;
148-
match res {
149-
Ok(res) => {
150-
let r = res.json::<ImageEditResponse>().await?;
151-
Ok(r)
152-
}
153-
Err(e) => Err(e),
135+
pub async fn image_edit(&self, req: ImageEditRequest) -> Result<ImageEditResponse, Error> {
136+
let res = self.post("/images/edits", &req).await?;
137+
let r = res.json::<ImageEditResponse>().await;
138+
match r {
139+
Ok(r) => Ok(r),
140+
Err(e) => Err(self.new_error(e)),
154141
}
155142
}
156143

157144
pub async fn image_variation(
158145
&self,
159146
req: ImageVariationRequest,
160-
) -> Result<ImageVariationResponse, Box<dyn std::error::Error>> {
161-
let res = self.post("/images/variations", &req).await;
162-
match res {
163-
Ok(res) => {
164-
let r = res.json::<ImageVariationResponse>().await?;
165-
Ok(r)
166-
}
167-
Err(e) => Err(e),
147+
) -> Result<ImageVariationResponse, Error> {
148+
let res = self.post("/images/variations", &req).await?;
149+
let r = res.json::<ImageVariationResponse>().await;
150+
match r {
151+
Ok(r) => Ok(r),
152+
Err(e) => Err(self.new_error(e)),
168153
}
169154
}
170155

171-
pub async fn embedding(
172-
&self,
173-
req: EmbeddingRequest,
174-
) -> Result<EmbeddingResponse, Box<dyn std::error::Error>> {
175-
let res = self.post("/embeddings", &req).await;
176-
match res {
177-
Ok(res) => {
178-
let r = res.json::<EmbeddingResponse>().await?;
179-
Ok(r)
180-
}
181-
Err(e) => Err(e),
156+
pub async fn embedding(&self, req: EmbeddingRequest) -> Result<EmbeddingResponse, Error> {
157+
let res = self.post("/embeddings", &req).await?;
158+
let r = res.json::<EmbeddingResponse>().await;
159+
match r {
160+
Ok(r) => Ok(r),
161+
Err(e) => Err(self.new_error(e)),
182162
}
183163
}
184164

185-
pub async fn file_list(&self) -> Result<FileListResponse, Box<dyn std::error::Error>> {
186-
let res = self.get("/files").await;
187-
match res {
188-
Ok(res) => {
189-
let r = res.json::<FileListResponse>().await?;
190-
Ok(r)
191-
}
192-
Err(e) => Err(e),
165+
pub async fn file_list(&self) -> Result<FileListResponse, Error> {
166+
let res = self.get("/files").await?;
167+
let r = res.json::<FileListResponse>().await;
168+
match r {
169+
Ok(r) => Ok(r),
170+
Err(e) => Err(self.new_error(e)),
193171
}
194172
}
195173

196-
pub async fn file_upload(
197-
&self,
198-
req: FileUploadRequest,
199-
) -> Result<FileUploadResponse, Box<dyn std::error::Error>> {
200-
let res = self.post("/files", &req).await;
201-
match res {
202-
Ok(res) => {
203-
let r = res.json::<FileUploadResponse>().await?;
204-
Ok(r)
205-
}
206-
Err(e) => Err(e),
174+
pub async fn file_upload(&self, req: FileUploadRequest) -> Result<FileUploadResponse, Error> {
175+
let res = self.post("/files", &req).await?;
176+
let r = res.json::<FileUploadResponse>().await;
177+
match r {
178+
Ok(r) => Ok(r),
179+
Err(e) => Err(self.new_error(e)),
207180
}
208181
}
209182

210-
pub async fn file_delete(
211-
&self,
212-
req: FileDeleteRequest,
213-
) -> Result<FileDeleteResponse, Box<dyn std::error::Error>> {
214-
let res = self.delete(&format!("{}/{}", "/files", req.file_id)).await;
215-
match res {
216-
Ok(res) => {
217-
let r = res.json::<FileDeleteResponse>().await?;
218-
Ok(r)
219-
}
220-
Err(e) => Err(e),
183+
pub async fn file_delete(&self, req: FileDeleteRequest) -> Result<FileDeleteResponse, Error> {
184+
let res = self
185+
.delete(&format!("{}/{}", "/files", req.file_id))
186+
.await?;
187+
let r = res.json::<FileDeleteResponse>().await;
188+
match r {
189+
Ok(r) => Ok(r),
190+
Err(e) => Err(self.new_error(e)),
221191
}
222192
}
223193

224194
pub async fn file_retrieve(
225195
&self,
226196
req: FileRetrieveRequest,
227-
) -> Result<FileRetrieveResponse, Box<dyn std::error::Error>> {
228-
let res = self.get(&format!("{}/{}", "/files", req.file_id)).await;
229-
match res {
230-
Ok(res) => {
231-
let r = res.json::<FileRetrieveResponse>().await?;
232-
Ok(r)
233-
}
234-
Err(e) => Err(e),
197+
) -> Result<FileRetrieveResponse, Error> {
198+
let res = self.get(&format!("{}/{}", "/files", req.file_id)).await?;
199+
let r = res.json::<FileRetrieveResponse>().await;
200+
match r {
201+
Ok(r) => Ok(r),
202+
Err(e) => Err(self.new_error(e)),
235203
}
236204
}
237205

238206
pub async fn file_retrieve_content(
239207
&self,
240208
req: FileRetrieveContentRequest,
241-
) -> Result<FileRetrieveContentResponse, Box<dyn std::error::Error>> {
209+
) -> Result<FileRetrieveContentResponse, Error> {
242210
let res = self
243211
.get(&format!("{}/{}/content", "/files", req.file_id))
244-
.await;
245-
match res {
246-
Ok(res) => {
247-
let r = res.json::<FileRetrieveContentResponse>().await?;
248-
Ok(r)
249-
}
250-
Err(e) => Err(e),
212+
.await?;
213+
let r = res.json::<FileRetrieveContentResponse>().await;
214+
match r {
215+
Ok(r) => Ok(r),
216+
Err(e) => Err(self.new_error(e)),
251217
}
252218
}
253219

254220
pub async fn chat_completion(
255221
&self,
256222
req: ChatCompletionRequest,
257-
) -> Result<ChatCompletionResponse, Box<dyn std::error::Error>> {
258-
let res = self.post("/chat/completions", &req).await;
259-
match res {
260-
Ok(res) => {
261-
let r = res.json::<ChatCompletionResponse>().await?;
262-
Ok(r)
263-
}
264-
Err(e) => Err(e),
223+
) -> Result<ChatCompletionResponse, Error> {
224+
let res = self.post("/chat/completions", &req).await?;
225+
let r = res.json::<ChatCompletionResponse>().await;
226+
match r {
227+
Ok(r) => Ok(r),
228+
Err(e) => Err(self.new_error(e)),
265229
}
266230
}
231+
232+
fn new_error(&self, err: reqwest::Error) -> Error {
233+
Error::new(std::io::ErrorKind::Other, err)
234+
}
267235
}

0 commit comments

Comments
 (0)