omniparse 0.4.0

A Rust toolkit for detecting and extracting metadata, text, and content from various file formats
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

//! `omniparse models …` subcommand handlers.
//!
//! All real work happens in [`omniparse::ocr::ml`]; this module is a thin
//! presentation layer. When the binary is built without the `ocr-ml` feature
//! the subcommand still parses but emits a clear error.

use crate::cli::args::ModelsAction;

/// Dispatch a `models` subcommand. Returns an exit code (0 = success).
pub fn run(action: &ModelsAction) -> i32 {
    #[cfg(feature = "ocr-ml")]
    {
        match action {
            ModelsAction::Download { force } => download(*force),
            ModelsAction::Verify => verify(),
            ModelsAction::Path => print_path(),
            ModelsAction::List => list(),
        }
    }
    #[cfg(not(feature = "ocr-ml"))]
    {
        let _ = action;
        eprintln!(
            "omniparse: `models` subcommand requires the `ocr-ml` feature.\n\
             Rebuild with: cargo install omniparse --features ocr-ml"
        );
        2
    }
}

#[cfg(feature = "ocr-ml")]
fn download(force: bool) -> i32 {
    match omniparse::ocr::ml::prefetch_all(force) {
        Ok(paths) => {
            for p in &paths {
                println!("ok  {}", p.display());
            }
            0
        }
        Err(e) => {
            eprintln!("download failed: {e}");
            1
        }
    }
}

#[cfg(feature = "ocr-ml")]
fn verify() -> i32 {
    match omniparse::ocr::ml::verify_all() {
        Ok(()) => {
            println!("ok");
            0
        }
        Err(e) => {
            eprintln!("verify failed: {e}");
            1
        }
    }
}

#[cfg(feature = "ocr-ml")]
fn print_path() -> i32 {
    match omniparse::ocr::ml::model_dir() {
        Ok(p) => {
            println!("{}", p.display());
            0
        }
        Err(e) => {
            eprintln!("could not resolve cache dir: {e}");
            1
        }
    }
}

#[cfg(feature = "ocr-ml")]
fn list() -> i32 {
    let statuses = match omniparse::ocr::ml::list_models() {
        Ok(v) => v,
        Err(e) => {
            eprintln!("list failed: {e}");
            return 1;
        }
    };
    println!(
        "{:<25} {:>10}  {:<64}  {}",
        "NAME", "SIZE", "SHA256", "STATUS"
    );
    let mut all_ok = true;
    for s in &statuses {
        let size = s.size.map(format_size).unwrap_or_else(|| "-".to_string());
        let sha = s.sha256.as_deref().unwrap_or("-");
        let status = if s.size.is_none() {
            "missing"
        } else if s.ok {
            "ok"
        } else {
            all_ok = false;
            "mismatch"
        };
        println!("{:<25} {:>10}  {:<64}  {}", s.spec.name, size, sha, status);
    }
    if all_ok { 0 } else { 1 }
}

#[cfg(feature = "ocr-ml")]
fn format_size(bytes: u64) -> String {
    const KB: f64 = 1024.0;
    const MB: f64 = KB * 1024.0;
    let b = bytes as f64;
    if b >= MB {
        format!("{:.1}M", b / MB)
    } else if b >= KB {
        format!("{:.1}K", b / KB)
    } else {
        format!("{}B", bytes)
    }
}