peasy-compress

Async Rust client for the Peasy Compress API -- compress, archive, and extract files with ZIP, TAR, gzip, Brotli, and Zstandard. Built with reqwest, serde, and tokio.

Built from Peasy Tools, a comprehensive file compression toolkit offering free online tools for creating and extracting archives across multiple formats. The glossary covers compression algorithms from classic DEFLATE to modern Brotli and Zstandard, while guides compare archive formats and explain lossless vs lossy compression strategies.

Explore compression formats at peasytools.com -- ZIP, TAR, Gzip, and more.

Table of Contents

• Install
• Quick Start
• What You Can Do
  • Compression and Archive Tools
  • Browse Compression Reference Content
  • Search and Discovery
• API Client
  • Available Methods
• Learn More About Compression
• Also Available
• Peasy Developer Tools
• License

Install

[dependencies]
peasy-compress = "0.2.0"
tokio = { version = "1", features = ["full"] }

Or via cargo:

cargo add peasy-compress

Quick Start

use peasy_compress::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();

    // List available compression tools
    let tools = client.list_tools(&Default::default()).await?;
    for tool in &tools.results {
        println!("{}: {}", tool.name, tool.description);
    }

    Ok(())
}

What You Can Do

Compression and Archive Tools

File compression reduces storage costs and speeds up network transfers. Archive formats like ZIP and TAR bundle multiple files into a single container, while compression algorithms like DEFLATE, Brotli, and Zstandard reduce the size of the archived data. Understanding which format to use -- ZIP for cross-platform compatibility, TAR+gzip for Unix workflows, or Brotli for web content delivery -- is critical for choosing the right tool for each task.

use peasy_compress::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();

    // Fetch the ZIP compression tool details
    let tool = client.get_tool("zip-compress").await?;
    println!("Tool: {}", tool.name);           // ZIP compression tool
    println!("Category: {}", tool.category);   // Archive and compression category

    // List supported compression and archive formats
    let formats = client.list_formats(&Default::default()).await?;
    for fmt in &formats.results {
        println!(".{} -- {} ({})", fmt.extension, fmt.name, fmt.mime_type);
    }

    Ok(())
}

Learn more: ZIP Format Reference · TAR Format Reference · Archive Formats Compared

Browse Compression Reference Content

The compression glossary explains key concepts from basic archiving terminology to advanced algorithm details. Understanding the difference between lossless and lossy compression, how DEFLATE works under the hood, and when to choose Brotli over gzip helps developers make informed decisions about their compression pipelines.

// Browse compression glossary terms programmatically
let glossary = client.list_glossary(&peasy_compress::ListOptions {
    search: Some("gzip".into()),
    ..Default::default()
}).await?;
for term in &glossary.results {
    println!("{}: {}", term.term, term.definition); // Compression algorithm definition
}

// Read in-depth guides comparing archive formats
let guides = client.list_guides(&peasy_compress::ListGuidesOptions {
    category: Some("compression".into()),
    ..Default::default()
}).await?;
for guide in &guides.results {
    println!("{} ({})", guide.title, guide.audience_level); // Guide title and difficulty
}

Learn more: Archive Glossary · Brotli Glossary · Lossless vs Lossy Compression Guide

Search and Discovery

The unified search endpoint queries across all compression tools, glossary terms, guides, and supported file formats simultaneously. This is useful for building CLI tools, documentation search, or CI/CD integrations that need to find the right compression approach.

// Search across all compression tools, glossary, and guides
let results = client.search("zip", Some(20)).await?;
println!("Found {} tools, {} glossary terms",
    results.results.tools.len(),
    results.results.glossary.len()); // Cross-content compression search results

Learn more: TAR Glossary · Lossless Compression Glossary · Zstandard Glossary

API Client

The client wraps the Peasy Tools REST API with strongly-typed Rust structs using serde deserialization.

use peasy_compress::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    // Or with a custom base URL:
    // let client = Client::with_base_url("https://custom.example.com");

    // List tools with filters
    let opts = peasy_compress::ListOptions {
        page: Some(1),
        limit: Some(10),
        search: Some("zip".into()),
        ..Default::default()
    };
    let tools = client.list_tools(&opts).await?;

    // Get a specific tool
    let tool = client.get_tool("zip-compress").await?;
    println!("{}: {}", tool.name, tool.description);

    // Search across all content
    let results = client.search("zip", Some(20)).await?;
    println!("Found {} tools", results.results.tools.len());

    // Browse the glossary
    let glossary = client.list_glossary(&peasy_compress::ListOptions {
        search: Some("gzip".into()),
        ..Default::default()
    }).await?;
    for term in &glossary.results {
        println!("{}: {}", term.term, term.definition);
    }

    // Discover guides
    let guides = client.list_guides(&peasy_compress::ListGuidesOptions {
        category: Some("compression".into()),
        ..Default::default()
    }).await?;
    for guide in &guides.results {
        println!("{} ({})", guide.title, guide.audience_level);
    }

    // List format conversions
    let conversions = client.list_conversions(&peasy_compress::ListConversionsOptions {
        source: Some("zip".into()),
        ..Default::default()
    }).await?;

    Ok(())
}

Available Methods

Full API documentation at peasytools.com/developers/. OpenAPI 3.1.0 spec: peasytools.com/api/openapi.json.

Learn More About Compression

• Formats: ZIP · TAR · Gzip · All Formats
• Guides: Archive Formats Compared · Lossless vs Lossy Compression · All Guides
• Glossary: Archive · TAR · Brotli · Lossless Compression · Zstandard · All Terms
• API: REST API Docs · OpenAPI Spec

Also Available

Peasy Developer Tools

Part of the Peasy Tools open-source developer ecosystem.

License

MIT