pdfni 0.2.0

Extract tables and Markdown from text-embedded PDFs, with a built-in pure-Rust PDF reader adapted from Mozilla pdf.js.
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! PDFから文書内容・表を抽出するCLI

use anyhow::Result;
use pdfni::{DetectMode, ExtractOptions, ExtractQuery, Region};
use std::env;
use std::io::{BufRead, IsTerminal};

fn usage() -> ! {
    eprintln!(
        "usage: pdfni [--output content|tables|doc] [--mode auto|ruled|borderless] [--pages 1,3-5] [--region L,T,R,B] [--detect-header-footer] [--password-stdin] <input.pdf> [output.json]"
    );
    std::process::exit(2);
}

enum OutputKind {
    Content,
    Tables,
    Doc,
}

// 矩形は top-down 表示座標
fn parse_region(s: &str) -> Option<Region> {
    let vals: Vec<f64> = s
        .split(',')
        .map(|t| t.trim().parse::<f64>())
        .collect::<std::result::Result<_, _>>()
        .ok()?;
    let &[left, top, right, bottom] = vals.as_slice() else {
        return None;
    };
    Some(Region::from_ltrb(left, top, right, bottom))
}

fn read_password_from_stdin() -> Result<String> {
    let stdin = std::io::stdin();
    if stdin.is_terminal() {
        eprintln!("--password-stdin was given but stdin is a TTY; pipe or redirect the password");
        std::process::exit(2);
    }
    let mut line = String::new();
    stdin.lock().read_line(&mut line)?;
    if line.ends_with('\n') {
        line.pop();
        if line.ends_with('\r') {
            line.pop();
        }
    }
    Ok(line)
}

fn main() -> Result<()> {
    let mut output_kind = OutputKind::Content;
    let mut mode = DetectMode::Auto;
    let mut detect_header_footer = false;
    let mut password_stdin = false;
    let mut query = ExtractQuery::default();
    let mut positional = Vec::new();
    let mut args = env::args().skip(1);
    while let Some(a) = args.next() {
        if a == "--output" {
            output_kind = match args.next().as_deref() {
                Some("content") => OutputKind::Content,
                Some("tables") => OutputKind::Tables,
                Some("doc") => OutputKind::Doc,
                _ => usage(),
            };
        } else if a == "--mode" {
            mode = match args.next().as_deref() {
                Some("auto") => DetectMode::Auto,
                Some("ruled") => DetectMode::Ruled,
                Some("borderless") => DetectMode::Borderless,
                _ => usage(),
            };
        } else if a == "--pages" {
            query.pages = match args.next().map(|s| s.parse()) {
                Some(Ok(sel)) => Some(sel),
                _ => usage(),
            };
        } else if a == "--region" {
            query.region = match args.next().as_deref().map(parse_region) {
                Some(Some(region)) => Some(region),
                _ => usage(),
            };
        } else if a == "--detect-header-footer" {
            detect_header_footer = true;
        } else if a == "--password-stdin" {
            password_stdin = true;
        } else {
            positional.push(a);
        }
    }
    let mut positional = positional.into_iter();
    let input = positional.next().unwrap_or_else(|| usage());
    let output = positional.next();
    if positional.next().is_some() {
        usage();
    }

    let password = if password_stdin {
        Some(read_password_from_stdin()?)
    } else {
        None
    };

    let options = ExtractOptions {
        mode,
        detect_header_footer,
        ..ExtractOptions::default()
    };
    let bytes = std::fs::read(&input)?;
    let out_text = match output_kind {
        OutputKind::Content => {
            let doc = pdfni::extract_content_from_bytes_with_query(
                &bytes,
                password.as_deref(),
                &options,
                &query,
            )?;
            serde_json::to_string_pretty(&doc)?
        }
        OutputKind::Tables => {
            let mut doc = pdfni::extract_from_bytes_with_query(
                &bytes,
                password.as_deref(),
                &options,
                &query,
            )?;
            doc.source = input.clone();
            serde_json::to_string_pretty(&doc)?
        }
        OutputKind::Doc => {
            let doc = pdfni::extract_document_from_bytes_with_query(
                &bytes,
                password.as_deref(),
                &options,
                &query,
            )?;
            serde_json::to_string_pretty(&doc)?
        }
    };

    match output {
        Some(out) => {
            std::fs::write(&out, out_text)?;
            eprintln!("=> {out}");
        }
        None => println!("{out_text}"),
    }
    Ok(())
}