transmutation 0.3.2

High-performance document conversion engine for AI/LLM embeddings - 27 formats supported
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
115
116
117
118
119
120
121
122

//! PDF conversion example
//!
//! This example demonstrates how to convert PDF files to Markdown.
//!
//! Usage:
//! ```bash
//! cargo run --example pdf_conversion --features pdf path/to/document.pdf
//! ```

#![allow(clippy::uninlined_format_args)]

use transmutation::{ConversionOptions, Converter, OutputFormat};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    tracing_subscriber::fmt::init();

    // Get PDF path from command line
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <pdf-file>", args[0]);
        eprintln!("Example: {} document.pdf", args[0]);
        std::process::exit(1);
    }

    let pdf_path = &args[1];
    println!("Converting PDF: {}", pdf_path);

    // Create converter
    let converter = Converter::new()?;

    // Example 1: Basic conversion to Markdown
    println!("\n=== Example 1: Basic PDF → Markdown ===");
    let result = converter
        .convert(pdf_path)
        .to(OutputFormat::Markdown {
            split_pages: false,
            optimize_for_llm: true,
        })
        .execute()
        .await?;

    println!("✓ Converted {} pages", result.page_count());
    println!("  Input size:  {} bytes", result.input_size());
    println!("  Output size: {} bytes", result.output_size());
    println!("  Duration:    {:?}", result.duration());
    println!(
        "  Compression: {:.1}%",
        (1.0 - result.output_size() as f64 / result.input_size() as f64) * 100.0
    );

    // Save to file
    result.save("data/output.md").await?;
    println!("  Saved to: data/output.md");

    // Example 2: Split by pages
    println!("\n=== Example 2: Split by Pages ===");
    let result = converter
        .convert(pdf_path)
        .to(OutputFormat::Markdown {
            split_pages: true,
            optimize_for_llm: true,
        })
        .execute()
        .await?;

    println!(
        "✓ Generated {} separate Markdown files",
        result.page_count()
    );
    result.save("output_pages/document.md").await?;
    println!("  Saved to: output_pages/document_page_*.md");

    // Example 3: Convert to JSON
    println!("\n=== Example 3: PDF → JSON ===");
    let result = converter
        .convert(pdf_path)
        .to(OutputFormat::Json {
            structured: true,
            include_metadata: true,
        })
        .execute()
        .await?;

    println!("✓ Converted to structured JSON");
    result.save("data/output.json").await?;
    println!("  Saved to: data/output.json");

    // Example 4: Custom options
    println!("\n=== Example 4: Custom Options ===");
    let options = ConversionOptions {
        split_pages: false,
        optimize_for_llm: true,
        preserve_layout: true,
        extract_tables: true,
        remove_headers_footers: true,
        normalize_whitespace: true,
        ..Default::default()
    };

    let result = converter
        .convert(pdf_path)
        .to(OutputFormat::Markdown {
            split_pages: false,
            optimize_for_llm: true,
        })
        .with_options(options)
        .execute()
        .await?;

    println!("✓ Converted with custom options");
    println!("  Pages: {}", result.page_count());
    println!("  Tables: {}", result.metadata.page_count);

    result.save("output_custom.md").await?;
    println!("  Saved to: output_custom.md");

    println!("\n✨ All examples completed successfully!");

    Ok(())
}