Enum PredictionOutput 

pub enum PredictionOutput {
    File(GradioFileData),
    Value(Value),
}

Variants

File(GradioFileData)

Value(Value)

Implementations

impl PredictionOutput

pub fn is_file(&self) -> bool

pub fn is_value(&self) -> bool

pub fn as_file(self) -> Result<GradioFileData>

Examples found in repository

examples/parler.rs (line 33)

async fn main() {
    if std::env::args().len() < 2 {
        println!("Please provide the content as an argument");
        std::process::exit(1);
    }
    let args: Vec<String> = std::env::args().collect();
    let content = &args[1];
    let description = if args.len() > 2 {
        &args[2]
    } else {
        "Talia speaks high quality audio."
    };

    let client = Client::new("parler-tts/parler-tts-expresso", ClientOptions::default())
        .await
        .unwrap();

    let output = client
        .predict(
            "/gen_tts",
            vec![
                PredictionInput::from_value(content),
                PredictionInput::from_value(description),
            ],
        )
        .await
        .unwrap();
    println!(
        "Generated audio: {}",
        output[0].clone().as_file().unwrap().url.unwrap()
    );
}

examples/vocal-separation.rs (line 29)

async fn main() {
    if std::env::args().len() < 2 {
        println!("Please provide an audio file path as an argument");
        std::process::exit(1);
    }
    let args: Vec<String> = std::env::args().collect();
    let file_path = &args[1];
    println!("File: {}", file_path);

    let client = Client::new("JacobLinCool/vocal-separation", ClientOptions::default())
        .await
        .unwrap();

    let output = client
        .predict(
            "/separate",
            vec![
                PredictionInput::from_file(file_path),
                PredictionInput::from_value("BS-RoFormer"),
            ],
        )
        .await
        .unwrap();
    println!(
        "Vocals: {}",
        output[0].clone().as_file().unwrap().url.unwrap()
    );
    println!(
        "Background: {}",
        output[1].clone().as_file().unwrap().url.unwrap()
    );
}

examples/sd3.rs (line 65)

async fn main() {
    if std::env::args().len() < 2 {
        println!("Please provide the prompt as an argument");
        std::process::exit(1);
    }
    let args: Vec<String> = std::env::args().collect();
    let prompt = &args[1];

    let client = Client::new(
        "stabilityai/stable-diffusion-3-medium",
        ClientOptions::default(),
    )
    .await
    .unwrap();

    let mut prediction = client
        .submit(
            "/infer",
            vec![
                PredictionInput::from_value(prompt),
                PredictionInput::from_value(""),   // negative_prompt
                PredictionInput::from_value(0),    // seed
                PredictionInput::from_value(true), // randomize_seed
                PredictionInput::from_value(1024), // width
                PredictionInput::from_value(1024), // height
                PredictionInput::from_value(5),    // guidance_scale
                PredictionInput::from_value(28),   // num_inference_steps
            ],
        )
        .await
        .unwrap();

    while let Some(event) = prediction.next().await {
        let event = event.unwrap();
        match event {
            gradio::structs::QueueDataMessage::Estimation {
                rank, queue_size, ..
            } => {
                println!("Queueing: {}/{}", rank + 1, queue_size);
            }
            gradio::structs::QueueDataMessage::Progress { progress_data, .. } => {
                if progress_data.is_none() {
                    continue;
                }
                let progress_data = progress_data.unwrap();
                if !progress_data.is_empty() {
                    let progress_data = &progress_data[0];
                    println!(
                        "Processing: {}/{} {}",
                        progress_data.index + 1,
                        progress_data.length.unwrap(),
                        progress_data.unit
                    );
                }
            }
            gradio::structs::QueueDataMessage::ProcessCompleted { output, .. } => {
                let output: Vec<PredictionOutput> = output.try_into().unwrap();

                println!(
                    "Generated Image: {}",
                    output[0].clone().as_file().unwrap().url.unwrap()
                );
                println!(
                    "Seed: {}",
                    output[1].clone().as_value().unwrap().as_i64().unwrap()
                );
                break;
            }
            _ => {}
        }
    }
}

pub fn as_value(self) -> Result<Value>

Examples found in repository

examples/hello-sync.rs (line 12)

