use serde::{Deserialize, Serialize};
#[derive(Debug, Deserialize)]
pub struct Choice {
pub text: String,
pub finish_reason: String,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct Usage {
pub prompt_tokens: u32,
pub completion_tokens: u32,
pub total_tokens: u32,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CompletionRequestInfo {
#[serde(skip_serializing)]
pub object: String,
#[serde(skip_serializing)]
pub choices: Vec<Choice>,
#[serde(skip_deserializing)]
pub prompt: String,
pub model: String,
#[serde(skip_deserializing)]
temperature: f32,
#[serde(skip_deserializing)]
max_tokens: u32,
#[serde(skip_serializing)]
pub usage: Usage,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Message {
pub role: String,
pub content: String,
}
#[derive(Serialize, Debug, Deserialize)]
#[serde(tag = "t")]
pub struct ChatChoice {
index: u32,
pub message: Message,
pub finish_reason: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ImageURL {
pub url: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ImageRequestInfo {
created: u64,
pub data: Vec<ImageURL>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ChatRequestInfo {
id: String,
pub object: String,
created: u64,
pub model: String,
pub usage: Usage,
pub choices: Vec<ChatChoice>,
}
impl CompletionRequestInfo {
pub fn new(
prompt: &str,
model: &str,
temperature: f32,
max_tokens: u32,
) -> Self {
Self {
choices: Vec::new(),
usage: Usage {
prompt_tokens: 0,
completion_tokens: 0,
total_tokens: 0,
},
object: String::new(),
prompt: prompt.to_string(),
model: model.to_string(),
temperature,
max_tokens,
}
}
}
#[derive(Debug, Serialize, Deserialize)]
struct Permission {
id: String,
object: String,
created: u64,
allow_create_engine: bool,
allow_sampling: bool,
allow_logprobs: bool,
allow_search_indices: bool,
allow_view: bool,
allow_fine_tuning: bool,
organization: String,
group: Option<String>,
is_blocking: bool,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Model {
id: String,
object: String,
created: u64,
owned_by: String,
permission: Vec<Permission>,
pub root: String,
parent: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ModelReturned {
object: String,
pub data: Vec<Model>,
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ModelExampleData;
#[test]
fn models_from_json() {
let model_data = ModelExampleData::new();
let json_data: String = model_data.json;
let v: ModelReturned =
match serde_json::from_str(json_data.as_str()) {
Ok(v) => v,
Err(err) => panic!("{err}"),
};
eprintln!("{:?}", &v);
assert!(!v.data.is_empty());
}
}
#[derive(Debug, Serialize, Deserialize)]
struct ModelData {
id: String,
}
#[derive(Debug, Serialize, Deserialize)]
struct ModelRequestInfo {
data: Vec<ModelData>,
}