Struct replicate_rust::Replicate

pub struct Replicate {
    pub predictions: Prediction,
    pub models: Model,
    pub training: Training,
    pub collection: Collection,
    /* private fields */
}

Fields

predictions: Prediction

models: Model

training: Training

collection: Collection

Implementations

impl Replicate

Rust Client for interacting with the Replicate API.

pub fn new() -> Self

Create a new Replicate client.

Arguments

• api_key - The API key to use for authentication.

Example

use replicate::Replicate;
let replicate = Replicate::new("api_key");

Examples found in repository

examples/replicate.rs (line 4)

fn main() {
    let replicate = Replicate::new();

    // Construct the inputs.
    let mut inputs = std::collections::HashMap::new();
    inputs.insert("prompt", "a  19th century portrait of a wombat gentleman");

    let version = String::from("stability-ai/stable-diffusion:27b93a2413e7f36cd83da926f3656280b2931564ff050bf9575f1fdf9bcd7478");

    // Run the model.
    // let result = replicate.run(version, inputs);

    // // Print the result.
    // match result {
    //     Ok(result) => println!("Success : {:?}", result.output),
    //     Err(e) => println!("Error : {}", e),
    // }

    // let mut prediction = replicate.predictions.create(version, inputs);
    // println!("Prediction : {:?}", prediction.status);
    // // let _ = prediction.cancel();
    // println!("Predictions : {:?}", prediction.status);
    // println!("Predictionss : {:?}", prediction.status);
    // let _ = prediction.reload();
    // println!("Prediction : {:?}", prediction.logs);

    // match prediction.wait() {
    //     Ok(result) => println!("Success : {:?}", result.output),
    //     Err(e) => println!("Error : {}", e),
    // }

    match replicate.predictions.list() {
        Ok(result) => println!("Success : {:?}", result),
        Err(e) => println!("Error : {}", e),
    }

    // match replicate
    //     .models
    //     .get(String::from("replicate"), String::from("hello-world"))
    // {
    //     Ok(result) => println!("Success : {:?}", result),
    //     Err(e) => println!("Error : {}", e),
    // };

    // match replicate
    //     .models
    //     .versions
    //     .list(String::from("replicate"), String::from("hello-world"))
    // {
    //     Ok(result) => println!("Success : {:?}", result),
    //     Err(e) => println!("Error : {}", e),
    // };

    // match replicate.models.versions.get(
    //     String::from("kvfrans"),
    //     String::from("clipdraw"),
    //     String::from("5797a99edc939ea0e9242d5e8c9cb3bc7d125b1eac21bda852e5cb79ede2cd9b"),
    // ) {
    //     Ok(result) => println!("Success : {:?}", result),
    //     Err(e) => println!("Error : {}", e),
    // }

    // match replicate.collection.get(String::from("audio-generation")) {
    //     Ok(result) => println!("Success : {:?}", result),
    //     Err(e) => println!("Error : {}", e),
    // }

    // match replicate.collection.list() {
    //     Ok(result) => println!("Success : {:?}", result),
    //     Err(e) => println!("Error : {}", e),
    // }
}

pub fn run<K: Serialize, V: Serialize>( &self, version: String, inputs: HashMap<K, V> ) -> Result<GetPrediction, Box<dyn Error>>

Run a model with the given inputs in a blocking manner.

Arguments

• version - The version of the model to run.
• inputs - The inputs to the model in the form of a HashMap.

Example

use replicate::Replicate;
let replicate = Replicate::new("api_key");

// Construct the inputs.
let mut inputs = std::collections::HashMap::new();
inputs.insert("prompt", "a  19th century portrait of a wombat gentleman");

let version = String::from("stability-ai/stable-diffusion:27b93a2413e7f36cd83da926f3656280b2931564ff050bf9575f1fdf9bcd7478");

// Run the model.
let result = replicate.run(version, inputs);

// Print the result.
match result {
   Ok(result) => println!("Success : {:?}", result.output),
  Err(e) => println!("Error : {}", e),
}

Errors

TODO : Add errors