omniparse 0.2.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
118
119
120
121
122
123
124
125

//! Example client for the Omniparse web service
//!
//! This demonstrates how to interact with the web service programmatically.
//!
//! Run the server first:
//! ```bash
//! cargo run --example web_service
//! ```
//!
//! Then run this client:
//! ```bash
//! cargo run --example web_client
//! ```

use serde::Deserialize;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let client = reqwest::Client::new();
    let base_url = "http://localhost:3000";

    println!("🔌 Omniparse Web Service Client");
    println!("================================\n");

    // Test health check
    println!("1. Checking service health...");
    let health: HealthResponse = client
        .get(format!("{}/health", base_url))
        .send()
        .await?
        .json()
        .await?;
    println!("   Status: {}\n", health.status);

    // Parse a JSON file
    println!("2. Parsing JSON file...");
    let json_data = std::fs::read("test_data/text/sample.json")?;
    let form = reqwest::multipart::Form::new()
        .part("file", reqwest::multipart::Part::bytes(json_data)
            .file_name("sample.json"));
    
    let parse_response: ParseResponse = client
        .post(format!("{}/parse", base_url))
        .multipart(form)
        .send()
        .await?
        .json()
        .await?;
    
    println!("   Filename: {}", parse_response.filename);
    println!("   MIME Type: {}", parse_response.mime_type);
    println!("   Confidence: {:.2}", parse_response.detection_confidence);
    println!("   Metadata keys: {}", parse_response.metadata.as_object().map(|m| m.len()).unwrap_or(0));
    println!();

    // Detect file type
    println!("3. Detecting DOCX file type...");
    let docx_data = std::fs::read("test_data/document/sample.docx")?;
    let form = reqwest::multipart::Form::new()
        .part("file", reqwest::multipart::Part::bytes(docx_data)
            .file_name("sample.docx"));
    
    let detect_response: DetectionResponse = client
        .post(format!("{}/detect", base_url))
        .multipart(form)
        .send()
        .await?
        .json()
        .await?;
    
    println!("   Filename: {}", detect_response.filename);
    println!("   MIME Type: {}", detect_response.mime_type);
    println!("   Confidence: {:.2}", detect_response.confidence);
    println!("   Detected By: {}", detect_response.detected_by);
    println!();

    // Parse with metadata only
    println!("4. Parsing CSV with metadata only...");
    let csv_data = std::fs::read("test_data/text/sample.csv")?;
    let form = reqwest::multipart::Form::new()
        .part("file", reqwest::multipart::Part::bytes(csv_data)
            .file_name("sample.csv"));
    
    let metadata_response: ParseResponse = client
        .post(format!("{}/parse?metadata_only=true", base_url))
        .multipart(form)
        .send()
        .await?
        .json()
        .await?;
    
    println!("   Filename: {}", metadata_response.filename);
    println!("   MIME Type: {}", metadata_response.mime_type);
    println!("   Has content: {}", metadata_response.content.is_some());
    println!();

    println!("✅ All requests completed successfully!");

    Ok(())
}

// Response types (matching the server)

#[derive(Deserialize)]
struct HealthResponse {
    status: String,
}

#[derive(Deserialize)]
struct ParseResponse {
    filename: String,
    mime_type: String,
    detection_confidence: f32,
    metadata: serde_json::Value,
    content: Option<serde_json::Value>,
}

#[derive(Deserialize)]
struct DetectionResponse {
    filename: String,
    mime_type: String,
    confidence: f32,
    detected_by: String,
}