use crate::chunk::Chunk;
use crate::error::Error;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Mirror {
#[serde(rename = "@src")]
pub src: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Mirrors {
#[serde(rename = "mirror", default)]
pub items: Vec<Mirror>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct File {
#[serde(rename = "@name")]
pub name: String,
#[serde(rename = "@file_size")]
pub file_size: u64,
#[serde(rename = "@chunk_size")]
pub chunk_size: u32,
#[serde(rename = "@title")]
pub title: Option<String>,
#[serde(rename = "@family")]
pub family: Option<String>,
#[serde(rename = "@model_size")]
pub model_size: Option<String>,
#[serde(rename = "@quantization")]
pub quantization: Option<String>,
#[serde(rename = "@adaptation")]
pub adaptation: Option<String>,
#[serde(rename = "@parameters")]
pub parameters: Option<String>,
#[serde(rename = "@description")]
pub description: Option<String>,
#[serde(rename = "mirrors")]
pub mirrors: Option<Mirrors>,
#[serde(rename = "hash")]
pub hash: String,
}
impl File {
pub fn mirror_urls(&self) -> Vec<String> {
self.mirrors
.as_ref()
.map(|m| m.items.iter().map(|item| item.src.clone()).collect())
.unwrap_or_default()
}
pub fn last_chunk_size(&self) -> u32 {
let remainder = (self.file_size % self.chunk_size as u64) as u32;
if remainder == 0 {
self.chunk_size
} else {
remainder
}
}
pub fn decode_hashes(&self) -> Result<Vec<[u8; 32]>, Error> {
Chunk::decode_base64_hashes(&self.hash)
}
pub fn chunks(&self) -> Result<Vec<Chunk>, Error> {
let hashes = self.decode_hashes()?;
let chunk_size = self.chunk_size as u64;
let total = hashes.len();
let mut chunks = Vec::with_capacity(total);
for (i, expected_hash) in hashes.into_iter().enumerate() {
let offset = i as u64 * chunk_size;
let size = if i == total - 1 {
self.last_chunk_size() as u64
} else {
chunk_size
};
chunks.push(Chunk::new(i, offset, size, expected_hash));
}
Ok(chunks)
}
}