A fast, helpful, and open-source document parser
feat: add inline is-complex signals to parse json result, opt-in only
Logan Markewicha3a9490f0787
diff --git a/crates/liteparse-napi/src/types.rs b/crates/liteparse-napi/src/types.rsindex 7c0b1cf..f330ce5 100644--- a/crates/liteparse-napi/src/types.rs+++ b/crates/liteparse-napi/src/types.rs@@ -66,6 +66,10 @@ pub struct JsLiteParseConfig {/// Drop diagonal text (rotation >2° off the nearest right angle). Default/// false. Use to exclude rotated watermarks/stamps from the output.pub skip_diagonal_text: Option<bool>,+ /// Compute per-page complexity signals during parse and attach them to each+ /// page as `ParsedPage.complexity` (the same signals `isComplex` returns).+ /// Default false; enabling it runs an extra vector-text detection pass.+ pub include_complexity: Option<bool>,}/// A page sub-region as the fraction cropped from each side (top-left origin,@@ -155,6 +159,9 @@ impl JsLiteParseConfig {if let Some(v) = self.skip_diagonal_text {cfg.skip_diagonal_text = v;}+ if let Some(v) = self.include_complexity {+ cfg.include_complexity = v;+ }cfg}@@ -202,6 +209,7 @@ impl JsLiteParseConfig {left: c.left as f64,}),skip_diagonal_text: Some(cfg.skip_diagonal_text),+ include_complexity: Some(cfg.include_complexity),}}}@@ -403,6 +411,9 @@ pub struct JsParsedPage {pub text: String,pub markdown: String,pub text_items: Vec<JsTextItem>,+ /// Per-page complexity signals. Present only when parsing was configured+ /// with `includeComplexity`; `undefined`/`None` otherwise.+ pub complexity: Option<JsPageComplexityStats>,}impl JsParsedPage {@@ -414,6 +425,10 @@ impl JsParsedPage {text: page.text.clone(),markdown: page.markdown.clone(),text_items: page.text_items.iter().map(JsTextItem::from_rust).collect(),+ complexity: page+ .complexity+ .as_ref()+ .map(JsPageComplexityStats::from_rust),}}}diff --git a/crates/liteparse-python/src/cli.rs b/crates/liteparse-python/src/cli.rsindex a0475ad..b13ab5c 100644--- a/crates/liteparse-python/src/cli.rs+++ b/crates/liteparse-python/src/cli.rs@@ -72,6 +72,10 @@ struct ParseCommand {/// `[text](url)` in markdown output; pass this to emit plain anchor text.#[arg(long)]no_links: bool,+ /// Include per-page complexity signals as a `complexity` object on each+ /// page of JSON output. Off by default.+ #[arg(long)]+ complexity: bool,}#[derive(Args, Debug)]@@ -121,6 +125,10 @@ struct BatchParseCommand {quiet: bool,#[arg(long)]num_workers: Option<usize>,+ /// Include per-page complexity signals as a `complexity` object on each+ /// page of JSON output. Off by default.+ #[arg(long)]+ complexity: bool,}/// Parse a `Name: Value` header string into a `(name, value)` pair.@@ -183,6 +191,7 @@ pub fn run_cli(args: Vec<String>) -> Result<(), Box<dyn std::error::Error>> {ocr_server_headers: cmd.ocr_server_headers,image_mode,extract_links: !cmd.no_links,+ include_complexity: cmd.complexity,..Default::default()};if let Some(n) = cmd.num_workers {@@ -278,6 +287,7 @@ pub fn run_cli(args: Vec<String>) -> Result<(), Box<dyn std::error::Error>> {quiet: cmd.quiet,ocr_server_url: cmd.ocr_server_url,ocr_server_headers: cmd.ocr_server_headers,+ include_complexity: cmd.complexity,..Default::default()};if let Some(n) = cmd.num_workers {diff --git a/crates/liteparse-python/src/lib.rs b/crates/liteparse-python/src/lib.rsindex 85fadf2..6d0b62b 100644--- a/crates/liteparse-python/src/lib.rs+++ b/crates/liteparse-python/src/lib.rs@@ -134,6 +134,10 @@ struct PyParsedPage {markdown: String,#[pyo3(get)]text_items: Vec<PyTextItem>,+ /// Per-page complexity signals. Populated only when parsing was configured+ /// with `include_complexity=True`; `None` otherwise.+ #[pyo3(get)]+ complexity: Option<PyPageComplexityStats>,}#[pymethods]@@ -162,6 +166,10 @@ impl PyParsedPage {.into_iter().map(PyTextItem::from_rust).collect(),+ complexity: page+ .complexity+ .as_ref()+ .map(PyPageComplexityStats::from_rust),}}}@@ -458,6 +466,7 @@ impl LiteParse {emit_word_boxes = None,crop_box = None,skip_diagonal_text = None,+ include_complexity = None,))]fn new(ocr_language: Option<String>,@@ -480,6 +489,7 @@ impl LiteParse {emit_word_boxes: Option<bool>,crop_box: Option<(f32, f32, f32, f32)>,skip_diagonal_text: Option<bool>,+ include_complexity: Option<bool>,) -> PyResult<Self> {let mut cfg = LiteParseConfig::default();if let Some(v) = ocr_language {@@ -555,6 +565,9 @@ impl LiteParse {if let Some(v) = skip_diagonal_text {cfg.skip_diagonal_text = v;}+ if let Some(v) = include_complexity {+ cfg.include_complexity = v;+ }let inner = liteparse::parser::LiteParse::new(cfg.clone());let runtime = tokio::runtime::Runtime::new()diff --git a/crates/liteparse-wasm/src/lib.rs b/crates/liteparse-wasm/src/lib.rsindex 73bcd57..26c9d17 100644--- a/crates/liteparse-wasm/src/lib.rs+++ b/crates/liteparse-wasm/src/lib.rs@@ -68,6 +68,10 @@ pub struct LiteParseConfig {/// Drop diagonal text (rotation >2° off the nearest right angle). Default/// false. Use to exclude rotated watermarks/stamps from the output.skip_diagonal_text: Option<bool>,+ /// Compute per-page complexity signals during parse and attach them to each+ /// page as `ParsedPage.complexity` (the same signals `isComplex` returns).+ /// Default false; enabling it runs an extra vector-text detection pass.+ include_complexity: Option<bool>,}/// A page sub-region as the fraction cropped from each side (top-left origin,@@ -161,6 +165,9 @@ impl LiteParseConfig {if let Some(v) = self.skip_diagonal_text {cfg.skip_diagonal_text = v;}+ if let Some(v) = self.include_complexity {+ cfg.include_complexity = v;+ }cfg.num_workers = 1;Ok(cfg)}@@ -203,6 +210,7 @@ impl LiteParseConfig {left: c.left,}),skip_diagonal_text: Some(cfg.skip_diagonal_text),+ include_complexity: Some(cfg.include_complexity),}}}@@ -255,6 +263,10 @@ pub struct ParsedPage {pub text: String,pub markdown: String,pub text_items: Vec<TextItem>,+ /// Per-page complexity signals. Present only when parsing was configured+ /// with `includeComplexity`; omitted otherwise.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub complexity: Option<PageComplexityStats>,}#[derive(Serialize, Tsify)]@@ -492,6 +504,7 @@ impl LiteParse {},}).collect(),+ complexity: p.complexity.as_ref().map(PageComplexityStats::from_rust),}).collect();diff --git a/crates/liteparse/src/config.rs b/crates/liteparse/src/config.rsindex f452fee..a720b9c 100644--- a/crates/liteparse/src/config.rs+++ b/crates/liteparse/src/config.rs@@ -71,6 +71,13 @@ pub struct LiteParseConfig {/// Drop diagonal (skewed) text — items whose rotation is more than 2°/// off the nearest right angle (0/90/180/270). Default `false`.pub skip_diagonal_text: bool,+ /// Compute per-page complexity signals during `parse` and attach them to+ /// each `ParsedPage` (surfaced as a `complexity` object per page in JSON).+ /// These are the same signals the standalone `is_complex` API returns.+ /// Default `false`: the vector-text detection walk this runs is only worth+ /// paying for when a caller actually consumes the signals, so parse stays+ /// on its cheap path unless this is explicitly opted into.+ pub include_complexity: bool,}/// A page sub-region expressed as the fraction cropped from each side.@@ -145,6 +152,7 @@ impl Default for LiteParseConfig {emit_word_boxes: false,crop_box: None,skip_diagonal_text: false,+ include_complexity: false,}}}diff --git a/crates/liteparse/src/main.rs b/crates/liteparse/src/main.rsindex 7308067..241616a 100644--- a/crates/liteparse/src/main.rs+++ b/crates/liteparse/src/main.rs@@ -119,6 +119,12 @@ struct ParseCommand {/// parity, where ground truth uses no link syntax).#[arg(long)]no_links: bool,++ /// Include per-page complexity signals (the same `is-complex` reports) as a+ /// `complexity` object on each page of JSON output. Off by default; enabling+ /// it runs the extra vector-text detection pass.+ #[arg(long)]+ complexity: bool,}#[derive(Args, Debug)]@@ -207,6 +213,11 @@ struct BatchParseCommand {/// Number of concurrent OCR workers (default: CPU cores - 1)#[arg(long)]num_workers: Option<usize>,++ /// Include per-page complexity signals as a `complexity` object on each+ /// page of JSON output. Off by default.+ #[arg(long)]+ complexity: bool,}#[derive(Args, Debug)]@@ -308,6 +319,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {ocr_server_headers: cmd.ocr_server_headers,image_mode,extract_links: !cmd.no_links,+ include_complexity: cmd.complexity,..Default::default()};if let Some(n) = cmd.num_workers {@@ -408,6 +420,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {quiet: cmd.quiet,ocr_server_url: cmd.ocr_server_url,ocr_server_headers: cmd.ocr_server_headers,+ include_complexity: cmd.complexity,..Default::default()};if let Some(n) = cmd.num_workers {diff --git a/crates/liteparse/src/markdown_layout/test_helpers.rs b/crates/liteparse/src/markdown_layout/test_helpers.rsindex 2fbe925..8a27727 100644--- a/crates/liteparse/src/markdown_layout/test_helpers.rs+++ b/crates/liteparse/src/markdown_layout/test_helpers.rs@@ -42,6 +42,7 @@ pub(crate) fn page(lines: Vec<ProjectedLine>) -> ParsedPage {figures: vec![],struct_nodes: vec![],image_refs: vec![],+ complexity: None,}}@@ -192,6 +193,7 @@ pub(crate) fn header_footer_page(n: usize, header: &str, footer: &str, body: &stfigures: vec![],struct_nodes: vec![],image_refs: vec![],+ complexity: None,}}diff --git a/crates/liteparse/src/ocr_merge.rs b/crates/liteparse/src/ocr_merge.rsindex 95baa3c..5b963c4 100644--- a/crates/liteparse/src/ocr_merge.rs+++ b/crates/liteparse/src/ocr_merge.rs@@ -75,7 +75,7 @@ impl ComplexityReason {}}-#[derive(Debug, Serialize)]+#[derive(Debug, Clone, Serialize)]pub struct PageComplexityStats {pub page_number: usize,pub text_length: usize,diff --git a/crates/liteparse/src/output/json.rs b/crates/liteparse/src/output/json.rsindex 442ec2a..e218991 100644--- a/crates/liteparse/src/output/json.rs+++ b/crates/liteparse/src/output/json.rs@@ -1,3 +1,4 @@+use crate::ocr_merge::PageComplexityStats;use crate::types::ParsedPage;use serde::Serialize;@@ -23,6 +24,10 @@ pub(crate) struct JsonPage {pub height: f32,pub text: String,pub text_items: Vec<JsonTextItem>,+ /// Per-page complexity signals. Present only when parsing was configured+ /// with `include_complexity` (otherwise omitted from the JSON entirely).+ #[serde(skip_serializing_if = "Option::is_none")]+ pub complexity: Option<PageComplexityStats>,}#[derive(Debug, Serialize)]@@ -54,6 +59,7 @@ pub(crate) fn build_json(pages: &[ParsedPage]) -> ParseResultJson {confidence: item.confidence.or(Some(1.0)),}).collect(),+ complexity: page.complexity.clone(),}).collect(),}@@ -98,6 +104,7 @@ mod tests {figures: vec![],struct_nodes: vec![],image_refs: vec![],+ complexity: None,}}diff --git a/crates/liteparse/src/output/markdown.rs b/crates/liteparse/src/output/markdown.rsindex 3d5caf1..2bc6b94 100644--- a/crates/liteparse/src/output/markdown.rs+++ b/crates/liteparse/src/output/markdown.rs@@ -158,6 +158,7 @@ mod tests {figures: vec![],struct_nodes: vec![],image_refs: vec![],+ complexity: None,}}@@ -206,6 +207,7 @@ mod tests {figures: vec![],struct_nodes: vec![],image_refs: vec![],+ complexity: None,};let out = format_markdown(&[p], &[], ImageMode::Placeholder);assert!(out.contains("```text"));diff --git a/crates/liteparse/src/output/text.rs b/crates/liteparse/src/output/text.rsindex 64348b3..dace7af 100644--- a/crates/liteparse/src/output/text.rs+++ b/crates/liteparse/src/output/text.rs@@ -27,6 +27,7 @@ mod tests {figures: vec![],struct_nodes: vec![],image_refs: vec![],+ complexity: None,}}diff --git a/crates/liteparse/src/parser.rs b/crates/liteparse/src/parser.rsindex 1877214..e82f0a2 100644--- a/crates/liteparse/src/parser.rs+++ b/crates/liteparse/src/parser.rs@@ -285,7 +285,7 @@ impl LiteParse {};let ocr_grayscale = ocr_engine.as_ref().is_some_and(|e| e.prefers_grayscale());- let (pages, ocr_rendered, outline, images) = {+ let (pages, ocr_rendered, outline, images, complexity) = {let lib = Library::init();let document = extract::load_document_from_input(&lib, &validated_input, password)?;let outline = extract::extract_outline(&document);@@ -324,8 +324,22 @@ impl LiteParse {} else {Vec::new()};+ // Per-page complexity signals, opt-in via `include_complexity`. Needs+ // the live PDFium document (image / filled-path geometry), so it runs+ // here inside the lock; empty otherwise so the cheap path pays nothing.+ let complexity = if self.config.include_complexity {+ pages+ .iter()+ .map(|page| {+ let page_obj = document.page((page.page_number - 1) as i32)?;+ ocr_merge::calculate_page_complexity(page, &page_obj)+ })+ .collect::<Result<Vec<_>, _>>()?+ } else {+ Vec::new()+ };// `lib` is dropped here, releasing the PDFium lock.- (pages, rendered, outline, images)+ (pages, rendered, outline, images, complexity)};let mut pages = pages;let t1 = web_time::Instant::now();@@ -360,6 +374,12 @@ impl LiteParse {// Grid projectionlet mut parsed_pages = projection::project_pages_to_grid(pages);+ // Attach per-page complexity signals (empty unless `include_complexity`).+ // Projection is 1:1 with the input pages and preserves order, so a+ // positional zip aligns each page with its own stats.+ for (page, stats) in parsed_pages.iter_mut().zip(complexity) {+ page.complexity = Some(stats);+ }let t2 = web_time::Instant::now();log(&format!("[liteparse] project: {:.1}ms",diff --git a/crates/liteparse/src/projection.rs b/crates/liteparse/src/projection.rsindex f9f7859..530410f 100644--- a/crates/liteparse/src/projection.rs+++ b/crates/liteparse/src/projection.rs@@ -2909,6 +2909,7 @@ pub fn project_pages_to_grid(pages: Vec<Page>) -> Vec<ParsedPage> {figures,struct_nodes: page.struct_nodes,image_refs: page.image_refs,+ complexity: None,}}).collect()diff --git a/crates/liteparse/src/types.rs b/crates/liteparse/src/types.rsindex 6287b14..ea008c9 100644--- a/crates/liteparse/src/types.rs+++ b/crates/liteparse/src/types.rs@@ -180,6 +180,11 @@ pub struct ParsedPage {/// page has no embedded images. Not part of JSON/text output.#[serde(skip)]pub image_refs: Vec<ImageRef>,+ /// Per-page complexity signals (the same the `is_complex` API returns).+ /// Populated only when `LiteParseConfig::include_complexity` is set;+ /// `None` otherwise. Surfaced as a per-page `complexity` object in JSON.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub complexity: Option<crate::ocr_merge::PageComplexityStats>,}/// One embedded raster image on a page. `id` is a stable, page-scoped slugdiff --git a/packages/node/src/cli.ts b/packages/node/src/cli.tsindex 3673811..79ccce9 100644--- a/packages/node/src/cli.ts+++ b/packages/node/src/cli.ts@@ -61,6 +61,10 @@ program.option("--config <file>", "JSON config file path").option("-q, --quiet", "Suppress progress output").option("--num-workers <n>", "Number of concurrent OCR workers", parseInt)+ .option(+ "--complexity",+ "Include per-page complexity signals in JSON output",+ ).action(async (file: string, opts: Record<string, unknown>) => {try {const config: Partial<LiteParseConfig> = {};@@ -91,6 +95,7 @@ programif (opts.password) config.password = opts.password as string;if (opts.quiet) config.quiet = true;if (opts.numWorkers) config.numWorkers = opts.numWorkers as number;+ if (opts.complexity) config.includeComplexity = true;// Default CLI output to text (library defaults to json)if (!config.outputFormat) config.outputFormat = "text";diff --git a/packages/node/src/lib.ts b/packages/node/src/lib.tsindex 25d85c2..c28a9ba 100644--- a/packages/node/src/lib.ts+++ b/packages/node/src/lib.ts@@ -71,6 +71,13 @@ export interface LiteParseConfig {* watermarks/stamps from the output.*/skipDiagonalText: boolean;+ /**+ * Compute per-page complexity signals during {@link LiteParse.parse} and+ * attach them to each page as {@link ParsedPage.complexity} (the same signals+ * {@link LiteParse.isComplex} returns). Default false; enabling it runs an+ * extra vector-text detection pass.+ */+ includeComplexity: boolean;}/**@@ -161,6 +168,12 @@ export interface ParsedPage {text: string;markdown: string;textItems: TextItem[];+ /**+ * Per-page complexity signals (the same {@link LiteParse.isComplex} returns).+ * Present only when parsing with `includeComplexity: true`; `undefined`+ * otherwise.+ */+ complexity?: PageComplexityStats;}export interface ExtractedImage {@@ -253,6 +266,7 @@ export class LiteParse {emitWordBoxes: userConfig.emitWordBoxes,cropBox: userConfig.cropBox,skipDiagonalText: userConfig.skipDiagonalText,+ includeComplexity: userConfig.includeComplexity,};this._native = new native.LiteParse(nativeConfig);@@ -280,6 +294,7 @@ export class LiteParse {emitWordBoxes: resolved.emitWordBoxes ?? false,cropBox: resolved.cropBox ?? undefined,skipDiagonalText: resolved.skipDiagonalText ?? false,+ includeComplexity: resolved.includeComplexity ?? false,};}@@ -327,21 +342,7 @@ export class LiteParse {typeof input === "string" ? input : Buffer.from(input);const stats: NativePageComplexityStats[] =await this._native.isComplex(nativeInput);- return stats.map((s) => ({- pageNumber: s.pageNumber,- textLength: s.textLength,- textCoverage: s.textCoverage,- hasSubstantialImages: s.hasSubstantialImages,- imageBlockCount: s.imageBlockCount,- imageCoverage: s.imageCoverage,- largestImageCoverage: s.largestImageCoverage,- fullPageImage: s.fullPageImage,- uncoveredVectorArea: s.uncoveredVectorArea ?? undefined,- isGarbled: s.isGarbled,- pageArea: s.pageArea,- needsOcr: s.needsOcr,- reasons: s.reasons,- }));+ return stats.map(toComplexity);}async screenshot(@@ -367,6 +368,24 @@ export class LiteParse {}}+function toComplexity(s: NativePageComplexityStats): PageComplexityStats {+ return {+ pageNumber: s.pageNumber,+ textLength: s.textLength,+ textCoverage: s.textCoverage,+ hasSubstantialImages: s.hasSubstantialImages,+ imageBlockCount: s.imageBlockCount,+ imageCoverage: s.imageCoverage,+ largestImageCoverage: s.largestImageCoverage,+ fullPageImage: s.fullPageImage,+ uncoveredVectorArea: s.uncoveredVectorArea ?? undefined,+ isGarbled: s.isGarbled,+ pageArea: s.pageArea,+ needsOcr: s.needsOcr,+ reasons: s.reasons,+ };+}+function toPage(p: NativeParsedPage): ParsedPage {return {pageNum: p.pageNum,@@ -375,6 +394,7 @@ function toPage(p: NativeParsedPage): ParsedPage {text: p.text,markdown: p.markdown,textItems: p.textItems.map(toTextItem),+ complexity: p.complexity ? toComplexity(p.complexity) : undefined,};}diff --git a/packages/node/src/native.ts b/packages/node/src/native.tsindex 03942dc..22d8acc 100644--- a/packages/node/src/native.ts+++ b/packages/node/src/native.ts@@ -40,6 +40,7 @@ export interface LiteParseNativeConfig {emitWordBoxes?: boolean;cropBox?: NativeCropBox;skipDiagonalText?: boolean;+ includeComplexity?: boolean;}export interface NativeCropBox {@@ -102,6 +103,7 @@ export interface NativeParsedPage {text: string;markdown: string;textItems: NativeTextItem[];+ complexity?: NativePageComplexityStats;}export interface NativeExtractedImage {diff --git a/packages/python/liteparse/parser.py b/packages/python/liteparse/parser.pyindex 3d07fdc..f3efe97 100644--- a/packages/python/liteparse/parser.py+++ b/packages/python/liteparse/parser.py@@ -19,6 +19,25 @@ from .types import ()+def _convert_complexity(s: Any) -> PageComplexityStats:+ """Convert a native PyPageComplexityStats to our Python dataclass."""+ return PageComplexityStats(+ page_number=s.page_number,+ text_length=s.text_length,+ text_coverage=s.text_coverage,+ has_substantial_images=s.has_substantial_images,+ image_block_count=s.image_block_count,+ image_coverage=s.image_coverage,+ largest_image_coverage=s.largest_image_coverage,+ full_page_image=s.full_page_image,+ uncovered_vector_area=s.uncovered_vector_area,+ is_garbled=s.is_garbled,+ page_area=s.page_area,+ needs_ocr=s.needs_ocr,+ reasons=list(s.reasons),+ )++def _convert_native_result(native_result: Any) -> ParseResult:"""Convert a native PyParseResult to our Python ParseResult."""pages: List[ParsedPage] = []@@ -47,6 +66,7 @@ def _convert_native_result(native_result: Any) -> ParseResult:)for item in native_page.text_items]+ native_complexity = getattr(native_page, "complexity", None)pages.append(ParsedPage(page_num=native_page.page_num,@@ -55,6 +75,11 @@ def _convert_native_result(native_result: Any) -> ParseResult:text=native_page.text,markdown=native_page.markdown,text_items=text_items,+ complexity=(+ _convert_complexity(native_complexity)+ if native_complexity is not None+ else None+ ),))images = [@@ -109,6 +134,7 @@ class LiteParse:emit_word_boxes: Optional[bool] = None,crop_box: Optional[Tuple[float, float, float, float]] = None,skip_diagonal_text: Optional[bool] = None,+ include_complexity: Optional[bool] = None,):"""Initialize LiteParse parser.@@ -154,6 +180,11 @@ class LiteParse:skip_diagonal_text: Drop diagonal text — items whose rotation ismore than 2° off the nearest right angle (0/90/180/270).Default False. Use to exclude rotated watermarks/stamps.+ include_complexity: Compute per-page complexity signals during+ :meth:`parse` and attach them to each page as+ ``ParsedPage.complexity`` (the same :meth:`is_complex` returns).+ Default False; enabling it runs an extra vector-text detection+ pass."""kwargs = {}if ocr_enabled is not None:@@ -196,6 +227,8 @@ class LiteParse:kwargs["crop_box"] = crop_boxif skip_diagonal_text is not None:kwargs["skip_diagonal_text"] = skip_diagonal_text+ if include_complexity is not None:+ kwargs["include_complexity"] = include_complexityself._native = _NativeLiteParse(**kwargs)@@ -259,24 +292,7 @@ class LiteParse:if not file_path.exists():raise FileNotFoundError(f"File not found: {file_path}")native_stats = self._native.is_complex(str(file_path.absolute()))- return [- PageComplexityStats(- page_number=s.page_number,- text_length=s.text_length,- text_coverage=s.text_coverage,- has_substantial_images=s.has_substantial_images,- image_block_count=s.image_block_count,- image_coverage=s.image_coverage,- largest_image_coverage=s.largest_image_coverage,- full_page_image=s.full_page_image,- uncovered_vector_area=s.uncovered_vector_area,- is_garbled=s.is_garbled,- page_area=s.page_area,- needs_ocr=s.needs_ocr,- reasons=list(s.reasons),- )- for s in native_stats- ]+ return [_convert_complexity(s) for s in native_stats]except FileNotFoundError:raiseexcept Exception as e:diff --git a/packages/python/liteparse/types.py b/packages/python/liteparse/types.pyindex c9ca0d3..a080964 100644--- a/packages/python/liteparse/types.py+++ b/packages/python/liteparse/types.py@@ -43,6 +43,10 @@ class ParsedPage:text: strmarkdown: str = ""text_items: List[TextItem] = field(default_factory=list)+ #: Per-page complexity signals (the same :meth:`LiteParse.is_complex`+ #: returns). Populated only when parsing with ``include_complexity=True``;+ #: ``None`` otherwise.+ complexity: Optional[PageComplexityStats] = None@dataclass