Struct CreateBatchRequest

pub struct CreateBatchRequest {
    pub input_file_id: String,
    pub endpoint: String,
    pub completion_window: String,
    pub metadata: Option<Metadata>,
}

Fields

input_file_id: String

endpoint: String

completion_window: String

metadata: Option<Metadata>

Implementations

impl CreateBatchRequest

pub fn new( input_file_id: String, endpoint: String, completion_window: String, ) -> Self

Examples found in repository

examples/batch.rs (lines 23-27)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = OpenAIClient::new(env::var("OPENAI_API_KEY").unwrap().to_string());

    let req = FileUploadRequest::new(
        "examples/data/batch_request.json".to_string(),
        "batch".to_string(),
    );

    let result = client.upload_file(req).await?;
    println!("File id: {:?}", result.id);

    let input_file_id = result.id;
    let req = CreateBatchRequest::new(
        input_file_id.clone(),
        "/v1/chat/completions".to_string(),
        "24h".to_string(),
    );

    let result = client.create_batch(req).await?;
    println!("Batch id: {:?}", result.id);

    let batch_id = result.id;
    let result = client.retrieve_batch(batch_id.to_string()).await?;
    println!("Batch status: {:?}", result.status);

    // sleep 30 seconds
    println!("Sleeping for 30 seconds...");
    tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;

    let result = client.retrieve_batch(batch_id.to_string()).await?;

    let file_id = result.output_file_id.unwrap();
    let result = client.retrieve_file_content(file_id).await?;
    let s = match str::from_utf8(&result) {
        Ok(v) => v.to_string(),
        Err(e) => panic!("Invalid UTF-8 sequence: {}", e),
    };
    let json_value: Value = from_str(&s)?;
    let result_json = to_string_pretty(&json_value)?;

    let output_file_path = "examples/data/batch_result.json";
    let mut file = File::create(output_file_path)?;
    file.write_all(result_json.as_bytes())?;

    println!("File writed to {:?}", output_file_path);

    Ok(())
}

Trait Implementations

impl Debug for CreateBatchRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CreateBatchRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CreateBatchRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.