langparse 0.1.0__py3-none-any.whl

langparse/engines/pdf/deepdoc/__init__.py

@@ -0,0 +1,55 @@
+"""
+Ported from RAGFlow's deepdoc module (Apache-2.0):
+https://github.com/infiniflow/ragflow/tree/main/deepdoc
+Copyright 2025 The InfiniFlow Authors.
+
+Ported near-verbatim: geometry, OCR, layout-recognition, and
+table-structure-recognition logic is unchanged. Removed or replaced:
+- All non-PDF format parsers, the resume parser, and the deepdoc_server
+  FastAPI service (out of scope -- langparse has its own docx/excel/
+  markdown parsers).
+- VisionParser and PlainParser (VisionParser needs an LLM and RAGFlow's
+  DB/service stack; PlainParser is a no-OCR pypdf fallback, redundant with
+  langparse's own `simple` engine).
+- Ascend NPU code paths and the remote DLA HTTP client branch (this port is
+  CPU/ONNX-only).
+- The XGBoost up/down line-merge classifier (updown_cnt_mdl /
+  _updown_concat_features) -- confirmed dead code on the live call path in
+  the source revision this was ported from: _concat_downward() returns
+  immediately after its first two lines.
+- rag_tokenizer (a thin wrapper around a tokenizer bundled in the
+  infinity-sdk vector-DB client) -- replaced with tokenizer.py, a small
+  jieba-backed shim covering the same call sites (is_chinese/tokenize/tag).
+- common.*/rag.* cross-package imports -- replaced with local equivalents
+  (see model_loader.py for model directory resolution).
+
+operators.py and postprocess.py are themselves derived from PaddleOCR
+(Apache-2.0) upstream in RAGFlow; that attribution carries through here too.
+"""
+
+__all__ = ["OCR", "LayoutRecognizer", "Recognizer", "TableStructureRecognizer", "RAGFlowPdfParser"]
+
+# Lazy (PEP 562) exports: importing this package must stay cheap so that
+# lightweight submodules (model_loader.py, rendering.py, tokenizer.py) can be
+# imported on their own -- e.g. under a `pip install -e ".[dev]"`-only
+# environment -- without transitively pulling in sklearn/cv2/onnxruntime via
+# pdf_parser.py's own heavy dependency chain. Python always runs a package's
+# __init__.py before any of its submodules, so eager `from .x import Y` here
+# would make every submodule import pay that cost.
+_EXPORTS = {
+    "OCR": (".ocr", "OCR"),
+    "LayoutRecognizer": (".layout_recognizer", "LayoutRecognizer4YOLOv10"),
+    "Recognizer": (".recognizer", "Recognizer"),
+    "TableStructureRecognizer": (".table_structure_recognizer", "TableStructureRecognizer"),
+    "RAGFlowPdfParser": (".pdf_parser", "RAGFlowPdfParser"),
+}
+
+
+def __getattr__(name):
+    if name in _EXPORTS:
+        import importlib
+
+        module_name, attr_name = _EXPORTS[name]
+        module = importlib.import_module(module_name, __name__)
+        return getattr(module, attr_name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

langparse/engines/pdf/deepdoc/layout_recognizer.py

@@ -0,0 +1,235 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+import logging
+import re
+from collections import Counter
+from copy import deepcopy
+
+import cv2
+import numpy as np
+
+from .model_loader import default_model_dir
+from .recognizer import Recognizer
+from .operators import nms
+
+
+class LayoutRecognizer(Recognizer):
+    labels = [
+        "_background_",
+        "Text",
+        "Title",
+        "Figure",
+        "Figure caption",
+        "Table",
+        "Table caption",
+        "Header",
+        "Footer",
+        "Reference",
+        "Equation",
+    ]
+
+    def __init__(self, domain, model_dir=None):
+        self.garbage_layouts = ["footer", "header", "reference"]
+        self.client = None
+
+        model_dir = model_dir or str(default_model_dir())
+        super().__init__(self.labels, domain, model_dir)
+
+    def __call__(self, image_list, ocr_res, scale_factor=3, thr=0.2, batch_size=16, drop=True):
+        def __is_garbage(b):
+            patt = [r"\(cid\s*:\s*\d+\s*\)"]
+            return any([re.search(p, b.get("text", "")) for p in patt])
+
+        if self.client:
+            layouts = self.client.predict(image_list)
+        else:
+            layouts = super().__call__(image_list, thr, batch_size)
+        # save_results(image_list, layouts, self.labels, output_dir='output/', threshold=0.7)
+        assert len(image_list) == len(ocr_res)
+        # Tag layout type
+        boxes = []
+        assert len(image_list) == len(layouts)
+        garbages = {}
+        page_layout = []
+        for pn, lts in enumerate(layouts):
+            bxs = ocr_res[pn]
+            lts = [
+                {
+                    "type": b["type"],
+                    "score": float(b["score"]),
+                    "x0": b["bbox"][0] / scale_factor,
+                    "x1": b["bbox"][2] / scale_factor,
+                    "top": b["bbox"][1] / scale_factor,
+                    "bottom": b["bbox"][-1] / scale_factor,
+                    "page_number": pn,
+                }
+                for b in lts
+                if float(b["score"]) >= 0.4 or b["type"] not in self.garbage_layouts
+            ]
+            lts = self.sort_Y_firstly(lts, np.mean([lt["bottom"] - lt["top"] for lt in lts]) / 2)
+            lts = self.layouts_cleanup(bxs, lts)
+            page_layout.append(lts)
+
+            def findLayout(ty):
+                nonlocal bxs, lts, self
+                lts_ = [lt for lt in lts if lt["type"] == ty]
+                i = 0
+                while i < len(bxs):
+                    if bxs[i].get("layout_type"):
+                        i += 1
+                        continue
+                    if __is_garbage(bxs[i]):
+                        bxs.pop(i)
+                        continue
+
+                    ii = self.find_overlapped_with_threshold(bxs[i], lts_, thr=0.4)
+                    if ii is None:
+                        bxs[i]["layout_type"] = ""
+                        i += 1
+                        continue
+                    lts_[ii]["visited"] = True
+                    keep_feats = [
+                        lts_[ii]["type"] == "footer" and bxs[i]["bottom"] < image_list[pn].size[1] * 0.9 / scale_factor,
+                        lts_[ii]["type"] == "header" and bxs[i]["top"] > image_list[pn].size[1] * 0.1 / scale_factor,
+                    ]
+                    if drop and lts_[ii]["type"] in self.garbage_layouts and not any(keep_feats):
+                        if lts_[ii]["type"] not in garbages:
+                            garbages[lts_[ii]["type"]] = []
+                        garbages[lts_[ii]["type"]].append(bxs[i]["text"])
+                        bxs.pop(i)
+                        continue
+
+                    bxs[i]["layoutno"] = f"{ty}-{ii}"
+                    bxs[i]["layout_type"] = lts_[ii]["type"] if lts_[ii]["type"] != "equation" else "figure"
+                    i += 1
+
+            for lt in ["footer", "header", "reference", "figure caption", "table caption", "title", "table", "text", "figure", "equation"]:
+                findLayout(lt)
+
+            # add box to figure/equation layouts which have no text box.
+            # Index within each type's own list and keep the type as the layoutno
+            # prefix so these match the namespace findLayout() assigns to
+            # text-overlapping boxes (figure-N vs equation-N). Using a combined
+            # figure+equation index with a fixed "figure" prefix would collide
+            # with figure-N tags from findLayout and merge unrelated regions.
+            for ty in ["figure", "equation"]:
+                for i, lt in enumerate([lt for lt in lts if lt["type"] == ty]):
+                    if lt.get("visited"):
+                        continue
+                    lt = deepcopy(lt)
+                    lt.pop("type", None)
+                    lt["text"] = ""
+                    lt["layout_type"] = "figure"
+                    lt["layoutno"] = f"{ty}-{i}"
+                    logging.debug(f"Created placeholder box {lt['layoutno']} for textless {ty} region")
+                    bxs.append(lt)
+
+            boxes.extend(bxs)
+
+        ocr_res = boxes
+
+        garbag_set = set()
+        for k in garbages.keys():
+            garbages[k] = Counter(garbages[k])
+            for g, c in garbages[k].items():
+                if c > 1:
+                    garbag_set.add(g)
+
+        ocr_res = [b for b in ocr_res if b["text"].strip() not in garbag_set]
+        return ocr_res, page_layout
+
+    def forward(self, image_list, thr=0.7, batch_size=16):
+        return super().__call__(image_list, thr, batch_size)
+
+
+class LayoutRecognizer4YOLOv10(LayoutRecognizer):
+    labels = [
+        "title",
+        "Text",
+        "Reference",
+        "Figure",
+        "Figure caption",
+        "Table",
+        "Table caption",
+        "Table caption",
+        "Equation",
+        "Figure caption",
+    ]
+
+    def __init__(self, domain, model_dir=None):
+        domain = "layout"
+        super().__init__(domain, model_dir)
+        self.auto = False
+        self.scaleFill = False
+        self.scaleup = True
+        self.stride = 32
+        self.center = True
+
+    def preprocess(self, image_list):
+        inputs = []
+        new_shape = self.input_shape  # height, width
+        for img in image_list:
+            shape = img.shape[:2]  # current shape [height, width]
+            # Scale ratio (new / old)
+            r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
+            # Compute padding
+            new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
+            dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]  # wh padding
+            dw /= 2  # divide padding into 2 sides
+            dh /= 2
+            ww, hh = new_unpad
+            img = np.array(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)).astype(np.float32)
+            img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
+            top, bottom = int(round(dh - 0.1)) if self.center else 0, int(round(dh + 0.1))
+            left, right = int(round(dw - 0.1)) if self.center else 0, int(round(dw + 0.1))
+            img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=(114, 114, 114))  # add border
+            img /= 255.0
+            img = img.transpose(2, 0, 1)
+            img = img[np.newaxis, :, :, :].astype(np.float32)
+            inputs.append({self.input_names[0]: img, "scale_factor": [shape[1] / ww, shape[0] / hh, dw, dh]})
+
+        return inputs
+
+    def postprocess(self, boxes, inputs, thr):
+        thr = 0.08
+        boxes = np.squeeze(boxes)
+        scores = boxes[:, 4]
+        boxes = boxes[scores > thr, :]
+        scores = scores[scores > thr]
+        if len(boxes) == 0:
+            return []
+        class_ids = boxes[:, -1].astype(int)
+        boxes = boxes[:, :4]
+        boxes[:, 0] -= inputs["scale_factor"][2]
+        boxes[:, 2] -= inputs["scale_factor"][2]
+        boxes[:, 1] -= inputs["scale_factor"][3]
+        boxes[:, 3] -= inputs["scale_factor"][3]
+        input_shape = np.array([inputs["scale_factor"][0], inputs["scale_factor"][1], inputs["scale_factor"][0], inputs["scale_factor"][1]])
+        boxes = np.multiply(boxes, input_shape, dtype=np.float32)
+
+        unique_class_ids = np.unique(class_ids)
+        indices = []
+        for class_id in unique_class_ids:
+            class_indices = np.where(class_ids == class_id)[0]
+            class_boxes = boxes[class_indices, :]
+            class_scores = scores[class_indices]
+            class_keep_boxes = nms(class_boxes, class_scores, 0.45)
+            indices.extend(class_indices[class_keep_boxes])
+
+        return [{"type": self.label_list[class_ids[i]].lower(), "bbox": [float(t) for t in boxes[i].tolist()], "score": float(scores[i])} for i in indices]
+
+

