dataload

A flexible Rust library for loading CSV and Excel files into Polars DataFrames.

Features

• Automatic file type detection via magic bytes and file extensions
• Smart delimiter detection for CSV files (comma, tab, semicolon, pipe)
• Excel support for xlsx, xls, xlsm, xlsb, and ods formats
• Builder-pattern API for flexible configuration
• Feature flags to minimize dependencies

Installation

Add to your Cargo.toml:

[dependencies]

dataload = "0.1"

To disable Excel support (reduces compile time and dependencies):

[dependencies]

dataload = { version = "0.1", default-features = false, features = ["csv"] }

Quick Start

use dataload::{DataLoader, load_file, load_bytes};
use std::path::Path;

// Simple one-liner
let df = load_file(Path::new("data.csv"))?;

// From bytes
let csv_data = b"name,age\nAlice,30\nBob,25";
let df = load_bytes(csv_data, "data.csv")?;

// With custom options
let df = DataLoader::new()
    .with_delimiter(dataload::Delimiter::Tab)
    .with_header(false)
    .with_skip_rows(1)
    .with_max_rows(Some(1000))
    .load_file(Path::new("data.tsv"))?;

CSV Loading

The library automatically detects the delimiter by analyzing the file content:

use dataload::load_bytes;

// Auto-detects comma delimiter
let df = load_bytes(b"a,b,c\n1,2,3", "data.csv")?;

// Auto-detects tab delimiter
let df = load_bytes(b"a\tb\tc\n1\t2\t3", "data.tsv")?;

// Auto-detects semicolon delimiter
let df = load_bytes(b"a;b;c\n1;2;3", "data.csv")?;

Or specify a delimiter explicitly:

use dataload::{DataLoader, Delimiter};

let df = DataLoader::new()
    .with_delimiter(Delimiter::Pipe)
    .load_bytes(b"a|b|c\n1|2|3", "data.txt")?;

Excel Loading

use dataload::DataLoader;
use std::path::Path;

// Load first sheet (default)
let df = DataLoader::new()
    .load_file(Path::new("report.xlsx"))?;

// Load specific sheet by name
let df = DataLoader::new()
    .with_sheet_name("Sales Data")
    .load_file(Path::new("report.xlsx"))?;

// Load specific sheet by index (0-based)
let df = DataLoader::new()
    .with_sheet_index(2)
    .load_file(Path::new("report.xlsx"))?;

// List available sheets
let sheets = dataload::list_sheets(&file_bytes)?;

Configuration Options

Error Handling

All operations return Result<T, DataLoadError>:

use dataload::{load_file, DataLoadError};
use std::path::Path;

match load_file(Path::new("data.csv")) {
    Ok(df) => println!("Loaded {} rows", df.height()),
    Err(DataLoadError::Io(e)) => eprintln!("File error: {e}"),
    Err(DataLoadError::UnsupportedFileType(ext)) => eprintln!("Unknown type: {ext}"),
    Err(e) => eprintln!("Error: {e}"),
}

Feature Flags

License

Licensed under Apache License, Version 2.0

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.