docvortex 0.2.1__py3-none-any.whl

docvortex/postprocess/content.py

@@ -0,0 +1,53 @@
+"""raw block 的文本、代码和公式内容清理规则。"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..content.inline import map_text_span_content, normalize_inline_spans
+
+
+def code_content_clean(content: str | None) -> str:
+    """去除代码块外层 Markdown 围栏并保留代码正文。"""
+    if not content:
+        return ""
+    lines = content.splitlines()
+    start_idx = 1 if lines and lines[0].startswith("```") else 0
+    end_idx = len(lines)
+    if lines and end_idx > start_idx and lines[end_idx - 1].strip() == "```":
+        end_idx -= 1
+    if start_idx < end_idx:
+        return "\n".join(lines[start_idx:end_idx]).strip()
+    return ""
+
+
+def clean_content(content: str | None) -> str | None:
+    """将成对的行间公式分隔符改为兼容文本清理的方括号。"""
+    if content and content.count("\\[") == content.count("\\]") and content.count("\\[") > 0:
+
+        def replace_pattern(match: re.Match[str]) -> str:
+            """替换单个成对公式片段。"""
+            return f"[{match.group(1)}]"
+
+        content = re.sub(r"\\\[(.*?)\\\]", replace_pattern, content)
+    return content
+
+
+def clean_inline_content(content: Any) -> list[dict[str, Any]]:
+    """严格规范化 raw Span 列表，并返回可继续后处理的 JSON 字典。"""
+    if content is None:
+        return []
+    if not isinstance(content, list):
+        raise TypeError("inline content must be a list of spans")
+    spans = normalize_inline_spans(content)
+    return [span.model_dump(mode="json") for span in spans]
+
+
+def collapse_inline_newlines(content: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """把标题 Span 中的换行及后续空白收敛为单个空格。"""
+    spans = map_text_span_content(normalize_inline_spans(content), lambda value: re.sub(r"\n\s*", " ", value))
+    return [span.model_dump(mode="json") for span in spans]
+
+
+__all__ = ["clean_content", "clean_inline_content", "code_content_clean", "collapse_inline_newlines"]

docvortex/postprocess/document.py

@@ -0,0 +1,19 @@
+"""将规范化分析结果转换为独立的语义文档。"""
+
+from __future__ import annotations
+from copy import deepcopy
+from ..schema import MiddleJson, ModelJson
+from .pages import model_json_to_pages
+
+
+def model_json_to_middle_json(model_json: ModelJson) -> MiddleJson:
+    """只执行确定性后处理，智能增强由调用方另行执行。"""
+    return MiddleJson(
+        pages=model_json_to_pages(model_json),
+        is_full_document=model_json.is_full_document,
+        metadata=model_json.metadata.model_copy(deep=True),
+        extensions=deepcopy(model_json.extensions),
+    )
+
+
+__all__ = ["model_json_to_middle_json"]

docvortex/postprocess/lists.py

@@ -0,0 +1,236 @@
+"""PDF 与 Office 的列表、目录和标题编号后处理。"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..content.spans import inline_span_plain_text, text_spans
+from ..schema import BlockType, parse_inline_spans
+from ..foundation.geometry import calculate_overlap_area_in_bbox1_area_ratio
+
+from ..content.inline import inline_plain_text, slice_inline_spans
+from .visual import _bbox_for_calculation
+
+
+def fix_office_paragraph_titles(model_list: list[list[dict[str, Any]]]) -> None:
+    """按文档级标题序列内化 Office 自动编号，并清除私有编号元数据。"""
+    counters: dict[int, int] = {}
+    for page_model_list in model_list:
+        for block in page_model_list:
+            if block.get("type") != BlockType.PARAGRAPH_TITLE:
+                continue
+            raw_level = block.get("level")
+            normalized_level = raw_level if type(raw_level) is int else 2
+            level = min(max(normalized_level, 2), 6)
+            block["level"] = level
+            numbering_depth = level - 1
+            is_numbered_style = block.pop("is_numbered_style", None)
+            block.pop("section_number", None)
+            content = block.get("content")
+            if not isinstance(content, list):
+                continue
+            if is_numbered_style is True:
+                for ancestor_level in range(1, numbering_depth):
+                    counters.setdefault(ancestor_level, 1)
+                counters[numbering_depth] = counters.get(numbering_depth, 0) + 1
+                _clear_deeper_title_counters(counters, numbering_depth)
+                section_number = ".".join(str(counters[ancestor_level]) for ancestor_level in range(1, numbering_depth + 1))
+                block["content"] = [*text_spans(f"{section_number} "), *content]
+                continue
+            if is_numbered_style is False:
+                number_match = re.match(r"^\s*(\d+(?:\.\d+)*)\b", _visible_text(content))
+                if number_match is None:
+                    continue
+                number_parts = [int(part) for part in number_match.group(1).split(".")]
+                if len(number_parts) != numbering_depth:
+                    continue
+                counters.update((part_level, number) for part_level, number in enumerate(number_parts, start=1))
+                _clear_deeper_title_counters(counters, numbering_depth)
+
+
+def fix_office_index_title_blocks(model_list: list[list[dict[str, Any]]]) -> None:
+    """按正文目标 anchor 将 Office 目录文本叶子转换为对应正文或标题类型。"""
+    target_by_anchor: dict[str, tuple[str, int | None]] = {}
+    for page_model_list in model_list:
+        for block in page_model_list:
+            block_type = block.get("type")
+            if block_type not in {BlockType.TEXT, BlockType.DOC_TITLE, BlockType.PARAGRAPH_TITLE}:
+                continue
+            anchor = block.get("anchor")
+            level = block.get("level")
+            if not isinstance(anchor, str) or not anchor.strip():
+                continue
+            if block_type in {BlockType.DOC_TITLE, BlockType.PARAGRAPH_TITLE} and type(level) is not int:
+                continue
+            target_by_anchor.setdefault(anchor.strip(), (block_type, level if type(level) is int else None))
+
+    for page_model_list in model_list:
+        for block in page_model_list:
+            if block.get("type") == BlockType.INDEX:
+                _rewrite_office_index_title_leaves(block, target_by_anchor)
+
+
+def _rewrite_office_index_title_leaves(
+    index_block: dict[str, Any],
+    target_by_anchor: dict[str, tuple[str, int | None]],
+) -> None:
+    """递归改写目录叶子；未匹配 anchor 时降级为不带 anchor 的普通文本。"""
+    content = index_block.get("content")
+    if not isinstance(content, list):
+        return
+    for child in content:
+        if not isinstance(child, dict):
+            continue
+        if child.get("type") == BlockType.INDEX:
+            _rewrite_office_index_title_leaves(child, target_by_anchor)
+            continue
+        if child.get("type") != BlockType.TEXT:
+            continue
+        anchor = child.get("anchor")
+        normalized_anchor = anchor.strip() if isinstance(anchor, str) else ""
+        target = target_by_anchor.get(normalized_anchor)
+        if target is None:
+            child.pop("anchor", None)
+            continue
+        target_type, target_level = target
+        child["type"] = target_type
+        if target_level is None:
+            child.pop("level", None)
+        else:
+            child["level"] = target_level
+        child["anchor"] = normalized_anchor
+
+
+def fix_pdf_list_blocks(
+    list_blocks: list[dict[str, Any]],
+    text_blocks: list[dict[str, Any]],
+    ref_text_blocks: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]]]:
+    """按 bbox 把 PDF text/ref_text 归入 list，并推断列表子类型。"""
+    for list_block in list_blocks:
+        list_block["content"] = []
+    need_remove_blocks = []
+    for block in text_blocks + ref_text_blocks:
+        for list_block in list_blocks:
+            if (
+                calculate_overlap_area_in_bbox1_area_ratio(
+                    _bbox_for_calculation(block["bbox"]),
+                    _bbox_for_calculation(list_block["bbox"]),
+                )
+                >= 0.8
+            ):
+                list_block["content"].append(block)
+                need_remove_blocks.append(block)
+                break
+    for block in need_remove_blocks:
+        if block in text_blocks:
+            text_blocks.remove(block)
+        elif block in ref_text_blocks:
+            ref_text_blocks.remove(block)
+    list_blocks = [block for block in list_blocks if block["content"]]
+    for list_block in list_blocks:
+        type_count: dict[str, int] = {}
+        for sub_block in list_block["content"]:
+            sub_block_type = sub_block["type"]
+            type_count[sub_block_type] = type_count.get(sub_block_type, 0) + 1
+        list_block["sub_type"] = max(type_count, key=type_count.get) if type_count else "text"  # type: ignore[arg-type]
+    return list_blocks, text_blocks, ref_text_blocks
+
+
+def fix_pdf_index_blocks(index_blocks: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """将 PDF 目录块的多行内容拆分为多个文本子块。"""
+    for index_block in index_blocks:
+        raw_content = index_block.get("content")
+        if not isinstance(raw_content, list):
+            index_block["content"] = []
+            continue
+        spans = parse_inline_spans(raw_content)
+        visible = inline_plain_text(spans)
+        children: list[dict[str, Any]] = []
+        start = 0
+        for match in re.finditer("\n", visible):
+            content = slice_inline_spans(spans, start, match.start())
+            if content:
+                children.append({"type": BlockType.TEXT, "content": [span.model_dump(mode="json") for span in content]})
+            start = match.end()
+        content = slice_inline_spans(spans, start)
+        if content:
+            children.append({"type": BlockType.TEXT, "content": [span.model_dump(mode="json") for span in content]})
+        index_block["content"] = children
+    return index_blocks
+
+
+def fix_office_index_blocks(index_blocks: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """递归移除 Office 目录层级私有字段，保留已规范化的标题叶子。"""
+    pending_blocks = list(index_blocks)
+    while pending_blocks:
+        block = pending_blocks.pop()
+        block.pop("ilevel", None)
+        content = block.get("content")
+        if isinstance(content, list):
+            pending_blocks.extend(child for child in content if isinstance(child, dict))
+    return index_blocks
+
+
+def _clear_deeper_title_counters(counters: dict[int, int], level: int) -> None:
+    """删除当前标题层级之后的旧计数。"""
+    for counter_level in [value for value in counters if value > level]:
+        del counters[counter_level]
+
+
+def _visible_text(content: list[dict[str, Any]]) -> str:
+    """提取结构化 Span 的可见文本，供显式标题编号识别。"""
+    return inline_span_plain_text(content)
+
+
+def fix_office_list_blocks(list_blocks: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """将每层 Office 列表的局部序号写入文本内容，并移除原始元数据。"""
+
+    def get_ordered_list_start(list_block: dict[str, Any]) -> int:
+        """读取有序列表起始编号，保留合法的零值。"""
+        start = list_block.get("start")
+        if start is None:
+            return 1
+        try:
+            start = int(start)
+        except (TypeError, ValueError):
+            return 1
+        return start if start >= 0 else 1
+
+    def fix_list_block(list_block: dict[str, Any]) -> None:
+        """递归处理列表树；每个有序列表只维护当前层的独立编号。"""
+        is_ordered = list_block.get("attribute") == "ordered"
+        ordered_number = get_ordered_list_start(list_block)
+        content = list_block.get("content")
+        if isinstance(content, list):
+            for child_block in content:
+                if not isinstance(child_block, dict):
+                    continue
+                child_type = child_block.get("type")
+                if child_type == BlockType.TEXT:
+                    child_content = child_block.get("content")
+                    if not isinstance(child_content, list):
+                        child_block.pop("list_label", None)
+                        continue
+                    exact_label = child_block.pop("list_label", None)
+                    if isinstance(exact_label, str) and exact_label.strip():
+                        prefix = f"{exact_label.strip()} "
+                        if is_ordered:
+                            ordered_number += 1
+                    elif is_ordered:
+                        prefix = f"{ordered_number}. "
+                        ordered_number += 1
+                    else:
+                        prefix = "- "
+                    child_block["content"] = [*text_spans(prefix), *child_content]
+                elif child_type == BlockType.LIST:
+                    fix_list_block(child_block)
+        list_block.pop("attribute", None)
+        list_block.pop("ilevel", None)
+        list_block.pop("start", None)
+
+    for list_block in list_blocks:
+        if isinstance(list_block, dict):
+            fix_list_block(list_block)
+    return list_blocks

docvortex/postprocess/page_blocks.py

@@ -0,0 +1,214 @@
+"""单页 raw block 的内容清理、列表整理和视觉分组流水线。"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..schema import RAW_ALGORITHM, RAW_CAPTION, RAW_FOOTNOTE, BlockType, VISUAL_MAIN_TYPES
+from ..foundation.language import guess_code_language
+
+from ..foundation.text import clean_isolated_formula
+
+from .content import clean_inline_content, code_content_clean, collapse_inline_newlines
+from .lists import fix_office_index_blocks, fix_office_list_blocks, fix_pdf_index_blocks, fix_pdf_list_blocks
+from .visual import (
+    fallback_inline_caption_fragments,
+    fallback_leading_table_continuation_captions,
+    fallback_no_bbox_caption_fragments,
+    regroup_visual_blocks,
+)
+
+BlockDict = dict[str, Any]
+
+_REPLACED_BLOCK_TYPES = {
+    BlockType.TEXT,
+    BlockType.REF_TEXT,
+    BlockType.LIST,
+    BlockType.INDEX,
+    RAW_CAPTION,
+    RAW_FOOTNOTE,
+    BlockType.IMAGE_BODY,
+    BlockType.TABLE_BODY,
+    BlockType.CHART_BODY,
+    BlockType.CODE_BODY,
+    BlockType.IMAGE_CAPTION,
+    BlockType.IMAGE_FOOTNOTE,
+    BlockType.TABLE_CAPTION,
+    BlockType.TABLE_FOOTNOTE,
+    BlockType.CHART_CAPTION,
+    BlockType.CHART_FOOTNOTE,
+    BlockType.CODE_CAPTION,
+    BlockType.CODE_FOOTNOTE,
+}
+
+
+_INLINE_CONTENT_BLOCK_TYPES = {
+    BlockType.TEXT,
+    BlockType.REF_TEXT,
+    BlockType.DOC_TITLE,
+    BlockType.PARAGRAPH_TITLE,
+    BlockType.HEADER,
+    BlockType.FOOTER,
+    BlockType.PAGE_NUMBER,
+    BlockType.ASIDE_TEXT,
+    BlockType.PAGE_FOOTNOTE,
+    RAW_CAPTION,
+    RAW_FOOTNOTE,
+    BlockType.IMAGE_CAPTION,
+    BlockType.IMAGE_FOOTNOTE,
+    BlockType.TABLE_CAPTION,
+    BlockType.TABLE_FOOTNOTE,
+    BlockType.CHART_CAPTION,
+    BlockType.CHART_FOOTNOTE,
+    BlockType.CODE_CAPTION,
+    BlockType.CODE_FOOTNOTE,
+}
+
+
+def _normalize_raw_blocks(page_model_list: list[BlockDict]) -> list[BlockDict]:
+    """原地规范化 raw block 类型、内容、索引和代码子类型。"""
+    blocks: list[BlockDict] = []
+    for index, block in enumerate(page_model_list):
+        code_block_sub_type = None
+        block_type = block.get("type", "")
+        block_content = block.get("content", "")
+        if block_type == BlockType.IMAGE:
+            block_type = BlockType.IMAGE_BODY
+        elif block_type == BlockType.TABLE:
+            block_type = BlockType.TABLE_BODY
+        elif block_type == BlockType.CHART:
+            block_type = BlockType.CHART_BODY
+        elif block_type == BlockType.CODE:
+            code_block_sub_type = block_type
+            block_content = code_content_clean(block_content)
+            block_type = BlockType.CODE_BODY
+        elif block_type == RAW_ALGORITHM:
+            code_block_sub_type = block_type
+            block_content = clean_inline_content(block_content)
+            block_type = BlockType.CODE_BODY
+        elif block_type == BlockType.EQUATION:
+            block_content = clean_isolated_formula(block_content)
+
+        if block_type in [BlockType.IMAGE_BODY, BlockType.CHART_BODY] and block_content is None:
+            block_content = ""
+        if block_type == BlockType.DOC_TITLE:
+            block["level"] = 1
+        elif block_type == BlockType.PARAGRAPH_TITLE:
+            raw_level = block.get("level")
+            normalized_level = raw_level if type(raw_level) is int else 2
+            block["level"] = min(max(normalized_level, 2), 6)
+
+        if block_type in _INLINE_CONTENT_BLOCK_TYPES:
+            block_content = clean_inline_content(block_content)
+            if block_type in [BlockType.DOC_TITLE, BlockType.PARAGRAPH_TITLE]:
+                block_content = collapse_inline_newlines(block_content)
+
+        block["type"] = block_type
+        block["content"] = block_content
+        block["index"] = index
+        if code_block_sub_type:
+            block["sub_type"] = code_block_sub_type
+        blocks.append(block)
+    return blocks
+
+
+def _apply_caption_fallbacks(blocks: list[BlockDict], *, use_bbox: bool) -> None:
+    """按 PDF 或 Office 结构应用视觉标题兜底规则。"""
+    if use_bbox:
+        fallback_inline_caption_fragments(blocks, VISUAL_MAIN_TYPES)
+        fallback_leading_table_continuation_captions(blocks, VISUAL_MAIN_TYPES)
+    else:
+        fallback_no_bbox_caption_fragments(blocks, VISUAL_MAIN_TYPES)
+
+
+def _partition_textual_blocks(
+    blocks: list[BlockDict],
+) -> tuple[list[BlockDict], list[BlockDict], list[BlockDict], list[BlockDict]]:
+    """按 text、ref_text、list、index 四类分区 raw block。"""
+    text_blocks: list[BlockDict] = []
+    ref_text_blocks: list[BlockDict] = []
+    list_blocks: list[BlockDict] = []
+    index_blocks: list[BlockDict] = []
+    for block in blocks:
+        block_type = block["type"]
+        if block_type == BlockType.TEXT:
+            text_blocks.append(block)
+        elif block_type == BlockType.REF_TEXT:
+            ref_text_blocks.append(block)
+        elif block_type == BlockType.LIST:
+            list_blocks.append(block)
+        elif block_type == BlockType.INDEX:
+            index_blocks.append(block)
+    return text_blocks, ref_text_blocks, list_blocks, index_blocks
+
+
+def _prepare_lists_and_indices(
+    blocks: list[BlockDict],
+    *,
+    use_bbox: bool,
+) -> tuple[list[BlockDict], list[BlockDict], list[BlockDict], list[BlockDict]]:
+    """根据文档类型整理列表、目录以及被列表吸收的文本块。"""
+    text_blocks, ref_text_blocks, list_blocks, index_blocks = _partition_textual_blocks(blocks)
+    if use_bbox:
+        list_blocks, text_blocks, ref_text_blocks = fix_pdf_list_blocks(
+            list_blocks,
+            text_blocks,
+            ref_text_blocks,
+        )
+        index_blocks = fix_pdf_index_blocks(index_blocks)
+    else:
+        list_blocks = fix_office_list_blocks(list_blocks)
+        index_blocks = fix_office_index_blocks(index_blocks)
+    return text_blocks, ref_text_blocks, list_blocks, index_blocks
+
+
+def _finalize_code_blocks(code_blocks: list[BlockDict]) -> None:
+    """确定代码语言，并把算法唯一主体切换为 algorithm_body。"""
+    for code_block in code_blocks:
+        if code_block["sub_type"] == RAW_ALGORITHM:
+            for sub_block in code_block["content"]:
+                if sub_block.get("type") == BlockType.CODE_BODY:
+                    sub_block["type"] = BlockType.ALGORITHM_BODY
+                    break
+            continue
+        guess_lang = code_block.get("guess_lang")
+        if isinstance(guess_lang, str) and guess_lang.strip():
+            code_block["guess_lang"] = guess_lang.strip()
+            continue
+        for sub_block in code_block["content"]:
+            if sub_block.get("type") == BlockType.CODE_BODY:
+                code_block["guess_lang"] = guess_code_language(sub_block.get("content", ""))
+                break
+
+
+def process_page_blocks(
+    page_model_list: list[BlockDict],
+    *,
+    use_bbox: bool | None = None,
+) -> list[BlockDict]:
+    """按固定阶段将单页 raw model-list 转换为可对象化的顶层 blocks。"""
+    resolved_use_bbox = any(block.get("bbox") for block in page_model_list) if use_bbox is None else use_bbox
+    blocks = _normalize_raw_blocks(page_model_list)
+    _apply_caption_fallbacks(blocks, use_bbox=resolved_use_bbox)
+    text_blocks, ref_text_blocks, list_blocks, index_blocks = _prepare_lists_and_indices(
+        blocks,
+        use_bbox=resolved_use_bbox,
+    )
+    visual_groups, unmatched_child_blocks = regroup_visual_blocks(
+        blocks,
+        use_bbox=resolved_use_bbox,
+    )
+    image_blocks = visual_groups[BlockType.IMAGE]
+    table_blocks = visual_groups[BlockType.TABLE]
+    chart_blocks = visual_groups[BlockType.CHART]
+    code_blocks = visual_groups[BlockType.CODE]
+    _finalize_code_blocks(code_blocks)
+    for block in unmatched_child_blocks:
+        block["type"] = BlockType.TEXT
+        text_blocks.append(block)
+
+    result = [block for block in blocks if block["type"] not in _REPLACED_BLOCK_TYPES]
+    result.extend(
+        list_blocks + text_blocks + ref_text_blocks + index_blocks + image_blocks + table_blocks + chart_blocks + code_blocks
+    )
+    return result

docvortex/postprocess/pages.py

@@ -0,0 +1,95 @@
+"""严格 ModelJson 到 PageInfo 列表的唯一转换边界。"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+from pydantic import TypeAdapter
+
+from .lists import fix_office_index_title_blocks, fix_office_paragraph_titles
+from .page_blocks import process_page_blocks
+from .paragraphs import merge_para_text_blocks
+from ..content.table import merge_table
+from ..schema import ModelJson, PageInfo
+
+PAGE_INFO_LIST_ADAPTER = TypeAdapter(list[PageInfo])
+
+
+def _document_uses_bbox(model_list: list[list[dict[str, Any]]]) -> bool:
+    """按整份文档是否出现 bbox 判定 PDF/Office，避免空白首页误判。"""
+    return any(
+        block.get("bbox") is not None for page_model_list in model_list for block in page_model_list if isinstance(block, dict)
+    )
+
+
+def _remove_private_block_metadata(block: dict[str, Any]) -> None:
+    """递归清除对象化边界之前仅供 Analyze 计算使用的临时字段。"""
+    for field_name in ("lines", "_lines", "angle", "score", "label"):
+        block.pop(field_name, None)
+    content = block.get("content")
+    if isinstance(content, list):
+        for child in content:
+            if isinstance(child, dict):
+                _remove_private_block_metadata(child)
+
+
+def _blocks_to_raw_page_info(
+    page_model_list: list[dict[str, Any]],
+    *,
+    page_idx: int,
+    use_bbox: bool,
+) -> dict[str, Any]:
+    """运行单页后处理流水线并保留 raw dict，供跨页处理继续消费。"""
+    page_blocks = process_page_blocks(page_model_list, use_bbox=use_bbox)
+    page_blocks.sort(key=lambda block: block["index"])
+    return {"page_idx": page_idx, "blocks": page_blocks}
+
+
+def blocks_to_page_info(
+    page_model_list: list[dict[str, Any]],
+    *,
+    page_idx: int = 0,
+    use_bbox: bool | None = None,
+) -> PageInfo:
+    """无副作用地把单页 raw blocks 转换为严格 PageInfo 对象。"""
+    copied_blocks = deepcopy(page_model_list)
+    resolved_use_bbox = _document_uses_bbox([copied_blocks]) if use_bbox is None else use_bbox
+    if not resolved_use_bbox:
+        fix_office_paragraph_titles([copied_blocks])
+        fix_office_index_title_blocks([copied_blocks])
+    raw_page = _blocks_to_raw_page_info(
+        copied_blocks,
+        page_idx=page_idx,
+        use_bbox=resolved_use_bbox,
+    )
+    for block in raw_page["blocks"]:
+        _remove_private_block_metadata(block)
+    return PageInfo.model_validate(raw_page)
+
+
+def model_json_to_pages(model_json: ModelJson) -> list[PageInfo]:
+    """从严格 ModelJson 无副作用地构造可递归序列化的 PageInfo。"""
+    page_indices = model_json.resolved_page_indices
+    copied_model_list = deepcopy(model_json.pages)
+    use_bbox = _document_uses_bbox(copied_model_list)
+    if not use_bbox:
+        fix_office_paragraph_titles(copied_model_list)
+        fix_office_index_title_blocks(copied_model_list)
+
+    raw_pages = [
+        _blocks_to_raw_page_info(
+            page_model_list,
+            page_idx=page_idx,
+            use_bbox=use_bbox,
+        )
+        for page_model_list, page_idx in zip(copied_model_list, page_indices, strict=True)
+    ]
+    if use_bbox:
+        merge_para_text_blocks(raw_pages)
+        merge_table(raw_pages)
+
+    for page in raw_pages:
+        for block in page["blocks"]:
+            _remove_private_block_metadata(block)
+    return PAGE_INFO_LIST_ADAPTER.validate_python(raw_pages)