docvortex 0.5.0__tar.gz → 0.5.1__tar.gz

{docvortex-0.5.0 → docvortex-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docvortex
-Version: 0.5.0
+Version: 0.5.1
 Summary: A fast, multi-format document parsing and conversion engine
 License-Expression: MIT
 Project-URL: Repository, https://github.com/myhloli/DocVortex

{docvortex-0.5.0 → docvortex-0.5.1}/docs/rust-acceleration.md

@@ -1,8 +1,8 @@
 # Optional Rust PDF kernels
 
 See [Repository architecture](ARCHITECTURE.md) for the Python/Rust ownership boundary
-and binding-module layout. The current private extension protocol is **6**, shared by
-the Python loader and Rust core. Protocol 4 and 5 references below describe historical
+and binding-module layout. The current private extension protocol is **8**, shared by
+the Python loader and Rust core. Protocol 4, 5, 6 and 7 references below describe historical
 interfaces or rollout stages, not the current loader requirement. Rebuild editable
 native installs and restart existing processes after updating native sources.
 
@@ -34,8 +34,9 @@ use an incremental accumulator matching the running CPython version's float-only
 inputs, other runtimes and intermediate overflow retain Python computation. Rust owns
 numeric batches and returns source ranges or indices. Canonical geometry reuses
 unchanged Python float objects and zero-rotation tuples to bound retained memory. Original `Char` references and
-copy-on-merge source-index behavior are retained. Small bounded caches contain only
-immutable Unicode features; they do not retain documents or use object addresses.
+copy-on-merge source-index behavior are retained. Process-wide caches contain only
+immutable Unicode features. Geometry, font and table preparation caches retain input
+references only for the active analysis or candidate build, and never retain native handles.
 
 ## Kernels
 
@@ -103,6 +104,10 @@ real parsing, both on Python 3.10 and 3.14. The regular CI matrix exercises Pyth
 Rust backends on Python 3.10–3.14. The release workflow retains the main-CI/tag gate,
 then builds/tests every artifact before publishing all platform wheels, the pure wheel
 and the source distribution. A local build is not evidence that remote matrix jobs passed.
+Performance comparisons run locally. CI retains cross-platform builds, ABI checks,
+installed-wheel parsing and Python/Rust correctness tests, without full-corpus timing
+or benchmark artifact uploads. Workflow-only changes do not require another local
+performance run when production source and extension fingerprints are unchanged.
 
 On Intel macOS, the existing Magika/ONNX Runtime dependency stack currently prevents
 full application installation on Python 3.14. That wheel is tested with full parsing
@@ -127,8 +132,11 @@ python tests/benchmarks/rust_pdf.py --backend python --suite shared --flash-base
 python tests/benchmarks/rust_pdf.py --backend rust --suite shared --flash-baseline output/rust/reference --output output/rust/shared-rust --baseline output/rust/shared-python
 ```
 
-The public/shared benchmark defaults to `caibao1`, `demo1` and `demo2`. Use repeatable
-`--path` arguments for other cases. Shared benchmarking consumes frozen baseline table
+The public/shared benchmark defaults to `--corpus all`: the layout manifest, recursively
+discovered `demo/pdfs` PDFs and native table fixtures, deduplicated by resolved path.
+Use `--corpus demo` for all demo PDFs, or repeatable `--path` arguments for explicit
+inputs. The revision comparison also accepts `--extra-path` for local external samples.
+Shared benchmarking consumes frozen baseline table
 regions, so a different candidate set cannot masquerade as acceleration. Timings include
 conversion into Rust and Python result construction. First invocation is separate from
 five warmed runs. Output comparison and memory sampling are outside timing. Public
@@ -137,8 +145,8 @@ an export. Shared timings separate extraction, reuse, evidence and table recover
 they do not include model inference or represent MinerU end-to-end latency.
 
 Acceptance requires unchanged full outputs, related historical/manual tests, host API
-and primitive-reuse tests, and installed-wheel verification. Target a 30% reduction in
-each demo's public parse and shared-entry timing. Investigate sustained regressions
+and primitive-reuse tests, and installed-wheel verification. Freeze the timing targets
+and aggregation method for each optimization round before measurement. Investigate sustained regressions
 above 5% in time or RSS. Never refresh a gold file or remove fields to achieve parity;
 record any remaining performance gap explicitly.
 
@@ -197,6 +205,21 @@ assert native state is actually used, not merely that an extension can be import
 
 The experimental native mapping pre-grouping kernel remains disabled in production:
 whole-entry measurements showed its packing cost exceeded its calculation benefit.
+
+Sixth-round inline geometry uses private protocol 7. Ordinary script classification
+batches contain at most 64 independent lines or 8,192 characters; a longer individual
+line is processed alone without splitting its classification scope. Formula segments,
+citation protection, first-match ties and final Python token materialization remain.
+Fraction filtering uses directional character indices and each cell's own character
+set and median height. Post-semantic line candidates preserve both same-baseline and
+edge-alignment paths before the original business predicate runs.
+
+Rule-band reuse requires identical, ordered, contiguous row references and strictly
+ordered finite rules. Repeated rules and unsupported inputs retain the reference path.
+At most 16 corridor band indices and 8,192 prepared marker lines / 16,384 glyphs are
+retained within one candidate build. Eviction recomputes evidence. Candidate enumeration,
+scoring, boundary double ownership, first-source choices and final conflict resolution
+remain unchanged.
 It is retained for differential coverage. No additional environment switch is exposed.
 
 For four-way revision acceptance, freeze the old checkout with its matching binary and

docvortex-0.5.1/docs/rust-pdf-round7.md

@@ -0,0 +1,67 @@
+# 第七轮 Flash PDF 热点优化
+
+冻结第六轮 `843b599` 及协议 7 二进制，最终性能源码 `aa02418`、协议 8。继续 `codex/rust-pdf-round6` 和 draft PR #14，不合并、不发布。
+
+17 份 demo／136 页公开解析 Rust 中位数之和：**16.378407 → 15.115506 秒，降低 7.71%**。10% 目标未达到。
+达到目标还需减少 0.374940 秒，差 2.29 个百分点。输出等价与 5% 退化门槛未降低。
+共享文本总和 3.270722 → 3.256694 秒，降低 0.43%；本轮不另设共享降幅目标。
+
+## 阶段实现
+
+| 阶段 | 提交 | 最终实现 |
+|---|---|---|
+| P0 | 1fb7305 | 独立目录冻结 32 PDF／299 页、186 个区域、文件与源码／扩展 SHA256、依赖。默认 all 仍自动发现新 demo。 |
+| P1 | 53df6cc | 每个标题阶段局部复用行高和栏 profile；保留排序副作用，语义变化失效，特殊对象参考路径。 |
+| P2 | fdd78f3 | 单行 source_rows_plain 源框选择／裁剪／旋转；单行 4096 项有界字体身份强引用缓存，Unicode／字体字段转换保留 Python 语义；协议 8。 |
+| P3 | 23af3c8 / 8546348 / aa02418 | 借用现有字符列表的映射保护／Glyph 几何融合、行内字体准备复用、256 块／8192 字有界文本投影；保留混合保护组和空页异常回调。 |
+
+中文论文2 的栏 profile 实算 5310 → 450；caibao1 为 603 → 114。逐样本准备次数、阶段输出、单次 pilot RSS 与映射微测见独立目录。Profiler 和早期 pilot 不是正式收益；生成器恢复次数不能解释为行打包次数。
+
+## 全部 demo 正式性能
+
+秒数为首次正式五次中位数（第六轮 → 第七轮）；RSS 为 Rust 跨版本具体指标裁决值。首次越过 5% 的耗时项另经反序复测，最终裁决列在报告中；不能只凭表中首次值判断持续退化。
+
+| PDF | 公开解析秒 | 提取秒 | text_total 秒 | table_total 秒 | public／shared RSS 变化 |
+|---|---:|---:|---:|---:|---:|
+| 2407.00079v4_origi-10.pdf | 0.092811 → 0.086420 | 0.018243 → 0.016836 | 0.023782 → 0.024553 | 0.000000 → 0.000000 | +0.14%／-0.14% |
+| IEBM_A_2667169_O-5.pdf | 0.170843 → 0.171224 | 0.017242 → 0.016133 | 0.028067 → 0.028045 | 0.000000 → 0.000000 | +0.11%／-0.07% |
+| caibao1.pdf | 2.452101 → 2.373419 | 0.325596 → 0.328070 | 0.570571 → 0.585651 | 0.449374 → 0.430277 | +0.27%／+0.36% |
+| demo1.pdf | 1.355296 → 1.207944 | 0.230689 → 0.201440 | 0.281070 → 0.277586 | 0.044858 → 0.047622 | +0.20%／+0.03% |
+| demo2.pdf | 0.958604 → 0.862577 | 0.129966 → 0.118818 | 0.181621 → 0.175139 | 0.011604 → 0.011935 | -0.16%／+0.39% |
+| demo3.pdf | 1.575423 → 1.427142 | 0.212203 → 0.192276 | 0.306598 → 0.300250 | 0.052482 → 0.049723 | +0.38%／-0.65% |
+| demo4.pdf | 1.670767 → 1.512883 | 0.258111 → 0.227539 | 0.352949 → 0.356910 | 0.006059 → 0.005732 | +0.19%／+0.30% |
+| demo6.pdf | 0.162215 → 0.148709 | 0.028103 → 0.027702 | 0.037096 → 0.041032 | 0.000000 → 0.000000 | -0.06%／+0.05% |
+| mixed_elements_pages_03_06.pdf | 0.448107 → 0.368632 | 0.066917 → 0.054733 | 0.087373 → 0.080706 | 0.004059 → 0.003694 | -0.19%／+0.44% |
+| mixed_elements_pages_07_10.pdf | 0.604619 → 0.550340 | 0.096087 → 0.096707 | 0.138526 → 0.137021 | 0.009868 → 0.008148 | -0.19%／+0.13% |
+| mixed_elements_pages_11_15.pdf | 0.769893 → 0.711560 | 0.115946 → 0.109838 | 0.163836 → 0.163087 | 0.007440 → 0.007065 | -0.09%／-0.46% |
+| mixed_elements_pages_39_40.pdf | 0.180964 → 0.157967 | 0.033202 → 0.030396 | 0.045920 → 0.040888 | 0.000000 → 0.000000 | -0.19%／+0.40% |
+| 中文论文.pdf | 1.087292 → 1.018619 | 0.137678 → 0.120614 | 0.221531 → 0.217378 | 0.011400 → 0.011064 | -0.05%／+0.32% |
+| 中文论文2.pdf | 3.476057 → 3.181534 | 0.362182 → 0.396619 | 0.671063 → 0.668371 | 0.016258 → 0.015684 | -0.12%／+0.40% |
+| small_ocr.pdf | 0.566205 → 0.585576 | 0.000593 → 0.000533 | 0.001538 → 0.001431 | 0.000000 → 0.000000 | -0.56%／-0.04% |
+| 中文论文3.pdf | 0.309775 → 0.286793 | 0.037955 → 0.035428 | 0.061237 → 0.060736 | 0.000000 → 0.000000 | +0.14%／+0.23% |
+| 中文论文4.pdf | 0.497434 → 0.464168 | 0.048115 → 0.044714 | 0.097942 → 0.097910 | 0.020723 → 0.020392 | -0.09%／-0.06% |
+
+正式比较仅在本机 Apple M4／16 GB、指定 `.venv4` 上进行。基线／候选 × Python／Rust 独立进程、一次预热、五次正式测量、交替顺序；RSS 独立采样。只对越过 5% 的具体指标反序复测，零基线新增工作量单列。最终源码的 profiler、测试与构建均未与计时并行。
+
+32 份文档全部三组门槛（Rust 跨版本、Python 跨版本、当前双后端）通过，无持续 >5% 的耗时／RSS 退化。反序清单和全部原始值见 performance-gates.json。
+
+## 等价性与验证
+
+- 四组完整 32 PDF／299 页 ModelJson、MiddleJson、文本证据、来源、HTML、Markdown、诊断及素材摘要一致；186 个表格区域一致，不刷新历史金标。
+- 515343 原始字符对照纯 Python 读取／几何参考一致；覆盖旋转、汉字映射、连字、重复来源、正负零及异常回调。
+- 全部 demo 加密集样本 137 页标框像素及导出一致；人工检查 18 文档的 22 个代表页，包含公式、上下标、长表注与旋转表格。既有作者拆分和部分副标题／表下注释分类保持一致。
+- 最终全量 Python 4469 passed／469 skipped；Rust 4937 passed／1 skipped；workspace test、clippy 与 fmt 通过。
+- MinerU 核心接口各 119 passed；18 文档 × medium/high 固定输入共 36 组回放，四组一致。补充 CPU 复用／文本样式各 16 项通过。另有 6 项稀疏渲染调度失败在冻结第六轮同样复现，单列为既有宿主局限。
+- 原生／纯 Python wheel、sdist 和实际安装通过；pypdfium2 5.10.1／5.13.0、协议 8 ABI、密集解析与 CLI 检查通过。性能快照扩展未被 wheel 重编译覆盖。
+- aa02418 的主 CI 39 作业、Native wheels 7 作业全部通过。Python 3.10–3.14、Linux x86_64／aarch64、macOS ARM／Intel、Windows 正确性／构建／兼容矩阵保留；未恢复全平台性能对比。
+- Intel macOS 3.14 仍有 magika／onnxruntime 应用依赖限制，完整依赖 smoke 使用 3.13，3.14 单独检查 ABI。
+
+## 剩余热点与证据
+
+当前热点为 PDFium 对象裁剪／矩阵／RGBA、源框 Python 记录准备、行构建、上下标分类打包和字体枚举；字体身份常不同，有界缓存收益有限。49.- 仍完整执行 7217 次候选展开和 7381 次区间检查，没有减少候选。
+
+首次完整候选 8546348 降低 6.31%，但共享入口存在持续退化，已拒绝；pre-fix-public／pre-fix-shared 保留原始结果。混合字符组和空页准备修复后重跑最终完整比较。逐字段 Python 单遍映射变慢和逐行略去无样式几何遗漏邻行证据的尝试均撤销并保留回归测试。
+
+独立本机证据：`output/pdf/rust-round7-20260926/REPORT.md`、`HOTSPOTS.md`、`stage-calls.json`、`performance-gates.json`、完整 accepted-public／accepted-shared 及 visual/review.json。第五／六轮产物和 tmp/ 保留。
+
+最终源码 SHA256：`dc8d902972b309e11881778598fd12edfb5f312cef38e9c7580432eea3e23f80`；性能扩展 SHA256：`799152ec326e20412a433ea41322e922701236c85ed907d59850a095c7ccc1ac`。后续文档提交不改变生产源码和二进制；正式记录的测量提交字段保持原样。

{docvortex-0.5.0 → docvortex-0.5.1}/rust/docvortex-core/src/lib.rs

@@ -1,6 +1,6 @@
 //! 不访问 Python 对象或 PDFium 的单线程批量计算内核。
 
-pub const PROTOCOL_VERSION: u32 = 6;
+pub const PROTOCOL_VERSION: u32 = 8;
 pub mod columns;
 pub mod note_index;
 pub mod row_geometry;

docvortex-0.5.1/rust/docvortex-python/src/dedup.rs

@@ -0,0 +1,256 @@
+//! 重复绘制、隐藏文字候选与映射分组的批量绑定。
+
+use docvortex_core::dedup;
+use pyo3::prelude::*;
+use pyo3::types::{PyBool, PyDict, PyFloat, PyInt, PyList, PyString, PyTuple, PyType};
+use std::collections::{HashMap, HashSet};
+
+/// 普通整数使用有界读取，超大或自定义整数由 Python 参考实现处理。
+fn plain_integer(value: &Bound<'_, PyAny>) -> Option<i64> {
+    value
+        .is_exact_instance_of::<PyInt>()
+        .then(|| value.extract::<i64>().ok())
+        .flatten()
+}
+
+/// 直接借用现有字符列表，一次准备映射保护区间与 Glyph 行框，不重新打包旧分组内核。
+#[pyfunction]
+pub(super) fn mapping_glyph_rows<'py>(
+    py: Python<'py>,
+    chars: &Bound<'py, PyList>,
+    bbox_type: &Bound<'py, PyType>,
+) -> PyResult<Option<Vec<(usize, usize, Option<Bound<'py, PyTuple>>, f64)>>> {
+    let mut fonts = HashSet::new();
+    let mut text_flags = HashMap::new();
+    let mut output: Vec<(usize, usize, Option<Bound<'py, PyTuple>>, f64)> = Vec::new();
+    let mut previous: Option<(
+        Bound<'py, PyAny>,
+        i64,
+        Bound<'py, PyDict>,
+        f64,
+        Option<[f64; 2]>,
+        [f64; 4],
+        bool,
+    )> = None;
+    for (position, item) in chars.iter().enumerate() {
+        if !item.is_exact_instance_of::<PyDict>() {
+            return Ok(None);
+        }
+        let char = item.cast::<PyDict>()?;
+        if char
+            .iter()
+            .any(|(key, _value)| !key.is_exact_instance_of::<PyString>())
+        {
+            return Ok(None);
+        }
+        let (Some(text), Some(index), Some(font), Some(raw), Some(rotation)) = (
+            char.get_item(pyo3::intern!(py, "char"))?,
+            char.get_item(pyo3::intern!(py, "char_idx"))?,
+            char.get_item(pyo3::intern!(py, "font"))?,
+            char.get_item(pyo3::intern!(py, "bbox"))?,
+            char.get_item(pyo3::intern!(py, "rotation"))?,
+        ) else {
+            return Ok(None);
+        };
+        if !text.is_exact_instance_of::<PyString>()
+            || !font.is_exact_instance_of::<PyDict>()
+            || !rotation.is_exact_instance_of::<PyFloat>()
+        {
+            return Ok(None);
+        }
+        let Some(index) = plain_integer(&index) else {
+            return Ok(None);
+        };
+        let font = font.cast_into::<PyDict>()?;
+        let font_id = font.as_ptr() as usize;
+        if !fonts.contains(&font_id) {
+            for (key, value) in font.iter() {
+                if !key.is_exact_instance_of::<PyString>()
+                    || !(value.is_none()
+                        || value.is_exact_instance_of::<PyString>()
+                        || value.is_exact_instance_of::<PyInt>()
+                        || value.is_exact_instance_of::<PyFloat>()
+                        || value.is_exact_instance_of::<PyBool>())
+                {
+                    return Ok(None);
+                }
+            }
+            if fonts.len() >= 4096 {
+                fonts.clear();
+            }
+            fonts.insert(font_id);
+        }
+        let raw = if raw.get_type().is(bbox_type) {
+            raw.getattr(pyo3::intern!(py, "bbox"))?
+        } else {
+            raw
+        };
+        let Some(Some(box4)) = super::geometry::plain_coordinates::<4>(&raw) else {
+            return Ok(None);
+        };
+        let origin = char
+            .get_item(pyo3::intern!(py, "origin"))?
+            .unwrap_or_else(|| py.None().into_bound(py));
+        let Some(origin) = super::geometry::plain_coordinates::<2>(&origin) else {
+            return Ok(None);
+        };
+        let object = char
+            .get_item(pyo3::intern!(py, "text_object_id"))?
+            .unwrap_or_else(|| py.None().into_bound(py));
+        if !object.is_none() && !object.is_exact_instance_of::<PyInt>() {
+            return Ok(None);
+        }
+        let rotation = rotation.extract::<f64>()?;
+        let angle = if let Some(value) = char.get_item(pyo3::intern!(py, "writing_angle"))? {
+            if !value.is_exact_instance_of::<PyFloat>() {
+                return Ok(None);
+            }
+            value.extract::<f64>()?
+        } else {
+            -rotation
+        };
+        if !rotation.is_finite() || !angle.is_finite() {
+            return Ok(None);
+        }
+        let last_source =
+            if let Some(source) = char.get_item(pyo3::intern!(py, "source_indices"))? {
+                if !source.is_exact_instance_of::<PyTuple>() || source.len()? == 0 {
+                    return Ok(None);
+                }
+                let mut maximum = i64::MIN;
+                for value in source.cast::<PyTuple>()?.iter() {
+                    let Some(value) = plain_integer(&value) else {
+                        return Ok(None);
+                    };
+                    maximum = maximum.max(value);
+                }
+                maximum
+            } else {
+                index
+            };
+        let Ok(text_key) = text.cast::<PyString>()?.to_str() else {
+            return Ok(None);
+        };
+        let has_text = if let Some(value) = text_flags.get(text_key) {
+            *value
+        } else {
+            let value = text.call_method0(pyo3::intern!(py, "strip"))?.is_truthy()?;
+            if text_key.len() <= 32 {
+                if text_flags.len() >= 4096 {
+                    text_flags.clear();
+                }
+                text_flags.insert(text_key.to_owned(), value);
+            }
+            value
+        };
+        let same = if let Some((
+            obj,
+            maximum,
+            previous_font,
+            previous_rotation,
+            previous_origin,
+            previous_box,
+            previous_text,
+        )) = &previous
+        {
+            !obj.is_none()
+                && obj.eq(&object)?
+                && maximum.checked_add(1) == Some(index)
+                && previous_font.eq(&font)?
+                && *previous_rotation == rotation
+                && previous_origin
+                    .zip(origin)
+                    .is_some_and(|(a, b)| a.iter().zip(b).all(|(x, y)| (x - y).abs() <= 0.001))
+                && previous_box
+                    .iter()
+                    .zip(box4)
+                    .all(|(x, y)| (x - y).abs() <= 0.001)
+                && *previous_text
+                && has_text
+        } else {
+            false
+        };
+        if same {
+            // 异字符保护组也返回完整区间；Unicode 转换在全部准备完成后由 Python 执行。
+            output.last_mut().expect("mapping group exists").1 = position + 1;
+        } else {
+            let box_tuple = if box4[2] > box4[0] && box4[3] > box4[1] {
+                Some(PyTuple::new(
+                    py,
+                    (0..4)
+                        .map(|i| raw.get_item(i))
+                        .collect::<PyResult<Vec<_>>>()?,
+                )?)
+            } else {
+                None
+            };
+            output.push((position, position + 1, box_tuple, angle));
+        }
+        previous = Some((object, last_source, font, rotation, origin, box4, has_text));
+    }
+    Ok(Some(output))
+}
+
+/// 批量生成重复绘制候选，不在内层循环回调 Python。
+#[pyfunction]
+pub(super) fn paint_pairs(
+    py: Python<'_>,
+    records: Vec<dedup::PaintRecord>,
+) -> Option<(Vec<dedup::Pair>, Vec<dedup::Offset>)> {
+    py.detach(move || dedup::paint_pairs(records))
+}
+
+/// 检查来源索引后批量计算最早来源连通关系。
+#[pyfunction]
+pub(super) fn dedup_components(
+    py: Python<'_>,
+    count: usize,
+    pairs: Vec<dedup::Pair>,
+) -> PyResult<Vec<usize>> {
+    if pairs.iter().any(|(a, b)| *a >= count || *b >= count) {
+        return Err(pyo3::exceptions::PyIndexError::new_err(
+            "glyph index out of range",
+        ));
+    }
+    Ok(py.detach(move || dedup::components(count, &pairs)))
+}
+
+/// 返回隐藏 OCR 的几何候选，文本比较与来源物化仍由 Python 拥有。
+#[pyfunction]
+pub(super) fn hidden_candidates(
+    py: Python<'_>,
+    records: Vec<dedup::HiddenRecord>,
+) -> Option<Vec<(Vec<usize>, Vec<usize>)>> {
+    py.detach(move || dedup::hidden_candidates(records))
+}
+
+/// 在原始候选顺序下确认平移证据，并验证全部来源索引。
+#[pyfunction]
+pub(super) fn confirmed_offsets(
+    py: Python<'_>,
+    records: Vec<dedup::EvidenceRecord>,
+    pairs: Vec<dedup::Offset>,
+    exact: Vec<dedup::Pair>,
+) -> PyResult<Vec<dedup::Pair>> {
+    if pairs
+        .iter()
+        .any(|p| p.0 >= records.len() || p.1 >= records.len())
+        || exact
+            .iter()
+            .any(|(a, b)| *a >= records.len() || *b >= records.len())
+    {
+        return Err(pyo3::exceptions::PyIndexError::new_err(
+            "glyph index out of range",
+        ));
+    }
+    Ok(py.detach(move || dedup::confirmed_offsets(records, pairs, exact)))
+}
+
+/// 只传递一次每字符数值，返回分组范围以复用原有字符对象。
+#[pyfunction]
+pub(super) fn mapping_runs(
+    py: Python<'_>,
+    records: Vec<dedup::MappingRecord>,
+) -> Option<Vec<(usize, usize)>> {
+    py.detach(move || dedup::mapping_runs(records))
+}

{docvortex-0.5.0 → docvortex-0.5.1}/rust/docvortex-python/src/geometry.rs

@@ -3,7 +3,7 @@
 use docvortex_core::extraction;
 use docvortex_core::geometry::{self, Box4, Size};
 use pyo3::prelude::*;
-use pyo3::types::{PyFloat, PyList, PyTuple};
+use pyo3::types::{PyFloat, PyInt, PyList, PyTuple};
 
 use super::conversion::{box_tuple, read_boxes, BoxTuple};
 
@@ -212,3 +212,109 @@ pub(super) fn source_rows<'py>(
     }
     Ok(output)
 }
+
+/// 只借用内置浮点序列，特殊类型及异常数值返回参考路径而不执行转换回调。
+pub(super) fn plain_coordinates<const N: usize>(
+    value: &Bound<'_, PyAny>,
+) -> Option<Option<[f64; N]>> {
+    if value.is_none() {
+        return Some(None);
+    }
+    if (!value.is_exact_instance_of::<PyList>() && !value.is_exact_instance_of::<PyTuple>())
+        || value.len().ok()? != N
+    {
+        return None;
+    }
+    let mut result = [0.0; N];
+    for (index, number) in result.iter_mut().enumerate() {
+        let item = value.get_item(index).ok()?;
+        if !item.is_exact_instance_of::<PyFloat>() {
+            return None;
+        }
+        *number = item.extract::<f64>().ok()?;
+        if !number.is_finite() {
+            return None;
+        }
+    }
+    Some(Some(result))
+}
+
+/// 每行只接收一份保序记录，融合普通数值校验及既有源框选择、裁剪和旋转。
+#[pyfunction]
+pub(super) fn source_rows_plain<'py>(
+    py: Python<'py>,
+    records: &Bound<'py, PyList>,
+    size: Size,
+    angle: i32,
+) -> PyResult<Option<Bound<'py, PyList>>> {
+    let mut rows = Vec::with_capacity(records.len());
+    let mut originals = Vec::with_capacity(records.len());
+    for record in records.iter() {
+        if !record.is_exact_instance_of::<PyTuple>() || record.len()? != 6 {
+            return Ok(None);
+        }
+        let position = record.get_item(0)?;
+        if !position.is_exact_instance_of::<PyInt>() || position.extract::<usize>().is_err() {
+            return Ok(None);
+        }
+        let raw = record.get_item(1)?;
+        let side = record.get_item(2)?;
+        let tight = record.get_item(3)?;
+        let origin = record.get_item(4)?;
+        let rotation = record.get_item(5)?;
+        let (Some(r), Some(s), Some(t), Some(o)) = (
+            plain_coordinates::<4>(&raw),
+            plain_coordinates::<4>(&side),
+            plain_coordinates::<4>(&tight),
+            plain_coordinates::<2>(&origin),
+        ) else {
+            return Ok(None);
+        };
+        if !rotation.is_exact_instance_of::<PyFloat>() {
+            return Ok(None);
+        }
+        let rotation = rotation.extract::<f64>()?;
+        if !rotation.is_finite() {
+            return Ok(None);
+        }
+        rows.push((r, s, t, o, rotation));
+        originals.push((position, raw, side, tight, origin));
+    }
+    let prepared = py.detach(move || geometry::source_rows(rows, size, angle));
+    let output = PyList::empty(py);
+    for ((position, raw, side, tight, origin), row) in originals.into_iter().zip(prepared) {
+        if let Some((s, t, o, ls, lt, lo)) = row {
+            let source = shared_coordinates(py, s, &[raw, side])?;
+            let tight = shared_coordinates(py, t, &[tight])?;
+            let origin = shared_coordinates(py, o, &[origin])?;
+            let local_source = if angle == 0 {
+                source.clone()
+            } else {
+                shared_coordinates(py, ls, &[])?
+            };
+            let local_tight = if angle == 0 {
+                tight.clone()
+            } else {
+                shared_coordinates(py, lt, &[])?
+            };
+            let local_origin = if angle == 0 {
+                origin.clone()
+            } else {
+                shared_coordinates(py, lo, &[])?
+            };
+            let values = PyTuple::new(
+                py,
+                [
+                    source,
+                    tight,
+                    origin,
+                    local_source,
+                    local_tight,
+                    local_origin,
+                ],
+            )?;
+            output.append(PyTuple::new(py, [position, values.into_any()])?)?;
+        }
+    }
+    Ok(Some(output))
+}

{docvortex-0.5.0 → docvortex-0.5.1}/rust/docvortex-python/src/lib.rs

@@ -20,6 +20,7 @@ fn _native(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_function(wrap_pyfunction!(spatial::title_gaps, module)?)?;
     module.add_function(wrap_pyfunction!(spatial::line_neighbors, module)?)?;
     module.add_function(wrap_pyfunction!(dedup::mapping_runs, module)?)?;
+    module.add_function(wrap_pyfunction!(dedup::mapping_glyph_rows, module)?)?;
     module.add_function(wrap_pyfunction!(pdfium::read_pdfium_chars, module)?)?;
     module.add_function(wrap_pyfunction!(pdfium::read_pdfium_char_batches, module)?)?;
     module.add_class::<pdfium::PdfiumCharacterBatches>()?;
@@ -46,6 +47,7 @@ fn _native(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_function(wrap_pyfunction!(geometry::visual_runs, module)?)?;
     module.add_function(wrap_pyfunction!(geometry::local_boxes, module)?)?;
     module.add_function(wrap_pyfunction!(geometry::source_rows, module)?)?;
+    module.add_function(wrap_pyfunction!(geometry::source_rows_plain, module)?)?;
     module.add_function(wrap_pyfunction!(dedup::paint_pairs, module)?)?;
     module.add_function(wrap_pyfunction!(dedup::dedup_components, module)?)?;
     module.add_function(wrap_pyfunction!(dedup::hidden_candidates, module)?)?;
@@ -58,5 +60,7 @@ fn _native(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_function(wrap_pyfunction!(tables::component_specs, module)?)?;
     module.add_function(wrap_pyfunction!(geometry::materialize_geometry, module)?)?;
     module.add_function(wrap_pyfunction!(scripts::script_roles_raw, module)?)?;
+    module.add_function(wrap_pyfunction!(scripts::script_roles_raw_batch, module)?)?;
+    module.add_function(wrap_pyfunction!(scripts::script_roles_plain_batch, module)?)?;
     Ok(())
 }