async-openai 0.34.0

Rust library for OpenAI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::{
    config::Config,
    error::OpenAIError,
    types::images::{
        CreateImageEditRequest, CreateImageRequest, CreateImageVariationRequest, ImagesResponse,
    },
    Client, RequestOptions,
};

#[cfg(not(target_family = "wasm"))]
use crate::types::images::{ImageEditStream, ImageGenStream};

/// Given a prompt and/or an input image, the model will generate a new image.
///
/// Related guide: [Image generation](https://platform.openai.com/docs/guides/images)
pub struct Images<'c, C: Config> {
    client: &'c Client<C>,
    pub(crate) request_options: RequestOptions,
}

impl<'c, C: Config> Images<'c, C> {
    pub fn new(client: &'c Client<C>) -> Self {
        Self {
            client,
            request_options: RequestOptions::new(),
        }
    }

    /// Creates an image given a prompt.
    #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
    pub async fn generate(
        &self,
        request: CreateImageRequest,
    ) -> Result<ImagesResponse, OpenAIError> {
        self.client
            .post("/images/generations", request, &self.request_options)
            .await
    }

    /// Creates an image given a prompt.
    #[cfg(not(target_family = "wasm"))]
    #[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, &self.request_options)
            .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 edit(
        &self,
        request: CreateImageEditRequest,
    ) -> Result<ImagesResponse, OpenAIError> {
        self.client
            .post_form("/images/edits", request, &self.request_options)
            .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.
    #[cfg(not(target_family = "wasm"))]
    #[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, &self.request_options)
            .await
    }

    /// Creates a variation of a given image. This endpoint only supports 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_variation(
        &self,
        request: CreateImageVariationRequest,
    ) -> Result<ImagesResponse, OpenAIError> {
        self.client
            .post_form("/images/variations", request, &self.request_options)
            .await
    }
}