pub struct Prediction {
    pub parent: Client,
}

Fields§

§parent: Client

Implementations§

source§

impl Prediction

source

pub fn new(rep: Client) -> Self

source

pub fn create<K: Serialize, V: Serialize>( self, version: String, inputs: HashMap<K, V> ) -> PredictionClient

source

pub fn list(&self) -> Result<ListPredictions, Box<dyn Error>>

Examples found in repository?
examples/replicate.rs (line 34)
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
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),
    // }
}

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more