[dependencies]
hurray-core = { path = "../hurray-core" }
hurray-io   = { path = "../hurray-io", features = ["tokio"] }
tokio       = { version = "1", features = ["full"] }

use hurray_core::{
    BufferHandle, DeviceTag, ElementType, LayoutDescriptor,
    Shape, SyncMode, TensorDescriptor, MIN_BUFFER_ALIGNMENT,
};
use hurray_io::file::{FileWriter, FileWriterOptions, KvValue};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Build a descriptor for a 4×4 float32 tensor (64 bytes)
    let handle = BufferHandle::new(
        64, MIN_BUFFER_ALIGNMENT, DeviceTag::Cpu, SyncMode::ProducerSynced,
    )?;
    let desc = TensorDescriptor::new(
        1, 0, ElementType::Float32, Shape::new(vec![4u64, 4])?,
        0, LayoutDescriptor::RowMajor, vec![handle],
        None, None, None, None,
    )?;
    let data: Vec<u8> = (0u8..64).collect();

    // Write to a file; sorted_index enables binary search by readers
    let file = tokio::fs::File::create("model.hrry").await?;
    let opts = FileWriterOptions { sorted_index: true, ..Default::default() };
    let mut writer = FileWriter::with_options(file, opts).await?;

    writer.write_tensor("layer0.weight", &desc, &[&data]).await?;

    writer.finish(vec![
        ("model".to_string(),  KvValue::String("demo-v1".to_string())),
        ("layers".to_string(), KvValue::Uint64(1)),
    ]).await?;

    println!("Wrote model.hrry");
    Ok(())
}

import hurray

tensor = hurray.Tensor(bytes(range(64)), hurray.float32, [4, 4])

hurray.save(
    "model.hrry",
    {"layer0.weight": tensor},
    kv={"model": "demo-v1", "layers": 1},
)
print("Wrote model.hrry")

use hurray_core::{
    BufferHandle, DeviceTag, ElementType, LayoutDescriptor, PerChannelAffine,
    QuantizationDescriptor, Shape, SyncMode, TensorDescriptor, MIN_BUFFER_ALIGNMENT,
};
use hurray_io::file::FileWriter;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let handle = |len: u64| {
    BufferHandle::new(len, MIN_BUFFER_ALIGNMENT, DeviceTag::Cpu, SyncMode::ProducerSynced)
};
let quant = QuantizationDescriptor::PerChannelAffine(PerChannelAffine::new_symmetric(0, 1)?);
let desc = TensorDescriptor::new(
    1, 0, ElementType::Int8, Shape::new(vec![2u64, 4])?, 0, LayoutDescriptor::RowMajor,
    vec![handle(8)?, handle(8)?], Some(quant.encode_to_vec()), None, None, None,
)?;
let (weight_data, scale_data) = (vec![0u8; 8], vec![0u8; 8]);
let mut writer = FileWriter::new(tokio::fs::File::create("quantized.hrry").await?).await?;
writer.write_tensor("q_layer", &desc, &[&weight_data, &scale_data]).await?;
Ok(())
}

import struct
import hurray

weight_data = bytes(16)                            # 4x4 int8 weights
scale_data = struct.pack("4f", *[0.02] * 4)        # one float32 scale per row

# A tensor carries its own buffers, so a multi-buffer one saves like any other.
quantized = hurray.Tensor(
    weight_data,
    hurray.dtype.int8,
    [4, 4],
    aux_buffers=[scale_data],
    quantization=hurray.PerChannelAffine.symmetric(axis=0, scale_buffer_index=1),
)
hurray.save("quantized.hrry", {"q_layer": quantized})

use hurray_io::file::{FileReader, KvValue};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let file = tokio::fs::File::open("model.hrry").await?;
    let mut reader = FileReader::open(file).await?;

    // List all tensors (in index order — sorted if SORTED_INDEX was set)
    println!("tensors: {:?}", reader.tensor_names().collect::<Vec<_>>());

    // Read KV metadata
    for (key, value) in reader.kv() {
        println!("{key} = {value:?}");
    }

    // Load one tensor by name — seeks directly, skips others
    let tensor = reader.read_tensor("layer0.weight").await?;
    println!("shape: {:?}", tensor.descriptor.shape);
    println!("buffer: {} bytes", tensor.buffers[0].len());

    Ok(())
}

import hurray

# Every tensor in the file, by name.
tensors = hurray.load("model.hrry")
print("tensors:", sorted(tensors))

# The KV metadata section.
for key, value in hurray.load_kv("model.hrry").items():
    print(f"{key} = {value!r}")

# One tensor by name — seeks directly, skips the others.
weight = hurray.load("model.hrry", names=["layer0.weight"])["layer0.weight"]
print("shape:", weight.shape)
print("buffer:", weight.buffer_handles[0].byte_size, "bytes")

use hurray_io::file::FileReader;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut reader = FileReader::open(tokio::fs::File::open("model.hrry").await?).await?;
let desc = reader.read_descriptor("layer0.weight").await?;
println!("element type: {:?}", desc.element_type);
Ok(())
}

import hurray

# Python has no descriptor-only read: `load` returns tensors, whose metadata is
# already on the object. Naming one tensor is how you avoid paying for the rest.
weight = hurray.load("model.hrry", names=["layer0.weight"])["layer0.weight"]
print("element type:", weight.dtype.name)

[ 64-byte file header  ]  magic "HRRYFILE", version, flags, alignment
[ Tensor region        ]  per tensor: descriptor → pad → buffer(s) → pad
[ KV section           ]  optional; count + (key, value) pairs
[ Index section        ]  count + (name, offsets, lengths, flags) entries
[ 40-byte trailer      ]  index_offset, index_length, kv_offset, kv_length,
                          index_crc32c, _reserved, magic "HRRY"

cargo run --example file_roundtrip -p hurray-io