Initial commit

.gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "openai-rs"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+reqwest = { version = "0.11", features = ["json"] }
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1", features = ["derive"] }

examples/completion.rs

@@ -0,0 +1,32 @@
+use openai_rs::v1::completion::{self, CompletionRequest};
+use openai_rs::v1::api::Client;
+use std::env;
+
+#[tokio::main]
+async 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: Some(String::from("NFTとは何か？")),
+        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 completion_response = client.completion(req).await?;
+    println!("{:?}", completion_response.choices[0].text);
+
+    Ok(())
+}
+
+// cargo run --package openai-rs --example completion

src/lib.rs

@@ -0,0 +1 @@
+pub mod v1;

src/v1/api.rs

@@ -0,0 +1,250 @@
+
+use crate::v1::completion::{CompletionRequest, CompletionResponse};
+use crate::v1::edit::{EditRequest, EditResponse};
+use crate::v1::image::{
+    ImageGenerationRequest,
+    ImageGenerationResponse,
+    ImageEditRequest,
+    ImageEditResponse,
+    ImageVariationRequest,
+    ImageVariationResponse,
+};
+use crate::v1::embedding::{EmbeddingRequest, EmbeddingResponse};
+use crate::v1::file::{
+    FileListResponse,
+    FileUploadRequest,
+    FileUploadResponse,
+    FileDeleteRequest,
+    FileDeleteResponse,
+    FileRetrieveRequest,
+    FileRetrieveResponse,
+    FileRetrieveContentRequest,
+    FileRetrieveContentResponse,
+};
+use reqwest::Response;
+
+const APU_URL_V1: &str =  "https://api.openai.com/v1";
+
+pub struct Client {
+  pub api_key: String,
+}
+
+impl Client {
+    pub fn new(api_key: String) -> Self {
+        Self { api_key }
+    }
+
+    pub async fn post<T:serde::ser::Serialize>(&self, path: &str, params: &T) -> Result<Response, Box<dyn std::error::Error>> {
+        let client = reqwest::Client::new();
+        let url = format!("{}{}", APU_URL_V1, path);
+        let res = client
+            .post(&url)
+            .header(reqwest::header::CONTENT_TYPE, "application/json")
+            .header(reqwest::header::AUTHORIZATION, "Bearer ".to_owned() + &self.api_key)
+            .json(&params)
+            .send()
+            .await;
+        match res {
+            Ok(res) => match res.status().is_success() {
+                true => Ok(res),
+                false => {
+                    Err(Box::new(std::io::Error::new(
+                        std::io::ErrorKind::Other,
+                        format!("{}: {}", res.status(), res.text().await.unwrap())
+                    )))
+                },
+            },
+            Err(e) => Err(Box::new(e)),
+        }
+    }
+
+    pub async fn get(&self, path: &str) -> Result<Response, Box<dyn std::error::Error>> {
+        let client = reqwest::Client::new();
+        let url = format!("{}{}", APU_URL_V1, path);
+        let res = client
+            .get(&url)
+            .header(reqwest::header::CONTENT_TYPE, "application/json")
+            .header(reqwest::header::AUTHORIZATION, "Bearer ".to_owned() + &self.api_key)
+            .send()
+            .await;
+        match res {
+            Ok(res) => match res.status().is_success() {
+                true => Ok(res),
+                false => {
+                    Err(Box::new(std::io::Error::new(
+                        std::io::ErrorKind::Other,
+                        format!("{}: {}", res.status(), res.text().await.unwrap())
+                    )))
+                },
+            },
+            Err(e) => Err(Box::new(e)),
+        }
+    }
+
+    pub async fn delete(&self, path: &str) -> Result<Response, Box<dyn std::error::Error>> {
+        let client = reqwest::Client::new();
+        let url = format!("{}{}", APU_URL_V1, path);
+        let res = client
+            .delete(&url)
+            .header(reqwest::header::CONTENT_TYPE, "application/json")
+            .header(reqwest::header::AUTHORIZATION, "Bearer ".to_owned() + &self.api_key)
+            .send()
+            .await;
+        match res {
+            Ok(res) => match res.status().is_success() {
+                true => Ok(res),
+                false => {
+                    Err(Box::new(std::io::Error::new(
+                        std::io::ErrorKind::Other,
+                        format!("{}: {}", res.status(), res.text().await.unwrap())
+                    )))
+                },
+            },
+            Err(e) => Err(Box::new(e)),
+        }
+    }
+
+    pub async fn completion(&self, req: CompletionRequest) -> Result<CompletionResponse, Box<dyn std::error::Error>> {
+        let res = self.post("/completions", &req).await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<CompletionResponse>().await?;
+                return Ok(r);
+            },
+            Err(e) => {
+                return Err(e);
+            },
+        }
+    }
+
+    pub async fn edit(&self, req: EditRequest) -> Result<EditResponse, Box<dyn std::error::Error>> {
+        let res = self.post("/edits", &req).await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<EditResponse>().await?;
+                return Ok(r);
+            },
+            Err(e) => {
+                return Err(e);
+            },
+        }
+    }
+
+    pub async fn image_generation(&self, req: ImageGenerationRequest) -> Result<ImageGenerationResponse, Box<dyn std::error::Error>> {
+        let res = self.post("/images/generations", &req).await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<ImageGenerationResponse>().await?;
+                return Ok(r);
+            },
+            Err(e) => {
+                return Err(e);
+            },
+        }
+    }
+
+    pub async fn image_edit(&self, req: ImageEditRequest) -> Result<ImageEditResponse, Box<dyn std::error::Error>> {
+        let res = self.post("/images/edits", &req).await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<ImageEditResponse>().await?;
+                return Ok(r);
+            },
+            Err(e) => {
+                return Err(e);
+            },
+        }
+    }
+
+    pub async fn image_variation(&self, req: ImageVariationRequest) -> Result<ImageVariationResponse, Box<dyn std::error::Error>> {
+        let res = self.post("/images/variations", &req).await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<ImageVariationResponse>().await?;
+                return Ok(r);
+            },
+            Err(e) => {
+                return Err(e);
+            },
+        }
+    }
+
+    pub async fn embedding(&self, req: EmbeddingRequest) -> Result<EmbeddingResponse, Box<dyn std::error::Error>> {
+        let res = self.post("/embeddings", &req).await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<EmbeddingResponse>().await?;
+                return Ok(r);
+            },
+            Err(e) => {
+                return Err(e);
+            },
+        }
+    }
+
+    pub async fn file_list(&self) -> Result<FileListResponse, Box<dyn std::error::Error>> {
+        let res = self.get("/files").await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<FileListResponse>().await?;
+                return Ok(r);
+            },
+            Err(e) => {
+                return Err(e);
+            },
+        }
+    }
+    
+    pub async fn file_upload(&self, req: FileUploadRequest) -> Result<FileUploadResponse, Box<dyn std::error::Error>> {
+        let res = self.post("/files", &req).await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<FileUploadResponse>().await?;
+                return Ok(r);
+            },
+            Err(e) => {
+                return Err(e);
+            },
+        }
+    }
+    
+    pub async fn file_delete(&self, req: FileDeleteRequest) -> Result<FileDeleteResponse, Box<dyn std::error::Error>> {
+        let res = self.delete(&format!("{}/{}", "/files", req.file_id)).await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<FileDeleteResponse>().await?;
+                return Ok(r);
+            },
+            Err(e) => {
+                return Err(e);
+            },
+        }
+    }
+
+    pub async fn file_retrieve(&self, req: FileRetrieveRequest) -> Result<FileRetrieveResponse, Box<dyn std::error::Error>> {
+        let res = self.get(&format!("{}/{}", "/files", req.file_id)).await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<FileRetrieveResponse>().await?;
+                return Ok(r);
+            },
+            Err(e) => {
+                return Err(e);
+            },
+        }
+    }
+
+    pub async fn file_retrieve_content(&self, req: FileRetrieveContentRequest) -> Result<FileRetrieveContentResponse, Box<dyn std::error::Error>> {
+        let res = self.get(&format!("{}/{}/content", "/files", req.file_id)).await;
+        match res {
+            Ok(res) => {
+                let r = res.json::<FileRetrieveContentResponse>().await?;
+                return Ok(r);
+            },
+            Err(e) => {
+                return Err(e);
+            },
+        }
+    }
+
+}

