more preps

Author: Alex Andreba

.github/workflows/rust.yml

@@ -16,4 +16,15 @@ jobs:
         steps:
             - uses: actions/checkout@v3
             - name: Build
-              run: cargo build --verbose
+              run:
+                - cargo build --verbose
+	            - cargo build --verbose --all-features
+	            - cargo build --verbose --tests
+	            - cargo build --verbose --tests --all-features
+
+            - name: Check
+              run:
+                - cargo check --verbose
+	            - cargo check --verbose --all-features
+	            - cargo check --verbose --tests
+	            - cargo check --verbose --tests --all-features

Cargo.toml

@@ -14,7 +14,7 @@ categories = [
 ]
 repository = "https://github.com/Aandreba/libopenai"
 license-file = "LICENSE.md"
-exclude = [".github", "media", "Makefile"]
+exclude = [".github", "examples", "media", "Makefile"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

Makefile

@@ -1,2 +1,8 @@
+check:
+	cargo check
+	cargo check --all-features
+	cargo check --tests
+	cargo check --tests --all-features
+
 doc:
 	cargo +nightly rustdoc --all-features --open -- --cfg docsrs

README.md

@@ -22,7 +22,8 @@ use libopenai::prelude::*;
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    # dotenv::dotenv().unwrap();
+    // OPTIONAL: Load variables in a `.env` file into the enviroment
+    dotenv::dotenv().unwrap();
 
     let client = Client::new(
         None, // Gets api key from `OPENAI_API_KEY` enviroment variable
@@ -41,9 +42,15 @@ async fn main() -> Result<()> {
     println!("{:#?}", basic);
     return Ok(());
 }
-
 ```
 
 ## Features
 
+-   Support for completions (regular & chat)
+-   [Image generation](https://docs.rs/libopenai/latest/libopenai/image) with automatic conversion to desired formats
+-   [Audio-to-text](https://docs.rs/libopenai/latest/libopenai/audio) conversions
+-   Support for streaming
+
+## Cargo features
+
 Currently, the only feature available is **tracing**, which enables some minor logging

examples/audio.rs

@@ -0,0 +1,31 @@
+use libopenai::prelude::*;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    dotenv::dotenv().unwrap();
+    tracing_subscriber::fmt::init();
+
+    let client = Client::new(None, None)?;
+
+    let srt = TranscriptionBuilder::new()
+        .response_format(libopenai::audio::AudioResponseFormat::Srt)
+        .temperature(0.0)?
+        .with_file("./media/audio.mp3", &client)
+        .await?;
+
+    println!("{:#?}", srt.text());
+    println!("{:#?}", srt.duration());
+    println!("{:#?}", srt.segments().map(Iterator::collect::<Vec<_>>));
+
+    let verbose = TranscriptionBuilder::new()
+        .response_format(libopenai::audio::AudioResponseFormat::VerboseJson)
+        .temperature(0.0)?
+        .with_file("./media/audio.mp3", &client)
+        .await?;
+
+    println!("{:#?}", verbose.text());
+    println!("{:#?}", verbose.duration());
+    println!("{:#?}", verbose.segments().map(Iterator::collect::<Vec<_>>));
+
+    return Ok(());
+}

examples/main.rs examples/basic.rs

@@ -3,6 +3,7 @@ use libopenai::prelude::*;
 #[tokio::main]
 async fn main() -> Result<()> {
     dotenv::dotenv().unwrap();
+    tracing_subscriber::fmt::init();
 
     let client = Client::new(
         None, // Gets api key from `OPENAI_API_KEY` enviroment variable

examples/finetune.rs

@@ -0,0 +1,62 @@
+use futures::TryStreamExt;
+use libopenai::{file::TemporaryFile, prelude::*};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    const MODEL: &str = "text-davinci-003";
+
+    dotenv::dotenv().unwrap();
+    tracing_subscriber::fmt::init();
+    let client = Client::new(None, None)?;
+
+    let ft = match FineTune::retreive("ft-8KUqxC0IcvgVe707j93Xoa6D", &client).await {
+        Ok(x) => x,
+        Err(_) => {
+            let questions = Completion::builder(MODEL, "Give me a math question")
+                .n(10)
+                .max_tokens(100)
+                .build(&client)
+                .await?
+                .choices;
+
+            let answers = Completion::raw_builder(MODEL)
+                .echo(true)
+                .prompt(questions.iter().map(|x| x.text.as_str()))
+                .max_tokens(256)
+                .build(&client)
+                .await?
+                .choices
+                .into_iter()
+                .filter_map(|x| {
+                    if let Some((prompt, completion)) = x.text.split_once("\n\n") {
+                        return Some(TrainingData::new(prompt, completion));
+                    }
+                    return None;
+                });
+
+            let training_file = TemporaryFile::from_file(
+                TrainingData::save_iter(answers, &client).await?,
+                client.clone(),
+            );
+
+            FineTune::new(&training_file.id, &client).await?
+        }
+    };
+
+    let mut events = ft.event_stream(&client).await.unwrap();
+
+    let handle = tokio::spawn(async move {
+        while let Some(event) = events.try_next().await.unwrap() {
+            println!("{event:#?}");
+        }
+        return Result::<()>::Ok(());
+    });
+
+    let example = Completion::new(ft.fine_tuned_model()?, "square root of two", client)
+        .await
+        .unwrap();
+    println!("{example:#?}");
+
+    handle.await.unwrap()?;
+    return Ok(());
+}

examples/image.rs

@@ -0,0 +1,18 @@
+use libopenai::prelude::*;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    dotenv::dotenv().unwrap();
+    tracing_subscriber::fmt::init();
+
+    let client = Client::new(None, None)?;
+
+    Images::create("Nintendo Switch playing The Last of Us")?
+        .n(2)?
+        .build(&client)
+        .await?
+        .save_at("./media/out")
+        .await?;
+
+    return Ok(());
+}

examples/streamed.rs

@@ -0,0 +1,24 @@
+use futures::TryStreamExt;
+use libopenai::prelude::*;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    dotenv::dotenv().unwrap();
+    tracing_subscriber::fmt::init();
+
+    let client = Client::new(None, None)?;
+
+    let mut stream = Completion::builder(
+        "text-davinci-003",
+        "What's the best way to calculate a factorial?",
+    )
+    .max_tokens(256)
+    .build_stream(&client)
+    .await?;
+
+    while let Some(completion) = stream.try_next().await? {
+        println!("{completion:#?}");
+    }
+
+    return Ok(());
+}

src/file.rs

@@ -25,6 +25,7 @@ use std::{
 };
 use tokio_util::io::ReaderStream;
 
+// File that is deleted when dropped
 #[derive(Debug)]
 pub struct TemporaryFile {
     inner: File,
@@ -234,15 +235,19 @@ impl<S: Stream<Item = reqwest::Result<Bytes>>, T: DeserializeOwned> Stream for C
 }
 
 impl TemporaryFile {
+    /// Creates a new [`TemporaryFile`] from an existing [`File`] instance.
     #[inline]
-    pub fn new(inner: File, client: Client) -> Self {
+    pub fn from_file(inner: File, client: Client) -> Self {
         return Self {
             inner,
             client,
             deleting: false,
         };
     }
 
+    /// Returns the inner [`File`]
+    ///
+    /// Note that after this function is invoked, the file will no longer be automatically deleted when dropped.
     #[inline]
     pub fn into_inner(self) -> File {
         let mut this = ManuallyDrop::new(self);

src/image/variation.rs

@@ -80,6 +80,8 @@ impl VariationBuilder {
     }
 
     /// Sends the request with the specified file
+    ///
+    /// If the images do not conform to OpenAI's requirements, they will be adapted before they are sent
     pub async fn with_file(
         self,
         image: impl Into<PathBuf>,
@@ -102,8 +104,6 @@ impl VariationBuilder {
     }
 
     /// Sends the request with the specified file.
-    ///
-    /// If the images do not conform to OpenAI's requirements, they will be adapted before they are sent
     pub async fn with_tokio_reader<I>(self, image: I, client: impl AsRef<Client>) -> Result<Images>
     where
         I: 'static + Send + Sync + tokio::io::AsyncRead,

src/lib.rs

@@ -67,6 +67,7 @@ pub mod prelude {
 
     pub use file::File;
 
+    pub use finetune::data::TrainingData;
     pub use finetune::{FineTune, FineTuneEvent};
 
     pub use super::image::ImageData;