Merge pull request #37 from night-cruise/feat/add-chain-call

feat: add chain call to create Request instance

README.md

@@ -33,25 +33,13 @@ let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
 ### Create request
 ```rust
 use openai_api_rs::v1::chat_completion::{self, ChatCompletionRequest};
-let req = ChatCompletionRequest {
-    model: chat_completion::GPT4.to_string(),
-    messages: vec![chat_completion::ChatCompletionMessage {
+let req = ChatCompletionRequest::new(
+    chat_completion::GPT4.to_string(),
+    vec![chat_completion::ChatCompletionMessage {
         role: chat_completion::MessageRole::user,
         content: String::from("Hello OpenAI!"),
     }],
-    functions: None,
-    function_call: None,
-    temperature: None,
-    top_p: None,
-    n: None,
-    stream: None,
-    stop: None,
-    max_tokens: None,
-    presence_penalty: None,
-    frequency_penalty: None,
-    logit_bias: None,
-    user: None,
-};
+);
 ```
 
 ### Send request
@@ -68,27 +56,15 @@ use std::env;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
-    let req = ChatCompletionRequest {
-        model: chat_completion::GPT4.to_string(),
-        messages: vec![chat_completion::ChatCompletionMessage {
+    let req = ChatCompletionRequest::new(
+        chat_completion::GPT4.to_string(),
+        vec![chat_completion::ChatCompletionMessage {
             role: chat_completion::MessageRole::user,
             content: String::from("What is Bitcoin?"),
             name: None,
             function_call: None,
         }],
-        functions: None,
-        function_call: None,
-        temperature: None,
-        top_p: None,
-        n: None,
-        stream: None,
-        stop: None,
-        max_tokens: None,
-        presence_penalty: None,
-        frequency_penalty: None,
-        logit_bias: None,
-        user: None,
-    };
+    );
     let result = client.chat_completion(req)?;
     println!("{:?}", result.choices[0].message.content);
     Ok(())

examples/chat_completion.rs

@@ -4,29 +4,20 @@ use std::env;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
-    let req = ChatCompletionRequest {
-        model: chat_completion::GPT4.to_string(),
-        messages: vec![chat_completion::ChatCompletionMessage {
+
+    let req = ChatCompletionRequest::new(
+        chat_completion::GPT4.to_string(),
+        vec![chat_completion::ChatCompletionMessage {
             role: chat_completion::MessageRole::user,
             content: String::from("What is Bitcoin?"),
             name: None,
             function_call: None,
         }],
-        functions: None,
-        function_call: None,
-        temperature: None,
-        top_p: None,
-        n: None,
-        stream: None,
-        stop: None,
-        max_tokens: None,
-        presence_penalty: None,
-        frequency_penalty: None,
-        logit_bias: None,
-        user: None,
-    };
+    );
+
     let result = client.chat_completion(req)?;
     println!("{:?}", result.choices[0].message.content);
+
     Ok(())
 }
 

examples/completion.rs

@@ -4,24 +4,18 @@ use std::env;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
-    let req = CompletionRequest {
-        model: completion::GPT3_TEXT_DAVINCI_003.to_string(),
-        prompt: String::from("What is Bitcoin?"),
-        suffix: None,
-        max_tokens: Some(3000),
-        temperature: Some(0.9),
-        top_p: Some(1.0),
-        n: None,
-        stream: None,
-        logprobs: None,
-        echo: None,
-        stop: Some(vec![String::from(" Human:"), String::from(" AI:")]),
-        presence_penalty: Some(0.6),
-        frequency_penalty: Some(0.0),
-        best_of: None,
-        logit_bias: None,
-        user: None,
-    };
+
+    let req = CompletionRequest::new(
+        completion::GPT3_TEXT_DAVINCI_003.to_string(),
+        String::from("What is Bitcoin?"),
+    )
+    .max_tokens(3000)
+    .temperature(0.9)
+    .top_p(1.0)
+    .stop(vec![String::from(" Human:"), String::from(" AI:")])
+    .presence_penalty(0.6)
+    .frequency_penalty(0.0);
+
     let result = client.completion(req)?;
     println!("{:}", result.choices[0].text);
 

examples/embedding.rs

@@ -4,11 +4,12 @@ use std::env;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let client = Client::new(env::var("OPENAI_API_KEY").unwrap().to_string());
-    let req = EmbeddingRequest {
-        model: "text-embedding-ada-002".to_string(),
-        input: "story time".to_string(),
-        user: Option::None,
-    };
+
+    let req = EmbeddingRequest::new(
+        "text-embedding-ada-002".to_string(),
+        "story time".to_string(),
+    );
+
     let result = client.embedding(req)?;
     println!("{:?}", result.data);
 

examples/function_call.rs

@@ -29,35 +29,25 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         }),
     );
 
