Struct Images 

pub struct Images { /* private fields */ }

Client for interacting with the OpenAI Images API.

This struct provides methods to generate, edit, and create variations of images. Use Images::new() to create a new instance.

Example

use openai_tools::images::request::{Images, GenerateOptions, ImageModel, ImageSize};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let images = Images::new()?;

    let options = GenerateOptions {
        model: Some(ImageModel::DallE3),
        size: Some(ImageSize::Size1024x1024),
        ..Default::default()
    };

    let response = images.generate("A sunset over mountains", options).await?;
    println!("Generated image: {:?}", response.data[0].url);

    Ok(())
}

Implementations

impl Images

pub fn new() -> Result<Self>

Creates a new Images client for OpenAI API.

Initializes the client by loading the OpenAI API key from the environment variable OPENAI_API_KEY. Supports .env file loading via dotenvy.

Returns

• Ok(Images) - A new Images client ready for use
• Err(OpenAIToolError) - If the API key is not found in the environment

Example

use openai_tools::images::request::Images;

let images = Images::new().expect("API key should be set");

pub fn with_auth(auth: AuthProvider) -> Self

Creates a new Images client with a custom authentication provider

pub fn azure() -> Result<Self>

Creates a new Images client for Azure OpenAI API

pub fn detect_provider() -> Result<Self>

Creates a new Images client by auto-detecting the provider

pub fn with_url<S: Into<String>>(base_url: S, api_key: S) -> Self

Creates a new Images client with URL-based provider detection

pub fn from_url<S: Into<String>>(url: S) -> Result<Self>

Creates a new Images client from URL using environment variables

pub fn auth(&self) -> &AuthProvider

Returns the authentication provider

pub fn timeout(&mut self, timeout: Duration) -> &mut Self

Sets the request timeout duration.

Arguments

• timeout - The maximum time to wait for a response

Returns

A mutable reference to self for method chaining

pub async fn generate( &self, prompt: &str, options: GenerateOptions, ) -> Result<ImageResponse>

Generates images from a text prompt.

Creates one or more images based on the provided text description.

Arguments

• prompt - Text description of the desired image(s)
• options - Generation options (model, size, quality, etc.)

Returns

• Ok(ImageResponse) - The generated image(s)
• Err(OpenAIToolError) - If the request fails

Example

use openai_tools::images::request::{Images, GenerateOptions, ImageQuality, ImageStyle};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let images = Images::new()?;

    let options = GenerateOptions {
        quality: Some(ImageQuality::Hd),
        style: Some(ImageStyle::Natural),
        ..Default::default()
    };

    let response = images.generate("A serene lake at dawn", options).await?;

    if let Some(url) = &response.data[0].url {
        println!("Image URL: {}", url);
    }

    Ok(())
}

pub async fn edit( &self, image_path: &str, prompt: &str, options: EditOptions, ) -> Result<ImageResponse>

Edits an existing image based on a prompt.

Creates edited versions of an image by replacing areas indicated by a transparent mask. Only available with DALL-E 2.

Arguments

• image_path - Path to the image to edit (PNG, max 4MB, square)
• prompt - Text description of the desired edit
• options - Edit options (mask, size, etc.)

Returns

• Ok(ImageResponse) - The edited image(s)
• Err(OpenAIToolError) - If the request fails

Example

use openai_tools::images::request::{Images, EditOptions};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let images = Images::new()?;

    let options = EditOptions {
        mask: Some("mask.png".to_string()),
        ..Default::default()
    };

    let response = images.edit("original.png", "Add a red hat", options).await?;
    println!("Edited image: {:?}", response.data[0].url);

    Ok(())
}

pub async fn variation( &self, image_path: &str, options: VariationOptions, ) -> Result<ImageResponse>

Creates variations of an existing image.

Only available with DALL-E 2.

Arguments

• image_path - Path to the image to create variations of (PNG, max 4MB, square)
• options - Variation options (n, size, etc.)

Returns

• Ok(ImageResponse) - The image variation(s)
• Err(OpenAIToolError) - If the request fails

Example

use openai_tools::images::request::{Images, VariationOptions, ImageModel};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let images = Images::new()?;

    let options = VariationOptions {
        model: Some(ImageModel::DallE2),
        n: Some(3),
        ..Default::default()
    };

    let response = images.variation("original.png", options).await?;

    for (i, image) in response.data.iter().enumerate() {
        println!("Variation {}: {:?}", i + 1, image.url);
    }

    Ok(())
}