Struct Pipeline 

pub struct Pipeline { /* private fields */ }

A reusable PDF pipeline: the layout model is loaded once and reused across documents; OCR loads lazily the first time a scanned page is seen.

Implementations

impl Pipeline

pub fn new() -> Result<Self, PdfError>

Load the layout model (the only always-required model).

Examples found in repository

examples/snapshot.rs (line 50)

fn main() {
    let mut args = std::env::args().skip(1);
    let root = PathBuf::from(args.next().expect("usage: snapshot <root> <outdir>"));
    let outdir = PathBuf::from(args.next().expect("usage: snapshot <root> <outdir>"));

    let mut pdfs = Vec::new();
    find_pdfs(&root, &mut pdfs);

    let mut pipeline = Pipeline::new().expect("load pipeline");
    let (mut ok, mut err) = (0u32, 0u32);
    for pdf in &pdfs {
        let rel = pdf.strip_prefix(&root).unwrap_or(pdf);
        let name = pdf.file_name().unwrap().to_string_lossy().to_string();
        let md = match std::fs::read(pdf)
            .map_err(|e| format!("read: {e}"))
            .and_then(|bytes| {
                let ext = pdf.extension().and_then(|e| e.to_str()).unwrap_or("");
                let result = if ext == "gz" {
                    fleischwolf_pdf::convert_mets_gbs(&bytes, &name)
                } else if IMAGE_EXTS.contains(&ext) {
                    pipeline.convert_image(&bytes, &name)
                } else {
                    pipeline.convert(&bytes, None, &name)
                };
                result
                    .map(|d| d.export_to_markdown())
                    .map_err(|e| e.to_string())
            }) {
            Ok(md) => {
                ok += 1;
                md
            }
            Err(e) => {
                err += 1;
                eprintln!("ERR {}: {e}", rel.display());
                format!("ERROR: {e}\n")
            }
        };
        // Groundtruth naming keeps the source extension: `<file>.<ext>.md`.
        let mut dest = outdir.join(rel).into_os_string();
        dest.push(".md");
        let dest = PathBuf::from(dest);
        std::fs::create_dir_all(dest.parent().unwrap()).expect("mkdir");
        std::fs::write(&dest, md).expect("write snapshot");
    }
    eprintln!("snapshots: {} ok, {} error, {} total", ok, err, pdfs.len());
}

pub fn convert( &mut self, bytes: &[u8], password: Option<&str>, name: &str, ) -> Result<DoclingDocument, PdfError>

Convert a PDF (bytes) to a DoclingDocument via the discriminative pipeline: pdfium text cells (or OCR for scanned pages) + per-page layout detection, assembled in reading order. Errors are detailed and surfaced.

Examples found in repository

examples/snapshot.rs (line 64)

fn main() {
    let mut args = std::env::args().skip(1);
    let root = PathBuf::from(args.next().expect("usage: snapshot <root> <outdir>"));
    let outdir = PathBuf::from(args.next().expect("usage: snapshot <root> <outdir>"));

    let mut pdfs = Vec::new();
    find_pdfs(&root, &mut pdfs);

    let mut pipeline = Pipeline::new().expect("load pipeline");
    let (mut ok, mut err) = (0u32, 0u32);
    for pdf in &pdfs {
        let rel = pdf.strip_prefix(&root).unwrap_or(pdf);
        let name = pdf.file_name().unwrap().to_string_lossy().to_string();
        let md = match std::fs::read(pdf)
            .map_err(|e| format!("read: {e}"))
            .and_then(|bytes| {
                let ext = pdf.extension().and_then(|e| e.to_str()).unwrap_or("");
                let result = if ext == "gz" {
                    fleischwolf_pdf::convert_mets_gbs(&bytes, &name)
                } else if IMAGE_EXTS.contains(&ext) {
                    pipeline.convert_image(&bytes, &name)
                } else {
                    pipeline.convert(&bytes, None, &name)
                };
                result
                    .map(|d| d.export_to_markdown())
                    .map_err(|e| e.to_string())
            }) {
            Ok(md) => {
                ok += 1;
                md
            }
            Err(e) => {
                err += 1;
                eprintln!("ERR {}: {e}", rel.display());
                format!("ERROR: {e}\n")
            }
        };
        // Groundtruth naming keeps the source extension: `<file>.<ext>.md`.
        let mut dest = outdir.join(rel).into_os_string();
        dest.push(".md");
        let dest = PathBuf::from(dest);
        std::fs::create_dir_all(dest.parent().unwrap()).expect("mkdir");
        std::fs::write(&dest, md).expect("write snapshot");
    }
    eprintln!("snapshots: {} ok, {} error, {} total", ok, err, pdfs.len());
}

pub fn convert_image( &mut self, bytes: &[u8], name: &str, ) -> Result<DoclingDocument, PdfError>

Convert a standalone image (PNG/JPEG/TIFF/WebP/…) as a single page — docling routes images through the same layout+OCR pipeline as a PDF page.

Examples found in repository

examples/snapshot.rs (line 62)

fn main() {
    let mut args = std::env::args().skip(1);
    let root = PathBuf::from(args.next().expect("usage: snapshot <root> <outdir>"));
    let outdir = PathBuf::from(args.next().expect("usage: snapshot <root> <outdir>"));

    let mut pdfs = Vec::new();
    find_pdfs(&root, &mut pdfs);

    let mut pipeline = Pipeline::new().expect("load pipeline");
    let (mut ok, mut err) = (0u32, 0u32);
    for pdf in &pdfs {
        let rel = pdf.strip_prefix(&root).unwrap_or(pdf);
        let name = pdf.file_name().unwrap().to_string_lossy().to_string();
        let md = match std::fs::read(pdf)
            .map_err(|e| format!("read: {e}"))
            .and_then(|bytes| {
                let ext = pdf.extension().and_then(|e| e.to_str()).unwrap_or("");
                let result = if ext == "gz" {
                    fleischwolf_pdf::convert_mets_gbs(&bytes, &name)
                } else if IMAGE_EXTS.contains(&ext) {
                    pipeline.convert_image(&bytes, &name)
                } else {
                    pipeline.convert(&bytes, None, &name)
                };
                result
                    .map(|d| d.export_to_markdown())
                    .map_err(|e| e.to_string())
            }) {
            Ok(md) => {
                ok += 1;
                md
            }
            Err(e) => {
                err += 1;
                eprintln!("ERR {}: {e}", rel.display());
                format!("ERROR: {e}\n")
            }
        };
        // Groundtruth naming keeps the source extension: `<file>.<ext>.md`.
        let mut dest = outdir.join(rel).into_os_string();
        dest.push(".md");
        let dest = PathBuf::from(dest);
        std::fs::create_dir_all(dest.parent().unwrap()).expect("mkdir");
        std::fs::write(&dest, md).expect("write snapshot");
    }
    eprintln!("snapshots: {} ok, {} error, {} total", ok, err, pdfs.len());
}