docling-rs 2.2.2__tar.gz → 2.2.3__tar.gz

{docling_rs-2.2.2 → docling_rs-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-rs
-Version: 2.2.2
+Version: 2.2.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling"
 description = "DocumentConverter and format backends for docling.rs (a Rust port of docling)."
-version = "2.2.2"
+version = "2.2.3"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"
@@ -79,9 +79,9 @@ headless_chrome = { version = "1.0", optional = true }
 # O_EXCL temp file with an unpredictable name for the browser pre-render page
 # (avoids a predictable /tmp path a local attacker could pre-plant a symlink at).
 tempfile = { version = "3", optional = true }
-docling-asr = { path = "../docling-asr", version = "2.2.2", optional = true }
-docling-core = { path = "../docling-core", version = "2.2.2" }
-docling-pdf = { path = "../docling-pdf", version = "2.2.2", optional = true, default-features = false }
+docling-asr = { path = "../docling-asr", version = "2.2.3", optional = true }
+docling-core = { path = "../docling-core", version = "2.2.3" }
+docling-pdf = { path = "../docling-pdf", version = "2.2.3", optional = true, default-features = false }
 image = { version = "0.25", default-features = false, features = ["png", "jpeg", "gif", "bmp", "tiff", "webp"] }
 mail-parser = "0.11"
 pulldown-cmark = { version = "0.13.4", default-features = false }

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling/src/backend/cfb.rs

@@ -554,9 +554,12 @@ mod tests {
             "/../../tests/data/doc/sources/docx_lists.doc"
         ))
         .unwrap();
-        // Every truncation point must fail cleanly, never panic.
+        // Every truncation point must fail cleanly — `None`, never a panic.
         for cut in [8, 76, 512, 700] {
-            let _ = CompoundFile::open(&data[..cut.min(data.len())]);
+            assert!(
+                CompoundFile::open(&data[..cut.min(data.len())]).is_none(),
+                "cut at {cut}"
+            );
         }
     }
 }

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling/src/backend/doc.rs

@@ -2396,42 +2396,6 @@ mod tests {
         assert_eq!(furniture, [("page_header", "MARK_HEADER_TEXTBOX_TEXT")]);
     }
 
-    #[test]
-    fn extracts_headings_lists_and_paragraphs() {
-        let doc = DocBackend
-            .convert(&fixture("docx_lists.doc"))
-            .expect("converts");
-        let headings = doc
-            .nodes
-            .iter()
-            .filter(|n| matches!(n, Node::Heading { .. }))
-            .count();
-        let lists = doc
-            .nodes
-            .iter()
-            .filter(|n| matches!(n, Node::ListItem { .. }))
-            .count();
-        assert!(headings > 0, "expected headings: {:?}", doc.nodes);
-        assert!(lists > 0, "expected list items: {:?}", doc.nodes);
-    }
-
-    #[test]
-    fn extracts_tables_with_cells() {
-        let doc = DocBackend
-            .convert(&fixture("docx_rich_tables_01.doc"))
-            .expect("converts");
-        let tables: Vec<&Table> = doc
-            .nodes
-            .iter()
-            .filter_map(|n| match n {
-                Node::Table(t) => Some(t),
-                _ => None,
-            })
-            .collect();
-        assert!(!tables.is_empty(), "expected tables: {:?}", doc.nodes);
-        assert!(tables[0].rows.len() > 1 && tables[0].rows[0].len() > 1);
-    }
-
     /// #567: prose is Markdown-escaped like the DOCX backend's — `OBJ_DIR`
     /// becomes `OBJ\_DIR` in the Markdown (the reporter's Word 2.133 and
     /// DOCX outputs), and the JSON export restores the raw text.

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling/src/backend/html.rs