src/v1/common.rs

@@ -0,0 +1,10 @@
+
+use serde::{Deserialize};
+
+
+#[derive(Debug, Deserialize)]
+pub struct Usage {
+  pub prompt_tokens:      i32,
+	pub completion_tokens:  i32,
+	pub total_tokens:       i32,
+}

src/v1/completion.rs

@@ -0,0 +1,79 @@
+use serde::{Serialize, Deserialize};
+use std::option::Option;
+use std::collections::HashMap;
+
+use crate::v1::common;
+
+pub const GPT3_TEXT_DAVINCI_003: &str       = "text-davinci-003";
+pub const GPT3_TEXT_DAVINCI_002: &str       = "text-davinci-002";
+pub const GPT3_TEXT_CURIE_001: &str         = "text-curie-001";
+pub const GPT3_TEXT_BABBAGE_001: &str       = "text-babbage-001";
+pub const GPT3_TEXT_ADA_001: &str           = "text-ada-001";
+pub const GPT3_TEXT_DAVINCI_001: &str       = "text-davinci-001";
+pub const GPT3_DAVINCI_INSTRUCT_BETA: &str  = "davinci-instruct-beta";
+pub const GPT3_DAVINCI: &str                = "davinci";
+pub const GPT3_CURIE_INSTRUCT_BETA: &str    = "curie-instruct-beta";
+pub const GPT3_CURIE: &str                  = "curie";
+pub const GPT3_ADA: &str                    = "ada";
+pub const GPT3_BABBAGE: &str                = "babbage";
+
+#[derive(Debug, Serialize)]
+pub struct CompletionRequest {
+    pub model:             String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub prompt:            Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub suffix:            Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub max_tokens:        Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temperature:       Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_p:             Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub n:                 Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stream:            Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub logprobs:          Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub echo:              Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stop:              Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub presence_penalty:  Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub frequency_penalty: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub best_of:           Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub logit_bias:        Option<HashMap<String, i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+	pub user:              Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct CompletionChoice {
+    pub text:          String,
+    pub index:         i64,
+    pub finish_reason: String,
+    pub logprobs:      Option<LogprobResult>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct LogprobResult {
+	pub tokens:         Vec<String>,
+	pub token_logprobs: Vec<f32>,
+	pub top_logprobs:   Vec<HashMap<String, f32>>,
+	pub text_offset:    Vec<i32>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct CompletionResponse {
+    pub id:      String,
+    pub object:  String,
+    pub created: i64,
+    pub model:   String,
+    pub choices: Vec<CompletionChoice>,
+	pub usage:   common::Usage,
+}

src/v1/edit.rs

@@ -0,0 +1,32 @@
+use serde::{Serialize, Deserialize};
+use std::option::Option;
+
+use crate::v1::common;
+
+#[derive(Debug, Serialize)]
+pub struct EditRequest {
+    pub model: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub input: Option<String>,
+    pub instruction: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub n: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temperature: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub top_p: Option<f32>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct EditChoice{
+	pub text:  String,
+	pub index: i32,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct EditResponse {
+    pub object:  String,
+    pub created: i64,
+    pub usage:   common::Usage,
+    pub choices: Vec<EditChoice>,
+}

src/v1/embedding.rs

@@ -0,0 +1,27 @@
+use serde::{Serialize, Deserialize};
+use std::option::Option;
+
+use crate::v1::common;
+
+#[derive(Debug, Deserialize)]
+pub struct EmbeddingData{
+	pub object:  String,
+  pub embedding: Vec<f32>,
+  pub index: i32,
+  pub usage: common::Usage,
+}
+
+#[derive(Debug, Serialize)]
+pub struct EmbeddingRequest {
+    pub model: String,
+    pub input: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub user: Option<String>,
+}
+
+
+#[derive(Debug, Deserialize)]
+pub struct EmbeddingResponse {
+    pub object: String,
+    pub data:   Vec<EmbeddingData>,
+}

src/v1/file.rs

@@ -0,0 +1,78 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Debug, Deserialize)]
+pub struct FileData{
+    pub id:  String,
+    pub oejct: String,
+    pub bytes: i32,
+    pub created_at: i64,
+    pub filename: String,
+    pub purpose: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct FileListResponse {
+    pub object: String,
+    pub data:   Vec<FileData>,
+}
+
+
+#[derive(Debug, Serialize)]
+pub struct FileUploadRequest {
+    pub file: String,
+    pub purpose: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct FileUploadResponse {
+    pub id: String,
+    pub oejct: String,
+    pub bytes: i32,
+    pub created_at: i64,
+    pub filename: String,
+    pub purpose: String,
+}
+
+
+#[derive(Debug, Serialize)]
+pub struct FileDeleteRequest {
+    pub file_id: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct FileDeleteResponse {
+    pub id: String,
+    pub oejct: String,
+    pub delete: bool,
+}
+
+#[derive(Debug, Serialize)]
+pub struct FileRetrieveRequest {
+    pub file_id: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct FileRetrieveResponse {
+    pub id: String,
+    pub oejct: String,
+    pub bytes: i32,
+    pub created_at: i64,
+    pub filename: String,
+    pub purpose: String,
+}
+
+
+#[derive(Debug, Serialize)]
+pub struct FileRetrieveContentRequest {
+    pub file_id: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct FileRetrieveContentResponse {
+    pub id: String,
+    pub oejct: String,
+    pub bytes: i32,
+    pub created_at: i64,
+    pub filename: String,
+    pub purpose: String,
+}

src/v1/image.rs

@@ -0,0 +1,68 @@
+use serde::{Serialize, Deserialize};
+use std::option::Option;
+
+#[derive(Debug, Deserialize)]
+pub struct ImageData{
+	pub url:  String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ImageGenerationRequest {
+    pub prompt: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub n: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_format: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub user: Option<String>,
+}
+
+
+#[derive(Debug, Deserialize)]
+pub struct ImageGenerationResponse {
+    pub created: i64,
+    pub data:   Vec<ImageData>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ImageEditRequest {
+    pub image: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mask: Option<String>,
+    pub prompt: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub n: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_format: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub user: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ImageEditResponse {
+    pub created: i64,
+    pub data:   Vec<ImageData>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ImageVariationRequest {
+    pub image: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub n: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_format: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub user: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ImageVariationResponse {
+    pub created: i64,
+    pub data:   Vec<ImageData>,
+}

src/v1/mod.rs

@@ -0,0 +1,9 @@
+pub mod common;
+
+pub mod completion;
+pub mod edit;
+pub mod image;
+pub mod embedding;
+pub mod file;
+
+pub mod api;