-    let req = ChatCompletionRequest {
-        model: chat_completion::GPT3_5_TURBO_0613.to_string(),
-        messages: vec![chat_completion::ChatCompletionMessage {
+    let req = ChatCompletionRequest::new(
+        chat_completion::GPT3_5_TURBO_0613.to_string(),
+        vec![chat_completion::ChatCompletionMessage {
             role: chat_completion::MessageRole::user,
             content: String::from("What is the price of Ethereum?"),
             name: None,
             function_call: None,
         }],
-        functions: Some(vec![chat_completion::Function {
-            name: String::from("get_coin_price"),
-            description: Some(String::from("Get the price of a cryptocurrency")),
-            parameters: chat_completion::FunctionParameters {
-                schema_type: chat_completion::JSONSchemaType::Object,
-                properties: Some(properties),
-                required: Some(vec![String::from("coin")]),
-            },
-        }]),
-        function_call: Some(FunctionCallType::Auto), // Some(FunctionCallType::Function { name: "test".to_string() }),
-        temperature: None,
-        top_p: None,
-        n: None,
-        stream: None,
-        stop: None,
-        max_tokens: None,
-        presence_penalty: None,
-        frequency_penalty: None,
-        logit_bias: None,
-        user: None,
-    };
+    )
+    .functions(vec![chat_completion::Function {
+        name: String::from("get_coin_price"),
+        description: Some(String::from("Get the price of a cryptocurrency")),
+        parameters: chat_completion::FunctionParameters {
+            schema_type: chat_completion::JSONSchemaType::Object,
+            properties: Some(properties),
+            required: Some(vec![String::from("coin")]),
+        },
+    }])
+    .function_call(FunctionCallType::Auto);
 
     // debug reuqest json
     // let serialized = serde_json::to_string(&req).unwrap();

examples/function_call_role.rs

@@ -29,35 +29,24 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         }),
     );
 
-    let req = ChatCompletionRequest {
-        model: chat_completion::GPT3_5_TURBO_0613.to_string(),
-        messages: vec![chat_completion::ChatCompletionMessage {
+    let req = ChatCompletionRequest::new(
+        chat_completion::GPT3_5_TURBO_0613.to_string(),
+        vec![chat_completion::ChatCompletionMessage {
             role: chat_completion::MessageRole::user,
             content: String::from("What is the price of Ethereum?"),
             name: None,
             function_call: None,
         }],
-        functions: Some(vec![chat_completion::Function {
-            name: String::from("get_coin_price"),
-            description: Some(String::from("Get the price of a cryptocurrency")),
-            parameters: chat_completion::FunctionParameters {
-                schema_type: chat_completion::JSONSchemaType::Object,
-                properties: Some(properties),
-                required: Some(vec![String::from("coin")]),
-            },
-        }]),
-        function_call: None,
-        temperature: None,
-        top_p: None,
-        n: None,
-        stream: None,
-        stop: None,
-        max_tokens: None,
-        presence_penalty: None,
-        frequency_penalty: None,
-        logit_bias: None,
-        user: None,
-    };
+    )
+    .functions(vec![chat_completion::Function {
+        name: String::from("get_coin_price"),
+        description: Some(String::from("Get the price of a cryptocurrency")),
+        parameters: chat_completion::FunctionParameters {
+            schema_type: chat_completion::JSONSchemaType::Object,
+            properties: Some(properties),
+            required: Some(vec![String::from("coin")]),
+        },
+    }]);
 
     let result = client.chat_completion(req)?;
 
@@ -80,9 +69,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             let c: Currency = serde_json::from_str(&arguments)?;
             let coin = c.coin;
 
-            let req = ChatCompletionRequest {
-                model: chat_completion::GPT3_5_TURBO_0613.to_string(),
-                messages: vec![
+            let req = ChatCompletionRequest::new(
+                chat_completion::GPT3_5_TURBO_0613.to_string(),
+                vec![
                     chat_completion::ChatCompletionMessage {
                         role: chat_completion::MessageRole::user,
                         content: String::from("What is the price of Ethereum?"),
@@ -99,19 +88,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                         function_call: None,
                     },
                 ],
-                functions: None,
-                function_call: None,
-                temperature: None,
-                top_p: None,
-                n: None,
-                stream: None,
-                stop: None,
-                max_tokens: None,
-                presence_penalty: None,
-                frequency_penalty: None,
-                logit_bias: None,
-                user: None,
-            };
+            );
+
             let result = client.chat_completion(req)?;
             println!("{:?}", result.choices[0].message.content);
         }

src/v1/audio.rs

@@ -1,5 +1,7 @@
 use serde::{Deserialize, Serialize};
 
+use crate::impl_builder_methods;
+
 pub const WHISPER_1: &str = "whisper-1";
 
 #[derive(Debug, Serialize)]
@@ -16,6 +18,27 @@ pub struct AudioTranscriptionRequest {
     pub language: Option<String>,
 }
 
+impl AudioTranscriptionRequest {
+    pub fn new(file: String, model: String) -> Self {
+        Self {
+            file,
+            model,
+            prompt: None,
+            response_format: None,
+            temperature: None,
+            language: None,
+        }
+    }
+}
+
+impl_builder_methods!(
+    AudioTranscriptionRequest,
+    prompt: String,
+    response_format: String,
+    temperature: f32,
+    language: String
+);
+
 #[derive(Debug, Deserialize)]
 pub struct AudioTranscriptionResponse {
     pub text: String,
@@ -33,6 +56,25 @@ pub struct AudioTranslationRequest {
     pub temperature: Option<f32>,
 }
 
+impl AudioTranslationRequest {
+    pub fn new(file: String, model: String) -> Self {
+        Self {
+            file,
+            model,
+            prompt: None,
+            response_format: None,
+            temperature: None,
+        }
+    }
+}
+
+impl_builder_methods!(
+    AudioTranslationRequest,
+    prompt: String,
+    response_format: String,
+    temperature: f32
+);
+
 #[derive(Debug, Deserialize)]
 pub struct AudioTranslationResponse {
     pub text: String,