Skip to main content

async_openai/
image.rs

1#![allow(deprecated)]
2use crate::{
3    config::Config,
4    error::OpenAIError,
5    types::images::{
6        CreateImageEditRequest, CreateImageRequest, CreateImageVariationRequest, ImagesResponse,
7    },
8    Client, RequestOptions,
9};
10
11use crate::types::images::{ImageEditStream, ImageGenStream};
12
13/// Given a prompt and/or an input image, the model will generate a new image.
14///
15/// Related guide: [Image generation](https://platform.openai.com/docs/guides/images)
16pub struct Images<'c, C: Config> {
17    client: &'c Client<C>,
18    pub(crate) request_options: RequestOptions,
19}
20
21impl<'c, C: Config> Images<'c, C> {
22    pub fn new(client: &'c Client<C>) -> Self {
23        Self {
24            client,
25            request_options: RequestOptions::new(),
26        }
27    }
28
29    /// Creates an image given a prompt.
30    #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
31    pub async fn generate(
32        &self,
33        request: CreateImageRequest,
34    ) -> Result<ImagesResponse, OpenAIError> {
35        self.client
36            .post("/images/generations", request, &self.request_options)
37            .await
38    }
39
40    /// Creates an image given a prompt.
41    #[crate::byot(
42        T0 = serde::Serialize,
43        R = serde::de::DeserializeOwned,
44        stream = "true",
45        where_clause = "R: crate::traits::MaybeSend + 'static"
46    )]
47    #[allow(unused_mut)]
48    pub async fn generate_stream(
49        &self,
50        mut request: CreateImageRequest,
51    ) -> Result<ImageGenStream, OpenAIError> {
52        #[cfg(not(feature = "byot"))]
53        {
54            if request.stream.is_some() && !request.stream.unwrap() {
55                return Err(OpenAIError::InvalidArgument(
56                    "When stream is false, use Image::generate".into(),
57                ));
58            }
59
60            request.stream = Some(true);
61        }
62
63        self.client
64            .post_stream("/images/generations", request, &self.request_options)
65            .await
66    }
67
68    /// Creates an edited or extended image given one or more source images and a prompt.
69    /// This endpoint only supports gpt-image-1 and dall-e-2.
70    #[crate::byot(
71        T0 = Clone,
72        R = serde::de::DeserializeOwned,
73        where_clause =  "reqwest::multipart::Form: crate::traits::AsyncTryFrom<T0, Error = OpenAIError>, T0: crate::traits::MaybeSend + 'static",
74    )]
75    pub async fn edit(
76        &self,
77        request: CreateImageEditRequest,
78    ) -> Result<ImagesResponse, OpenAIError> {
79        self.client
80            .post_form("/images/edits", request, &self.request_options)
81            .await
82    }
83
84    /// Creates an edited or extended image given one or more source images and a prompt.
85    /// This endpoint only supports gpt-image-1 and dall-e-2.
86    #[crate::byot(
87        T0 = Clone,
88        R = serde::de::DeserializeOwned,
89        stream = "true",
90        where_clause = "R: crate::traits::MaybeSend + 'static, reqwest::multipart::Form: crate::traits::AsyncTryFrom<T0, Error = OpenAIError>, T0: crate::traits::MaybeSend + 'static"
91    )]
92    #[allow(unused_mut)]
93    pub async fn edit_stream(
94        &self,
95        mut request: CreateImageEditRequest,
96    ) -> Result<ImageEditStream, OpenAIError> {
97        #[cfg(not(feature = "byot"))]
98        {
99            if let Some(stream) = request.stream {
100                if !stream {
101                    return Err(OpenAIError::InvalidArgument(
102                        "When stream is false, use Image::edit".into(),
103                    ));
104                }
105            }
106            request.stream = Some(true);
107        }
108        self.client
109            .post_form_stream("/images/edits", request, &self.request_options)
110            .await
111    }
112
113    /// Creates a variation of a given image. This endpoint only supports dall-e-2.
114    #[crate::byot(
115        T0 = Clone,
116        R = serde::de::DeserializeOwned,
117        where_clause =  "reqwest::multipart::Form: crate::traits::AsyncTryFrom<T0, Error = OpenAIError>, T0: crate::traits::MaybeSend + 'static",
118    )]
119    #[deprecated]
120    pub async fn create_variation(
121        &self,
122        request: CreateImageVariationRequest,
123    ) -> Result<ImagesResponse, OpenAIError> {
124        self.client
125            .post_form("/images/variations", request, &self.request_options)
126            .await
127    }
128}