@@ -2240,14 +2240,37 @@ fn is_row_header(cells: &[ElementRef]) -> bool {
 /// HTML5's "rowspan=0 spans to the end of the row group" is not modelled,
 /// the cell simply keeps one slot).
 fn span_attr(cell: ElementRef, name: &str) -> usize {
-    let Some(v) = cell.value().attr(name) else {
+    let limit = if name == "colspan" {
+        MAX_COLSPAN
+    } else {
+        MAX_ROWSPAN
+    };
+    span_value(cell.value().attr(name), limit)
+}
+
+/// docling's `MAX_COLSPAN` / `MAX_ROWSPAN` (`backend/utils/table_spans.py`,
+/// HTML's own limits): a declared span past them is clamped, so a
+/// `colspan="999999999"` cannot make the grid builder allocate billions of
+/// slots.
+pub(super) const MAX_COLSPAN: usize = 1000;
+pub(super) const MAX_ROWSPAN: usize = 65_534;
+
+/// One span attribute as `_get_cell_spans` reads it — [`span_attr`]'s rule,
+/// clamped to `[1, limit]` (`clamp_span`); a digit run too long to parse is
+/// over every limit, so it is the limit. Shared with the JSON item tree
+/// (`html_tree`), which must see the same grid.
+pub(super) fn span_value(raw: Option<&str>, limit: usize) -> usize {
+    let Some(v) = raw else {
         return 1;
     };
     if !v.starts_with(|c: char| c.is_numeric()) {
         return 1;
     }
     let digits: String = v.chars().take_while(|c| c.is_ascii_digit()).collect();
-    digits.parse::<usize>().map_or(1, |n| n.max(1))
+    match digits.trim_start_matches('0') {
+        "" => 1,
+        d => d.parse::<usize>().map_or(limit, |n| n.clamp(1, limit)),
+    }
 }
 
 /// Render a table cell to Markdown. docling treats a cell as "rich" (and

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling/src/backend/html_tree.rs

@@ -303,18 +303,15 @@ fn has_list_ancestor(elem: NodeRef<'_, HtmlNode>, boundary: NodeRef<'_, HtmlNode
 }
 
 /// upstream's `_get_cell_spans`: `colspan` / `rowspan`, each the leading
-/// digit run when the attribute starts with a digit, else 1 (so `"0"` is 0).
+/// digit run when the attribute starts with a digit, else 1, clamped to
+/// `[1, MAX_*SPAN]` — the same reading as the Markdown grid (`html.rs`), so
+/// a `rowspan="0"` keeps its slot in the JSON too (docling#4287, 2.129).
 fn cell_spans(cell: ElementRef) -> (usize, usize) {
-    let num = |attr: &str| -> usize {
-        let raw = cell.value().attr(attr).unwrap_or("1");
-        if raw.starts_with(|c: char| c.is_ascii_digit()) {
-            let digits: String = raw.chars().take_while(|c| c.is_ascii_digit()).collect();
-            digits.parse().unwrap_or(1)
-        } else {
-            1
-        }
-    };
-    (num("colspan"), num("rowspan"))
+    use super::html::{span_value, MAX_COLSPAN, MAX_ROWSPAN};
+    (
+        span_value(cell.value().attr("colspan"), MAX_COLSPAN),
+        span_value(cell.value().attr("rowspan"), MAX_ROWSPAN),
+    )
 }
 
 /// An `href` as docling's `AnnotatedText.hyperlink` serializes it: a URL
@@ -1968,11 +1965,15 @@ mod tests {
     #[test]
     fn cell_spans_follow_get_cell_spans() {
         let html = Html::parse_fragment(
-            r#"<table><tr><td colspan="3x" rowspan="0">a</td><td rowspan="x2">b</td></tr></table>"#,
+            r#"<table><tr><td colspan="3x" rowspan="0">a</td><td rowspan="x2">b</td>
+               <td colspan="99999999999999999999999" rowspan="70000">c</td></tr></table>"#,
         );
         let cells: Vec<ElementRef> = html.select(sel!("td")).collect();
-        assert_eq!(cell_spans(cells[0]), (3, 0));
+        // A zero span keeps one slot (docling#4287), not none.
+        assert_eq!(cell_spans(cells[0]), (3, 1));
         assert_eq!(cell_spans(cells[1]), (1, 1));
+        // Past HTML's limits: clamped, even past `usize`.
+        assert_eq!(cell_spans(cells[2]), (1000, 65_534));
     }
 
     /// The shape upstream gives a small page: the `<title>` and the prelude

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling/src/backend/mhtml.rs

@@ -641,17 +641,6 @@ mod tests {
         assert!(md(data).contains("Привет, мир"));
     }
 
-    #[test]
-    fn real_blink_fixture_decodes_quoted_printable_html() {
-        // docling's `tests/data/mhtml/sources/example.mhtml`, mirrored (#386).
-        let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../../tests/data/mhtml/sources/example.mhtml");
-        let bytes = std::fs::read(path).expect("mirrored upstream fixture");
-        let markdown = md(bytes);
-        assert!(markdown.contains("# Example Domain"), "{markdown}");
-        assert!(markdown.contains("[Learn more](https://iana.org/domains/example)"));
-    }
-
     #[test]
     fn embedded_images_resolve_by_location_and_cid() {
         let parts = png_part(

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling/src/backend/ppt.rs

@@ -792,50 +792,6 @@ mod tests {
     use super::*;
     use crate::InputFormat;
 
-    fn fixture(name: &str) -> SourceDocument {
-        let path = format!(
-            "{}/../../tests/data/ppt/sources/{name}",
-            env!("CARGO_MANIFEST_DIR")
-        );
-        let bytes = std::fs::read(&path).expect("fixture exists");
-        SourceDocument::from_bytes(name, InputFormat::Ppt, bytes)
-    }
-
-    #[test]
-    fn extracts_slide_titles_and_text() {
-        let doc = PptBackend
-            .convert(&fixture("powerpoint_sample.ppt"))
-            .expect("converts");
-        let headings = doc
-            .nodes
-            .iter()
-            .filter(|n| matches!(n, Node::Heading { .. }))
-            .count();
-        assert!(headings > 0, "expected slide titles: {:?}", doc.nodes);
-    }
-
-    #[test]
-    fn reconstructs_grouped_shapes_into_a_table() {
-        let doc = PptBackend
-            .convert(&fixture("powerpoint_sample.ppt"))
-            .expect("converts");
-        let tables: Vec<&Table> = doc
-            .nodes
-            .iter()
-            .filter_map(|n| match n {
-                Node::Table(t) => Some(t),
-                _ => None,
-            })
-            .collect();
-        assert!(!tables.is_empty(), "expected a reconstructed table");
-        let t = tables[0];
-        assert!(
-            t.rows.len() >= 2 && t.rows[0].len() >= 2,
-            "grid too small: {:?}",
-            t.rows
-        );
-    }
-
     #[test]
     fn grid_table_rejects_a_column_of_shapes() {
         // Four stacked shapes (one column) must NOT read as a table.

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling/src/backend/pptx.rs

@@ -1299,52 +1299,6 @@ fn cell_text(tc: XmlNode) -> String {
 fn descendant<'a, 'input>(node: XmlNode<'a, 'input>, name: &str) -> Option<XmlNode<'a, 'input>> {
     node.descendants().find(|n| n.has_tag_name(name))
 }
-#[cfg(test)]
-mod chart_tests {
-    use super::*;
-    use crate::backend::DeclarativeBackend;
-    use crate::{InputFormat, SourceDocument};
-
-    /// docling PR #3794: a native chart frame becomes a classified chart with
-    /// its cached data grid and the chart title as the caption.
-    #[test]
-    fn native_chart_yields_classified_data_grid() {
-        let path = format!(
-            "{}/../../tests/data/pptx/sources/pptx_chart.pptx",
-            env!("CARGO_MANIFEST_DIR")
-        );
-        let bytes = std::fs::read(&path).expect("fixture exists");
-        let src = SourceDocument::from_bytes("c.pptx", InputFormat::Pptx, bytes);
-        let doc = PptxBackend.convert(&src).expect("converts");
-        let chart = doc
-            .nodes
-            .iter()
-            // Slide content hangs off the slide's own group (#402).
-            .flat_map(|n| match n {
-                Node::Group { children, .. } => children.as_slice(),
-                other => std::slice::from_ref(other),
-            })
-            .find_map(|n| match n {
-                Node::Chart {
-                    kind,
-                    table,
-                    caption,
-                    ..
-                } => Some((kind.clone(), table.clone(), caption.clone())),
-                _ => None,
-            })
-            .expect("a chart node");
-        assert_eq!(chart.0, "bar_chart");
-        assert_eq!(
-            chart.2.as_deref(),
-            Some("Wild Duck Observations by Year"),
-            "chart title as caption"
-        );
-        assert_eq!(chart.1.rows[0][1], "Freshwater Ducks");
-        assert_eq!(chart.1.rows[1], vec!["2019", "120", "80"]);
-    }
-}
-
 #[cfg(test)]
 mod list_marker_tests {
     use super::{list_kind, Placeholder};

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling/src/backend/quattro.rs

@@ -707,26 +707,4 @@ mod tests {
         assert_eq!(g[&(3, 1)], "1.5");
         assert_eq!(g[&(4, 1)], "-2");
     }
-
-    #[test]
-    fn corpus_samples_convert() {
-        let dir =
-            std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/data/quattro/sources");
-        for (f, needle) in [
-            ("formatcorpus_ksbase.wq1", "OBSERV"),
-            (
-                "formatcorpus_ks4000.wq2",
-                "SATURATED HYDRAULIC CONDUCTIVITY",
-            ),
-            ("formatcorpus_test.wb1", "| X |"),
-            ("formatcorpus_test.wb2", "| X |"),
-            ("formatcorpus_test.wb3", "This is an example spreadsheet"),
-            ("formatcorpus_test.qpw", "This is an example spreadsheet"),
-        ] {
-            let bytes = std::fs::read(dir.join(f)).unwrap();
-            let doc = convert(bytes).unwrap_or_else(|e| panic!("{f}: {e}"));
-            let md = md(&doc);
-            assert!(md.contains(needle), "{f}:\n{md}");
-        }
-    }
 }

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling/src/backend/wps.rs

@@ -1105,21 +1105,4 @@ mod tests {
             .to_string();
         assert!(e.contains("not a Microsoft Works document"), "{e}");
     }
-
-    #[test]
-    fn libreoffice_fixtures_parse() {
-        // LibreOffice's libwps smoke files are near-empty documents; they
-        // must at least parse and detect their generation.
-        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/data/works/sources");
-        for f in [
-            "works2_dos.wps",
-            "works3.wps",
-            "works45.wps",
-            "works5.wps",
-            "works6.wps",
-        ] {
-            let bytes = std::fs::read(dir.join(f)).unwrap();
-            convert(bytes).unwrap_or_else(|e| panic!("{f}: {e}"));
-        }
-    }
 }

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling/src/backend/xls.rs

@@ -124,28 +124,6 @@ mod tests {
     use super::*;
     use crate::InputFormat;
 
-    fn fixture(name: &str) -> SourceDocument {
-        let path = format!(
-            "{}/../../tests/data/xls/sources/{name}",
-            env!("CARGO_MANIFEST_DIR")
-        );
-        let bytes = std::fs::read(&path).expect("fixture exists");
-        SourceDocument::from_bytes(name, InputFormat::Xls, bytes)
-    }
-
-    #[test]
-    fn parses_xls_tables_like_the_xlsx_twin() {
-        let doc = XlsBackend::default()
-            .convert(&fixture("xlsx_01.xls"))
-            .expect("converts");
-        let tables: Vec<_> = doc
-            .nodes
-            .iter()
-            .filter(|n| matches!(n, Node::Table(_)))
-            .collect();
-        assert!(!tables.is_empty(), "expected tables, got: {:?}", doc.nodes);
-    }
-
     #[test]
     fn garbage_is_an_error_not_a_panic() {
         let src = SourceDocument::from_bytes("x.xls", InputFormat::Xls, vec![0u8; 64]);

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling-asr/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling-asr"
 description = "Audio/ASR pipeline for docling.rs (Whisper via ONNX; a Rust port of docling's ASR pipeline)."
-version = "2.2.2"
+version = "2.2.3"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"
@@ -25,10 +25,10 @@ xnnpack = ["docling-onnx/xnnpack"]
 ort-load-dynamic = ["docling-onnx/load-dynamic", "ort/load-dynamic"]
 
 [dependencies]
-docling-core = { path = "../docling-core", version = "2.2.2" }
+docling-core = { path = "../docling-core", version = "2.2.3" }
 # Shared ONNX execution-provider selection (DOCLING_RS_EP, #288) — routes the
 # Whisper encoder/decoder sessions through the same switch as docling-pdf.
-docling-onnx = { path = "../docling-onnx", version = "2.2.2" }
+docling-onnx = { path = "../docling-onnx", version = "2.2.3" }
 # Same ort as docling-pdf so the workspace keeps a single ONNX runtime.
 ort = { version = "2.0.0-rc.13", default-features = false, features = ["std", "download-binaries", "tls-rustls"] }
 serde_json = "1"

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling-core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling-core"
 description = "Core DoclingDocument data model and serializers for docling.rs (a Rust port of docling)."
-version = "2.2.2"
+version = "2.2.3"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling-core/src/markdown.rs

@@ -2628,7 +2628,6 @@ mod tests {
     /// buffered export.
     #[test]
     fn streamer_matches_buffered_export_with_options() {
-        use crate::document::ContentLayer;
         let doc = options_doc();
         let options = MarkdownExportOptions {
             layers: ContentLayers::ALL,
@@ -2651,7 +2650,6 @@ mod tests {
             buffered.contains("(img)") && buffered.contains("R&D _ report"),
             "{buffered}"
         );
-        let _ = ContentLayer::Notes;
     }
 
     /// #613: the plain export of a document holding every decoration the

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling-onnx/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling-onnx"
 description = "Shared ONNX Runtime execution-provider selection for docling.rs (DOCLING_RS_EP)."
-version = "2.2.2"
+version = "2.2.3"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"
@@ -41,7 +41,7 @@ xnnpack = ["ort/xnnpack"]
 load-dynamic = ["ort/load-dynamic", "dep:libloading"]
 
 [dependencies]
-docling-core = { path = "../docling-core", version = "2.2.2" }
+docling-core = { path = "../docling-core", version = "2.2.3" }
 # Same ort build as docling-pdf/docling-asr so the workspace keeps a single
 # ONNX Runtime.
 ort = { version = "2.0.0-rc.13", default-features = false, features = ["std", "download-binaries", "tls-rustls"] }

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling-pdf/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling-pdf"
 description = "PDF/image backend for docling.rs: pure-Rust text layer and page renderer + ONNX layout/table/OCR pipeline."
-version = "2.2.2"
+version = "2.2.3"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"
@@ -71,10 +71,10 @@ ort-load-dynamic = ["ml", "docling-onnx/load-dynamic", "ort/load-dynamic"]
 # what current LTS distros ship (Ubuntu 24.04 = 1.17). Newer libheif-rs
 # requires libheif >= 1.18 and can be selected once baselines move.
 libheif-rs = { version = "~1.0", default-features = false, optional = true }
-docling-core = { path = "../docling-core", version = "2.2.2" }
+docling-core = { path = "../docling-core", version = "2.2.3" }
 # Shared ONNX execution-provider selection (DOCLING_RS_EP, #74/#288);
 # re-exported as `docling_pdf::ep`.
-docling-onnx = { path = "../docling-onnx", version = "2.2.2", optional = true }
+docling-onnx = { path = "../docling-onnx", version = "2.2.3", optional = true }
 pdfium-render = { version = "0.8", optional = true }
 # Runtime loading of the opt-in docling-parse renderer plugin (#478,
 # `dparse_render.rs`) — the same mechanism pdfium-render uses for libpdfium.

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling-pdf/src/ocr_prep.rs

@@ -530,12 +530,18 @@ pub fn prep_page_lines(img: &RgbImage) -> Vec<PrepLine> {
 pub fn text_score() -> f32 {
     static SCORE: std::sync::OnceLock<f32> = std::sync::OnceLock::new();
     *SCORE.get_or_init(|| {
-        docling_core::env::parse::<f32>("DOCLING_RS_OCR_TEXT_SCORE")
-            .filter(|s| s.is_finite() && (0.0..=1.0).contains(s))
-            .unwrap_or(0.5)
+        text_score_from(docling_core::env::nonempty("DOCLING_RS_OCR_TEXT_SCORE").as_deref())
     })
 }
 
+/// [`text_score`] for one raw `DOCLING_RS_OCR_TEXT_SCORE` value: a score in
+/// 0–1, else RapidOCR's 0.5.
+fn text_score_from(raw: Option<&str>) -> f32 {
+    raw.and_then(|r| r.trim().parse::<f32>().ok())
+        .filter(|s| s.is_finite() && (0.0..=1.0).contains(s))
+        .unwrap_or(0.5)
+}
+
 /// Deterministic recognition batching: page-order line indices grouped by
 /// exact width (equal widths share a run — bit-identical to one-at-a-time
 /// recognition, see `ocr.rs`), each group split into [`REC_BATCH`] chunks.
@@ -676,7 +682,12 @@ mod tests {
     /// `0`, and garbage values ignored.
     #[test]
     fn text_score_default_is_rapidocrs() {
-        assert_eq!(text_score(), 0.5);
+        assert_eq!(text_score_from(None), 0.5);
+        assert_eq!(text_score_from(Some("0")), 0.0);
+        assert_eq!(text_score_from(Some("0.7")), 0.7);
+        for garbage in ["1.5", "-0.1", "NaN", "high", ""] {
+            assert_eq!(text_score_from(Some(garbage)), 0.5, "{garbage:?}");
+        }
     }
 
     #[test]

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling-pdf/src/tesseract.rs

@@ -63,18 +63,15 @@ impl TesseractOptions {
     /// `ocr_lang`), the rest from the environment. A `DOCLING_RS_TESSERACT_PSM`
     /// outside 0–13 warns and is ignored.
     pub fn from_env(lang: Option<String>) -> Self {
-        let psm = docling_core::env::nonempty("DOCLING_RS_TESSERACT_PSM").and_then(|raw| match raw
-            .trim()
-            .parse::<u8>()
-        {
-            Ok(n) if n <= 13 => Some(n),
-            _ => {
+        let psm = docling_core::env::nonempty("DOCLING_RS_TESSERACT_PSM").and_then(|raw| {
+            let psm = parse_psm(&raw);
+            if psm.is_none() {
                 eprintln!(
                     "docling-pdf: DOCLING_RS_TESSERACT_PSM={raw:?} is not a page \
                          segmentation mode 0-13; using Tesseract's default"
                 );
-                None
             }
+            psm
         });
         Self {
             cmd: docling_core::env::nonempty("DOCLING_TESSERACT")
@@ -86,6 +83,12 @@ impl TesseractOptions {
     }
 }
 
+/// A `DOCLING_RS_TESSERACT_PSM` value: a page segmentation mode 0–13, or
+/// `None` for anything else.
+fn parse_psm(raw: &str) -> Option<u8> {
+    raw.trim().parse::<u8>().ok().filter(|&n| n <= 13)
+}
+
 /// Tesseract's `-l` argument for an `ocr_lang` value under this engine.
 ///
 /// `+`-separated parts, each either a tessdata stem handed over verbatim —
@@ -929,9 +932,12 @@ mod tests {
     }
 
     #[test]
-    fn psm_env_is_range_checked() {
-        let opts = TesseractOptions::from_env(Some("eng".into()));
-        assert_eq!(opts.lang.as_deref(), Some("eng"));
-        assert!(opts.psm.is_none() || opts.psm.is_some_and(|p| p <= 13));
+    fn psm_is_range_checked() {
+        assert_eq!(parse_psm("6"), Some(6));
+        assert_eq!(parse_psm(" 13 "), Some(13));
+        assert_eq!(parse_psm("0"), Some(0));
+        for bad in ["14", "-1", "300", "six", ""] {
+            assert_eq!(parse_psm(bad), None, "{bad:?}");
+        }
     }
 }

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling-pdf/tests/text_layer.rs

@@ -47,11 +47,8 @@ fn text_layer_matches_no_ocr() {
 #[test]
 fn scanned_page_extracts_table_and_keeps_chart() {
     let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
-    if std::env::var("PDFIUM_DYNAMIC_LIB_PATH").is_err() {
-        std::env::set_var("PDFIUM_DYNAMIC_LIB_PATH", root.join(".pdfium/lib"));
-    }
+    // The page renders through the pure-Rust raster; pdfium is not needed.
     for needed in [
-        ".pdfium/lib/libpdfium.so",
         ".models/layout_heron_int8.onnx",
         ".models/ocr_rec_en.onnx",
         ".models/tableformer/encoder.onnx",
@@ -98,10 +95,8 @@ fn scanned_pdf_yields_empty_document() {
     .unwrap();
     let doc = docling_pdf::convert_text_layer(&scan, "scan.pdf").expect("no error");
     assert!(doc.nodes.is_empty());
-    // Bytes that are no readable PDF at all are an error about the file,
-    // not an empty "scanned" document.
-    let err = docling_pdf::convert_text_layer(b"%PDF-1.4\n%%EOF", "x.pdf").unwrap_err();
-    assert!(err.to_string().contains("not a readable PDF"), "{err}");
+    // (Bytes no reader opens are an error, not an empty document:
+    // `lib.rs`'s `text_layer_path_reports_an_unreadable_file`.)
 }
 
 /// #211: HEIC is detected by content, and without the `heif` feature the

{docling_rs-2.2.2 → docling_rs-2.2.3}/docling-py/Cargo.lock

@@ -764,7 +764,7 @@ dependencies = [
 
 [[package]]
 name = "docling"
-version = "2.2.2"
+version = "2.2.3"
 dependencies = [
  "calamine",
  "csv",
@@ -794,7 +794,7 @@ dependencies = [
 
 [[package]]
 name = "docling-asr"
-version = "2.2.2"
+version = "2.2.3"
 dependencies = [
  "docling-core",
  "docling-onnx",
@@ -805,7 +805,7 @@ dependencies = [
 
 [[package]]
 name = "docling-core"
-version = "2.2.2"
+version = "2.2.3"
 dependencies = [
  "png 0.18.1",
  "pulldown-cmark",
@@ -816,7 +816,7 @@ dependencies = [
 
 [[package]]
 name = "docling-onnx"
-version = "2.2.2"
+version = "2.2.3"
 dependencies = [
  "docling-core",
  "libloading 0.8.9",
@@ -825,7 +825,7 @@ dependencies = [
 
 [[package]]
 name = "docling-pdf"
-version = "2.2.2"
+version = "2.2.3"
 dependencies = [
  "docling-core",
  "docling-onnx",

{docling_rs-2.2.2 → docling_rs-2.2.3}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "maturin"
 name = "docling-rs"
 # Fallback for local maturin builds — pypi-publish.yml overwrites this with the
 # workspace version (root Cargo.toml) on every release.
-version = "2.2.2"
+version = "2.2.3"
 description = "Rust port of docling (docling.rs): convert PDF/DOCX/HTML/... to Markdown or docling JSON. Python bindings."
 readme = "README.md"
 license = { text = "MIT" }