fn main() {
    let client = Client::new_sync("gradio/hello_world", ClientOptions::default()).unwrap();

    let output = client
        .predict_sync("/predict", vec![PredictionInput::from_value("Jacob")])
        .unwrap();

    println!(
        "Output: {}",
        output[0].clone().as_value().unwrap().as_str().unwrap()
    );
}

examples/hello.rs (line 15)

async fn main() {
    let client = Client::new("gradio/hello_world", ClientOptions::default())
        .await
        .unwrap();

    let output = client
        .predict("/predict", vec![PredictionInput::from_value("Jacob")])
        .await
        .unwrap();
    println!(
        "Output: {}",
        output[0].clone().as_value().unwrap().as_str().unwrap()
    );
}

examples/whisper.rs (line 29)

async fn main() {
    if std::env::args().len() < 2 {
        println!("Please provide an audio file path as an argument");
        std::process::exit(1);
    }
    let args: Vec<String> = std::env::args().collect();
    let file_path = &args[1];
    println!("File: {}", file_path);

    let client = Client::new("hf-audio/whisper-large-v3", ClientOptions::default())
        .await
        .unwrap();

    let output = client
        .predict(
            "/predict",
            vec![
                PredictionInput::from_file(file_path),
                PredictionInput::from_value("transcribe"),
            ],
        )
        .await
        .unwrap();
    println!(
        "Output: {}",
        output[0].clone().as_value().unwrap().as_str().unwrap()
    );
}

examples/whisper-turbo.rs (line 30)

async fn main() {
    if std::env::args().len() < 2 {
        println!("Please provide an audio file path as an argument");
        std::process::exit(1);
    }
    let args: Vec<String> = std::env::args().collect();
    let file_path = &args[1];
    println!("File: {}", file_path);

    // Gradio v5
    let client = Client::new("hf-audio/whisper-large-v3-turbo", ClientOptions::default())
        .await
        .unwrap();

    let output = client
        .predict(
            "/predict",
            vec![
                PredictionInput::from_file(file_path),
                PredictionInput::from_value("transcribe"),
            ],
        )
        .await
        .unwrap();
    println!(
        "Output: {}",
        output[0].clone().as_value().unwrap().as_str().unwrap()
    );
}

examples/sd3.rs (line 69)

async fn main() {
    if std::env::args().len() < 2 {
        println!("Please provide the prompt as an argument");
        std::process::exit(1);
    }
    let args: Vec<String> = std::env::args().collect();
    let prompt = &args[1];

    let client = Client::new(
        "stabilityai/stable-diffusion-3-medium",
        ClientOptions::default(),
    )
    .await
    .unwrap();

    let mut prediction = client
        .submit(
            "/infer",
            vec![
                PredictionInput::from_value(prompt),
                PredictionInput::from_value(""),   // negative_prompt
                PredictionInput::from_value(0),    // seed
                PredictionInput::from_value(true), // randomize_seed
                PredictionInput::from_value(1024), // width
                PredictionInput::from_value(1024), // height
                PredictionInput::from_value(5),    // guidance_scale
                PredictionInput::from_value(28),   // num_inference_steps
            ],
        )
        .await
        .unwrap();

    while let Some(event) = prediction.next().await {
        let event = event.unwrap();
        match event {
            gradio::structs::QueueDataMessage::Estimation {
                rank, queue_size, ..
            } => {
                println!("Queueing: {}/{}", rank + 1, queue_size);
            }
            gradio::structs::QueueDataMessage::Progress { progress_data, .. } => {
                if progress_data.is_none() {
                    continue;
                }
                let progress_data = progress_data.unwrap();
                if !progress_data.is_empty() {
                    let progress_data = &progress_data[0];
                    println!(
                        "Processing: {}/{} {}",
                        progress_data.index + 1,
                        progress_data.length.unwrap(),
                        progress_data.unit
                    );
                }
            }
            gradio::structs::QueueDataMessage::ProcessCompleted { output, .. } => {
                let output: Vec<PredictionOutput> = output.try_into().unwrap();

                println!(
                    "Generated Image: {}",
                    output[0].clone().as_file().unwrap().url.unwrap()
                );
                println!(
                    "Seed: {}",
                    output[1].clone().as_value().unwrap().as_i64().unwrap()
                );
                break;
            }
            _ => {}
        }
    }
}

Trait Implementations

impl Clone for PredictionOutput

fn clone(&self) -> PredictionOutput

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PredictionOutput

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PredictionOutput

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PredictionOutput

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.