flatten ApiResponseOrError to avoid nested Results and Errors

implement From traits for std:io and reqwest Errors Added missing_file test
davidbegin · Jun 4, 2023 · efd2d36 · efd2d36
1 parent ec78d1b
commit efd2d36
Show file tree

Hide file tree

Showing 10 changed files with 60 additions and 57 deletions.
diff --git a/examples/chat_cli.rs b/examples/chat_cli.rs
@@ -38,7 +38,6 @@ async fn main() {
         let chat_completion = ChatCompletion::builder("gpt-3.5-turbo", messages.clone())
             .create()
             .await
-            .unwrap()
             .unwrap();
         let returned_message = chat_completion.choices.first().unwrap().message.clone();
 

diff --git a/examples/completions_cli.rs b/examples/completions_cli.rs
@@ -20,7 +20,6 @@ async fn main() {
             .max_tokens(1024)
             .create()
             .await
-            .unwrap()
             .unwrap();
 
         let response = &completion.choices.first().unwrap().text;

diff --git a/src/chat.rs b/src/chat.rs
@@ -319,7 +319,6 @@ mod tests {
         .temperature(0.0)
         .create()
         .await
-        .unwrap()
         .unwrap();
 
         assert_eq!(

diff --git a/src/completions.rs b/src/completions.rs
@@ -181,7 +181,6 @@ mod tests {
             .temperature(0.0)
             .create()
             .await
-            .unwrap()
             .unwrap();
 
         assert_eq!(

diff --git a/src/edits.rs b/src/edits.rs
@@ -65,9 +65,9 @@ impl Edit {
                     edit.choices.push(choice.text.clone());
                 }
 
-                Ok(Ok(edit))
+                Ok(edit)
             }
-            Err(_) => Ok(response),
+            Err(_) => response,
         }
     }
 
@@ -102,7 +102,6 @@ mod tests {
             .temperature(0.0)
             .create()
             .await
-            .unwrap()
             .unwrap();
 
         assert_eq!(

diff --git a/src/embeddings.rs b/src/embeddings.rs
@@ -72,12 +72,8 @@ impl Embeddings {
 
 impl Embedding {
     pub async fn create(model: &str, input: &str, user: &str) -> ApiResponseOrError<Self> {
-        let response = Embeddings::create(model, vec![input], user).await?;
-
-        match response {
-            Ok(mut embeddings) => Ok(Ok(embeddings.data.swap_remove(0))),
-            Err(error) => Ok(Err(error)),
-        }
+        let mut embeddings = Embeddings::create(model, vec![input], user).await?;
+        Ok(embeddings.data.swap_remove(0))
     }
 
     pub fn distance(&self, other: &Self) -> f64 {
@@ -111,7 +107,6 @@ mod tests {
             "",
         )
         .await
-        .unwrap()
         .unwrap();
 
         assert!(!embeddings.data.first().unwrap().vec.is_empty());
@@ -128,7 +123,6 @@ mod tests {
             "",
         )
         .await
-        .unwrap()
         .unwrap();
 
         assert!(!embedding.vec.is_empty());

diff --git a/src/files.rs b/src/files.rs
@@ -1,10 +1,10 @@
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
 use derive_builder::Builder;
 use reqwest::multipart::{Form, Part};
 use serde::{Deserialize, Serialize};
 
-use crate::{openai_delete, openai_get, openai_post_multipart, OpenAiError};
+use crate::{openai_delete, openai_get, openai_post_multipart};
 
 use super::ApiResponseOrError;
 
@@ -44,23 +44,15 @@ impl File {
     async fn create(request: &FileUploadRequest) -> ApiResponseOrError<Self> {
         let purpose = request.purpose.clone();
         let upload_file_path = Path::new(request.file_name.as_str());
-        let upload_file_path = upload_file_path.canonicalize().unwrap();
-        if !upload_file_path.exists() {
-            return Ok(Err(file_not_found_error(&upload_file_path)));
-        }
+        let upload_file_path = upload_file_path.canonicalize()?;
         let simple_name = upload_file_path
             .file_name()
             .unwrap()
             .to_str()
             .unwrap()
             .to_string()
             .clone();
-        let async_file = match tokio::fs::File::open(upload_file_path).await {
-            Ok(f) => f,
-            Err(e) => {
-                return Ok(Err(io_error(e)));
-            }
-        };
+        let async_file = tokio::fs::File::open(upload_file_path).await?;
         let file_part = Part::stream(async_file)
             .file_name(simple_name)
             .mime_str("application/jsonl")?;
@@ -77,24 +69,6 @@ impl File {
     }
 }
 
-fn file_not_found_error(file_path: &PathBuf) -> OpenAiError {
-    OpenAiError {
-        message: format!("File {} not found", file_path.display()),
-        error_type: "internal".to_string(),
-        param: None,
-        code: None,
-    }
-}
-
-fn io_error(err: std::io::Error) -> OpenAiError {
-    OpenAiError {
-        message: format!("IO Error {}", err.to_string()),
-        error_type: "internal".to_string(),
-        param: None,
-        code: None,
-    }
-}
-
 impl FileUploadBuilder {
     pub async fn create(self) -> ApiResponseOrError<File> {
         File::create(&self.build().unwrap()).await
@@ -132,21 +106,38 @@ mod tests {
     async fn upload_file() {
         dotenv().ok();
         set_key(env::var("OPENAI_KEY").unwrap());
-        let file_upload = test_upload_builder().create().await.unwrap().unwrap();
+        let file_upload = test_upload_builder().create().await.unwrap();
         println!(
             "upload: {}",
             serde_json::to_string_pretty(&file_upload).unwrap()
         );
         assert_eq!(file_upload.id.as_bytes()[..5], *"file-".as_bytes())
     }
 
+    #[tokio::test]
+    async fn missing_file() {
+        dotenv().ok();
+        set_key(env::var("OPENAI_KEY").unwrap());
+        let test_builder = File::builder()
+            .file_name("test_data/missing_file.jsonl")
+            .purpose("fine-tune");
+        let response = test_builder.create().await;
+        assert!(response.is_err());
+        let openapi_err = response.err().unwrap();
+        assert_eq!(openapi_err.error_type, "io");
+        assert_eq!(
+            openapi_err.message,
+            "No such file or directory (os error 2)"
+        )
+    }
+
     #[tokio::test]
     async fn list_files() {
         dotenv().ok();
         set_key(env::var("OPENAI_KEY").unwrap());
         // ensure at least one file exists
-        test_upload_builder().create().await.unwrap().unwrap();
-        let openai_files = Files::list().await.unwrap().unwrap();
+        test_upload_builder().create().await.unwrap();
+        let openai_files = Files::list().await.unwrap();
         let file_count = openai_files.data.len();
         assert!(file_count > 0);
         for openai_file in &openai_files.data {
@@ -164,15 +155,15 @@ mod tests {
         dotenv().ok();
         set_key(env::var("OPENAI_KEY").unwrap());
         // ensure at least one file exists
-        test_upload_builder().create().await.unwrap().unwrap();
+        test_upload_builder().create().await.unwrap();
         // wait to avoid recent upload still processing error
         tokio::time::sleep(Duration::from_secs(5)).await;
-        let openai_files = Files::list().await.unwrap().unwrap();
+        let openai_files = Files::list().await.unwrap();
         assert!(openai_files.data.len() > 0);
         let mut files = openai_files.data;
         files.sort_by(|a, b| a.created_at.cmp(&b.created_at));
         for file in files {
-            let deleted_file = File::delete(file.id.as_str()).await.unwrap().unwrap();
+            let deleted_file = File::delete(file.id.as_str()).await.unwrap();
             assert!(deleted_file.deleted);
             println!("deleted: {} {}", deleted_file.id, deleted_file.deleted)
         }

diff --git a/src/lib.rs b/src/lib.rs
@@ -1,8 +1,9 @@
+use std::sync::Mutex;
+
 use reqwest::multipart::Form;
 use reqwest::{header::AUTHORIZATION, Client, Method, RequestBuilder};
 use reqwest_eventsource::{CannotCloneRequestError, EventSource, RequestBuilderExt};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
-use std::sync::Mutex;
 
 pub mod chat;
 pub mod completions;
@@ -25,6 +26,17 @@ pub struct OpenAiError {
     pub code: Option<String>,
 }
 
+impl OpenAiError {
+    fn new(message: String, error_type: String) -> OpenAiError {
+        OpenAiError {
+            message,
+            error_type,
+            param: None,
+            code: None,
+        }
+    }
+}
+
 impl std::fmt::Display for OpenAiError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.message)
@@ -47,7 +59,19 @@ pub struct Usage {
     pub total_tokens: u32,
 }
 
-type ApiResponseOrError<T> = Result<Result<T, OpenAiError>, reqwest::Error>;
+type ApiResponseOrError<T> = Result<T, OpenAiError>;
+
+impl From<reqwest::Error> for OpenAiError {
+    fn from(value: reqwest::Error) -> Self {
+        OpenAiError::new(value.to_string(), "reqwest".to_string())
+    }
+}
+
+impl From<std::io::Error> for OpenAiError {
+    fn from(value: std::io::Error) -> Self {
+        OpenAiError::new(value.to_string(), "io".to_string())
+    }
+}
 
 async fn openai_request<F, T>(method: Method, route: &str, builder: F) -> ApiResponseOrError<T>
 where
@@ -67,8 +91,8 @@ where
         .await?;
 
     match api_response {
-        ApiResponse::Ok(t) => Ok(Ok(t)),
-        ApiResponse::Err { error } => Ok(Err(error)),
+        ApiResponse::Ok(t) => Ok(t),
+        ApiResponse::Err { error } => Err(error),
     }
 }
 

diff --git a/src/models.rs b/src/models.rs
@@ -50,7 +50,7 @@ mod tests {
         dotenv().ok();
         set_key(env::var("OPENAI_KEY").unwrap());
 
-        let model = Model::from("text-davinci-003").await.unwrap().unwrap();
+        let model = Model::from("text-davinci-003").await.unwrap();
 
         assert_eq!(model.id, "text-davinci-003");
     }

diff --git a/src/moderations.rs b/src/moderations.rs
@@ -94,7 +94,6 @@ mod tests {
             .model("text-moderation-latest")
             .create()
             .await
-            .unwrap()
             .unwrap();
 
         assert_eq!(