openai-api-rs 10.0.1

OpenAI API client library for Rust (unofficial)
Documentation 
1
2
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use serde::{Deserialize, Serialize};

use crate::impl_builder_methods;

#[derive(Debug, Serialize, Clone)]
pub struct CreateFineTuningJobRequest {
    pub model: String,
    pub training_file: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hyperparameters: Option<HyperParameters>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suffix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub validation_file: Option<String>,
}

impl CreateFineTuningJobRequest {
    pub fn new(model: String, training_file: String) -> Self {
        Self {
            model,
            training_file,
            hyperparameters: None,
            suffix: None,
            validation_file: None,
        }
    }
}

impl_builder_methods!(
    CreateFineTuningJobRequest,
    hyperparameters: HyperParameters,
    suffix: String,
    validation_file: String
);

#[derive(Debug, Serialize)]
pub struct ListFineTuningJobsRequest {
    // TODO pass as query params
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
}

impl ListFineTuningJobsRequest {
    pub fn new(_fine_tune_id: String) -> Self {
        Self {
            after: None,
            limit: None,
        }
    }
}

#[derive(Debug, Serialize)]
pub struct ListFineTuningJobEventsRequest {
    pub fine_tuning_job_id: String,
    // TODO pass as query params
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
}

impl ListFineTuningJobEventsRequest {
    pub fn new(fine_tuning_job_id: String) -> Self {
        Self {
            fine_tuning_job_id,
            after: None,
            limit: None,
        }
    }
}

#[derive(Debug, Serialize)]
pub struct RetrieveFineTuningJobRequest {
    pub fine_tuning_job_id: String,
}

impl RetrieveFineTuningJobRequest {
    pub fn new(fine_tuning_job_id: String) -> Self {
        Self { fine_tuning_job_id }
    }
}

#[derive(Debug, Serialize)]
pub struct CancelFineTuningJobRequest {
    pub fine_tuning_job_id: String,
}

impl CancelFineTuningJobRequest {
    pub fn new(fine_tuning_job_id: String) -> Self {
        Self { fine_tuning_job_id }
    }
}

#[derive(Debug, Deserialize, Serialize)]
pub struct FineTuningPagination<T> {
    pub object: String,
    pub data: Vec<T>,
    pub has_more: bool,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct FineTuningJobObject {
    pub id: String,
    pub created_at: i64,
    pub error: Option<FineTuningJobError>,
    pub fine_tuned_model: Option<String>,
    pub finished_at: Option<String>,
    pub hyperparameters: HyperParameters,
    pub model: String,
    pub object: String,
    pub organization_id: String,
    pub result_files: Vec<String>,
    pub status: String,
    pub trained_tokens: Option<i64>,
    pub training_file: String,
    pub validation_file: Option<String>,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct FineTuningJobError {
    pub code: String,
    pub message: String,
    pub param: Option<String>,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct FineTuningJobEvent {
    pub id: String,
    pub created_at: i64,
    pub level: String,
    pub message: String,
    pub object: String,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct HyperParameters {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub batch_size: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub learning_rate_multiplier: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub n_epochs: Option<String>,
}