tinify 0.1.0

A high-performance Rust client for the Tinify API, providing image compression and optimization capabilities
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::error::Error;
use tinify::{S3Options, StoreOptions, Tinify};

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    println!("🧪 Tinify: Real Image Testing");
    println!("================================");

    // Test with provided API key
    let api_key = "XZmVxmxJxbx4PZbHyxwX74v8N0LLtvqq";
    let client = Tinify::new(api_key.to_string())?;
    println!("✅ Client initialized with provided API key");

    // Test 1: Basic compression with real image
    println!("\n🗜️  Test 1: Basic Compression");
    match client.source_from_file("test_real_image.png").await {
        Ok(source) => {
            println!("   ✅ Source created successfully");

            match source.to_buffer().await {
                Ok(compressed_data) => {
                    let original_size = tokio::fs::metadata("test_real_image.png").await?.len();
                    let compressed_size = compressed_data.len() as u64;
                    let savings =
                        ((original_size - compressed_size) as f64 / original_size as f64) * 100.0;

                    println!("   📊 Compression Results:");
                    println!(
                        "      Original: {} bytes ({:.1} KB)",
                        original_size,
                        original_size as f64 / 1024.0
                    );
                    println!(
                        "      Compressed: {} bytes ({:.1} KB)",
                        compressed_size,
                        compressed_size as f64 / 1024.0
                    );
                    println!("      Savings: {:.1}%", savings);

                    tokio::fs::write("compressed_real_image.png", compressed_data).await?;
                    println!("   💾 Saved compressed image");
                }
                Err(e) => println!("   ❌ Compression failed: {}", e),
            }
        }
        Err(e) => println!("   ❌ Source creation failed: {}", e),
    }

    // Test 2: S3 Storage (will fail with demo credentials but show proper behavior)
    println!("\n📦 Test 2: S3 Storage Attempt");
    match client.source_from_file("test_real_image.png").await {
        Ok(source) => {
            let s3_options = S3Options {
                service: "s3".to_string(),
                aws_access_key_id: "DEMO_ACCESS_KEY".to_string(),
                aws_secret_access_key: "DEMO_SECRET_KEY".to_string(),
                region: "us-east-1".to_string(),
                path: "test-bucket/real-image.png".to_string(),
                headers: None,
                acl: Some("public-read".to_string()),
            };

            match source.store(StoreOptions::S3(s3_options)).await {
                Ok(_) => println!("   ✅ S3 storage successful (unexpected)"),
                Err(e) => {
                    println!("   ❌ S3 storage failed (expected): {}", e);
                    println!(
                        "   💡 This demonstrates proper error handling with invalid credentials"
                    );
                }
            }
        }
        Err(e) => println!("   ❌ Source creation for S3 test failed: {}", e),
    }

    // Test 3: Format conversion
    println!("\n🎨 Test 3: Format Conversion");
    match client.source_from_file("test_real_image.png").await {
        Ok(source) => {
            use tinify::{ConvertOptions, ImageFormat};
            let convert_options = ConvertOptions {
                format: ImageFormat::Jpeg,
                background: Some("#FFFFFF".to_string()),
            };

            match source.convert(convert_options).await {
                Ok(mut result) => {
                    result.to_file("converted_real_image.jpg").await?;
                    println!("   ✅ Converted PNG to JPEG successfully");

                    if let Some(compression_count) = result.compression_count() {
                        println!("   📈 Compression count: {}", compression_count);
                    }
                }
                Err(e) => println!("   ❌ Format conversion failed: {}", e),
            }
        }
        Err(e) => println!("   ❌ Source creation for conversion failed: {}", e),
    }

    println!("\n🎉 Real Image Testing Complete!");
    println!("   This demonstrates that the library works correctly with real images");
    println!("   and the provided API key is functional for actual compression tasks.");

    // Clean up generated files (keep original for reference)
    let cleanup_files = ["compressed_real_image.png", "converted_real_image.jpg"];
    for file in cleanup_files {
        if tokio::fs::metadata(file).await.is_ok() {
            let _ = tokio::fs::remove_file(file).await;
        }
    }

    Ok(())
}