use super::{map_api_error, Client};
use crate::builders::images::{
ImageEditBuilder, ImageEditRequest, ImageGenerationBuilder, ImageVariationBuilder,
ImageVariationRequest, OutputFormat,
};
use crate::builders::Builder;
use crate::errors::Result;
use crate::interceptor::{AfterResponseContext, BeforeRequestContext, ErrorContext};
use crate::semantic_conventions::operation_names;
use crate::time::Instant;
use crate::Error;
use openai_client_base::apis::images_api;
use openai_client_base::models::ImagesResponse;
#[derive(Debug, Clone, Copy)]
#[allow(dead_code)]
pub struct ImagesClient<'a, T = ()> {
pub(super) client: &'a Client<T>,
}
impl_interceptor_helpers!(ImagesClient<'_, T>);
impl<T: Default + crate::MaybeSend + crate::MaybeSync> ImagesClient<'_, T> {
#[must_use]
pub fn generate(&self, prompt: impl Into<String>) -> ImageGenerationBuilder {
ImageGenerationBuilder::new(prompt)
}
pub async fn create(&self, builder: ImageGenerationBuilder) -> Result<ImagesResponse> {
let request = builder.build()?;
let mut state = T::default();
let operation = operation_names::IMAGE_GENERATION;
let model = request.model.clone();
let request_json = serde_json::to_string(&request).unwrap_or_default();
self.call_before_request(operation, &model, &request_json, &mut state)
.await?;
let start_time = Instant::now();
let response = match images_api::create_image()
.configuration(&self.client.base_configuration)
.create_image_request(&request)
.call()
.await
{
Ok(resp) => resp,
Err(e) => {
let error = self
.handle_api_error(e, operation, &model, &request_json, &state)
.await;
return Err(error);
}
};
let duration = start_time.elapsed();
self.call_after_response(
&response,
operation,
&model,
&request_json,
&state,
duration,
None,
None,
)
.await;
Ok(response)
}
#[must_use]
pub fn edit(
&self,
image: impl Into<timvw_rust_runtime::Upload>,
prompt: impl Into<String>,
) -> ImageEditBuilder {
ImageEditBuilder::new(image, prompt)
}
pub async fn create_edit(&self, builder: ImageEditBuilder) -> Result<ImagesResponse> {
let request = builder.build()?;
let model_str = request
.model
.as_deref()
.ok_or_else(|| Error::InvalidRequest("Image editing requires a model".to_string()))?
.to_string();
let mut state = T::default();
let operation = operation_names::IMAGE_EDIT;
let request_json = format!(
r#"{{"prompt":"{}","model":"{}"}}"#,
request.prompt, model_str
);
self.call_before_request(operation, &model_str, &request_json, &mut state)
.await?;
let ImageEditRequest {
image,
prompt,
mask,
background,
model: _,
n,
size,
response_format,
output_format,
output_compression,
user,
input_fidelity,
stream,
partial_images,
quality,
} = request;
let output_format = output_format
.as_deref()
.map(str::parse::<OutputFormat>)
.transpose()
.map_err(|e| Error::InvalidRequest(format!("Invalid image output format: {e}")))?;
let start_time = Instant::now();
let response = match images_api::create_image_edit()
.configuration(&self.client.base_configuration)
.image(image)
.prompt(&prompt)
.maybe_mask(mask)
.maybe_background(background.as_deref())
.model(&model_str)
.maybe_n(n)
.maybe_size(size.map(Into::into))
.maybe_response_format(response_format.as_deref())
.maybe_output_format(output_format)
.maybe_output_compression(output_compression)
.maybe_user(user.as_deref())
.maybe_input_fidelity(input_fidelity)
.maybe_stream(stream)
.maybe_partial_images(partial_images)
.maybe_quality(quality.as_deref())
.call()
.await
{
Ok(resp) => resp,
Err(e) => {
let error = self
.handle_api_error(e, operation, &model_str, &request_json, &state)
.await;
return Err(error);
}
};
let duration = start_time.elapsed();
self.call_after_response(
&response,
operation,
&model_str,
&request_json,
&state,
duration,
None,
None,
)
.await;
Ok(response)
}
#[must_use]
pub fn variation(&self, image: impl Into<timvw_rust_runtime::Upload>) -> ImageVariationBuilder {
ImageVariationBuilder::new(image)
}
pub async fn create_variation(&self, builder: ImageVariationBuilder) -> Result<ImagesResponse> {
let request = builder.build()?;
let model_str = request
.model
.as_ref()
.map_or_else(|| "dall-e-2".to_string(), ToString::to_string);
let mut state = T::default();
let operation = operation_names::IMAGE_VARIATION;
let request_json = format!(r#"{{"model":"{model_str}"}}"#);
self.call_before_request(operation, &model_str, &request_json, &mut state)
.await?;
let ImageVariationRequest {
image,
model,
n,
response_format,
size,
user,
} = request;
let start_time = Instant::now();
let response = match images_api::create_image_variation()
.configuration(&self.client.base_configuration)
.image(image)
.maybe_model(model.as_deref())
.maybe_n(n)
.maybe_response_format(response_format.as_deref())
.maybe_size(size.as_deref())
.maybe_user(user.as_deref())
.call()
.await
{
Ok(resp) => resp,
Err(e) => {
let error = self
.handle_api_error(e, operation, &model_str, &request_json, &state)
.await;
return Err(error);
}
};
let duration = start_time.elapsed();
self.call_after_response(
&response,
operation,
&model_str,
&request_json,
&state,
duration,
None,
None,
)
.await;
Ok(response)
}
}