feat: sync image api + image streaming support + fixes

.gitattributes

@@ -0,0 +1,16 @@
+# Enforce LF line endings for all text files
+* text=auto eol=lf
+
+# Explicitly set binary files
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.pdf binary
+*.mp3 binary
+*.mp4 binary
+*.zip binary
+*.tar binary
+*.gz binary
+

.github/workflows/pr-checks.yml

@@ -3,8 +3,6 @@ name: PR Checks
 on:
   pull_request:
     types: [opened, synchronize, reopened]
-  pull_request_target:
-    types: [opened, synchronize, reopened]
 
 jobs:
   build:

async-openai/README.md

@@ -76,7 +76,7 @@ Support for webhook event types, signature verification, and building webhook ev
 
 ```rust
 use async_openai::{
-    types::{CreateImageRequestArgs, ImageSize, ImageResponseFormat},
+    types::images::{CreateImageRequestArgs, ImageResponseFormat, ImageSize},
     Client,
 };
 use std::error::Error;
@@ -94,7 +94,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         .user("async-openai")
         .build()?;
 
-    let response = client.images().create(request).await?;
+    let response = client.images().generate(request).await?;
 
     // Download and save images to ./data directory.
     // Each url is downloaded and saved in dedicated Tokio task.

async-openai/src/image.rs

@@ -1,8 +1,9 @@
 use crate::{
     config::Config,
     error::OpenAIError,
-    types::{
-        CreateImageEditRequest, CreateImageRequest, CreateImageVariationRequest, ImagesResponse,
+    types::images::{
+        CreateImageEditRequest, CreateImageRequest, CreateImageVariationRequest, ImageEditStream,
+        ImageGenStream, ImagesResponse,
     },
     Client,
 };
@@ -21,24 +22,84 @@ impl<'c, C: Config> Images<'c, C> {
 
     /// Creates an image given a prompt.
     #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
-    pub async fn create(&self, request: CreateImageRequest) -> Result<ImagesResponse, OpenAIError> {
+    pub async fn generate(
+        &self,
+        request: CreateImageRequest,
+    ) -> Result<ImagesResponse, OpenAIError> {
         self.client.post("/images/generations", request).await
     }
 
-    /// Creates an edited or extended image given an original image and a prompt.
+    /// Creates an image given a prompt.
+    #[crate::byot(
+        T0 = serde::Serialize,
+        R = serde::de::DeserializeOwned,
+        stream = "true",
+        where_clause = "R: std::marker::Send + 'static"
+    )]
+    #[allow(unused_mut)]
+    pub async fn generate_stream(
+        &self,
+        mut request: CreateImageRequest,
+    ) -> Result<ImageGenStream, OpenAIError> {
+        #[cfg(not(feature = "byot"))]
+        {
+            if request.stream.is_some() && !request.stream.unwrap() {
+                return Err(OpenAIError::InvalidArgument(
+                    "When stream is false, use Image::generate".into(),
+                ));
+            }
+
+            request.stream = Some(true);
+        }
+
+        Ok(self
+            .client
+            .post_stream("/images/generations", request)
+            .await)
+    }
+
+    /// Creates an edited or extended image given one or more source images and a prompt.
+    /// This endpoint only supports gpt-image-1 and dall-e-2.
     #[crate::byot(
         T0 = Clone,
         R = serde::de::DeserializeOwned,
         where_clause =  "reqwest::multipart::Form: crate::traits::AsyncTryFrom<T0, Error = OpenAIError>",
     )]
-    pub async fn create_edit(
+    pub async fn edit(
         &self,
         request: CreateImageEditRequest,
     ) -> Result<ImagesResponse, OpenAIError> {
         self.client.post_form("/images/edits", request).await
     }
 
-    /// Creates a variation of a given image.
+    /// Creates an edited or extended image given one or more source images and a prompt.
+    /// This endpoint only supports gpt-image-1 and dall-e-2.
+    #[crate::byot(
+        T0 = Clone,
+        R = serde::de::DeserializeOwned,
+        stream = "true",
+        where_clause = "R: std::marker::Send + 'static, reqwest::multipart::Form: crate::traits::AsyncTryFrom<T0, Error = OpenAIError>"
+    )]
+    #[allow(unused_mut)]
+    pub async fn edit_stream(
+        &self,
+        mut request: CreateImageEditRequest,
+    ) -> Result<ImageEditStream, OpenAIError> {
+        #[cfg(not(feature = "byot"))]
+        {
+            if let Some(stream) = request.stream {
+                if !stream {
+                    return Err(OpenAIError::InvalidArgument(
+                        "When stream is false, use Image::edit".into(),
+                    ));
+                }
+            }
+            request.stream = Some(true);
+        }
+        self.client.post_form_stream("/images/edits", request).await
+    }
+
+    /// Creates a variation of a given image. This endpoint only supports dall-e-2.
     #[crate::byot(
         T0 = Clone,
         R = serde::de::DeserializeOwned,