langparse/engines/pdf/deepdoc/model_loader.py

@@ -0,0 +1,101 @@
+"""
+Model directory resolution for the deepdoc port, mirroring MinerUEngine's
+model_dir/download_dir/model_policy semantics (see
+langparse/engines/pdf/mineru_service.py) instead of upstream deepdoc's
+per-class try/except-then-snapshot_download pattern repeated four times.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+DEEPDOC_REPO_ID = "InfiniFlow/deepdoc"
+# Immutable upstream commit resolved from the Hugging Face model metadata.
+# Updating model weights is a deliberate release change, never an implicit pull.
+DEEPDOC_MODEL_REVISION = "de0e793dc6d744406c96dabd688ccc969f41b443"
+REQUIRED_MODEL_FILES = ("det.onnx", "rec.onnx", "layout.onnx", "tsr.onnx", "ocr.res")
+DEEPDOC_MODEL_SHA256 = {
+    "det.onnx": "30a86f5731181461d08021402766601e4302a9b9b9666be8aff402696339cdff",
+    "rec.onnx": "1c7cf60de2afd728d512f4190cf37455092b45f06175365c6fc58d8cd7e2a68b",
+    "layout.onnx": "de401c03ee30b1c120416dc06f0705237f0c36d3cdb692c9bfefe8a8f98a4b70",
+    "tsr.onnx": "1585f88015c60209f16a079a26d944afca790ab7022fe7d0574113ccb9a6f9b4",
+    "ocr.res": "28b2362ad4ab2dc38769aa72feb535e3a9ddb3fd2a7585a05920e6393b1dc7f7",
+}
+
+
+def default_model_dir() -> Path:
+    return Path.home() / ".langparse" / "models" / "deepdoc"
+
+
+def _has_required_files(model_dir: Path) -> bool:
+    return _model_validation_error(model_dir) is None
+
+
+def _sha256(file_path: Path) -> str:
+    digest = hashlib.sha256()
+    with file_path.open("rb") as model_file:
+        for chunk in iter(lambda: model_file.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _model_validation_error(model_dir: Path) -> str | None:
+    missing = [name for name in REQUIRED_MODEL_FILES if not (model_dir / name).is_file()]
+    if missing:
+        return f"missing required files: {tuple(missing)}"
+
+    for name, expected in DEEPDOC_MODEL_SHA256.items():
+        actual = _sha256(model_dir / name)
+        if actual != expected:
+            return f"checksum mismatch for {name}: expected {expected}, got {actual}"
+    return None
+
+
+def download_models(local_dir: Path) -> Path:
+    from huggingface_hub import snapshot_download
+
+    downloaded = snapshot_download(
+        repo_id=DEEPDOC_REPO_ID,
+        revision=DEEPDOC_MODEL_REVISION,
+        local_dir=str(local_dir),
+    )
+    return Path(downloaded)
+
+
+def ensure_deepdoc_models(
+    model_dir: str | None = None,
+    download_dir: str | None = None,
+    model_policy: str = "download_if_missing",
+) -> str:
+    if model_policy not in ("download_if_missing", "require_existing"):
+        raise ValueError(
+            f"Unsupported deepdoc model_policy: {model_policy}. "
+            "Expected 'download_if_missing' or 'require_existing'."
+        )
+
+    if model_dir:
+        target = Path(model_dir).expanduser()
+        validation_error = _model_validation_error(target)
+        if validation_error is not None:
+            raise RuntimeError(
+                f"deepdoc model_dir has missing or invalid required files under {target}: "
+                f"{validation_error}"
+            )
+        return str(target)
+
+    target = Path(download_dir).expanduser() if download_dir else default_model_dir()
+    if _has_required_files(target):
+        return str(target)
+
+    if model_policy == "require_existing":
+        raise RuntimeError(
+            f"deepdoc model_policy=require_existing but models are missing under {target}"
+        )
+
+    target.mkdir(parents=True, exist_ok=True)
+    downloaded = download_models(target)
+    validation_error = _model_validation_error(downloaded)
+    if validation_error is not None:
+        raise RuntimeError(f"Downloaded deepdoc models failed verification: {validation_error}")
+    return str(downloaded)