docvortex 0.2.1__py3-none-any.whl

docvortex/analyzers/native/office/doc/doc_converter.py

@@ -0,0 +1,573 @@
+"""把 Word 97–2003 语义模型转换为 DocVortex 分页 model-list。"""
+
+from __future__ import annotations
+
+from html import escape
+import re
+from typing import Any, BinaryIO, Iterable
+
+from ..errors import LegacyOfficeEncryptedError
+from ..image import serialize_office_image
+from ..legacy.ole import BoundedOleReader
+from ..streams import read_stream_bytes_from_start
+from .....schema import RAW_CAPTION, BlockType
+from .....content.spans import append_equation_span, extend_inline_spans, inline_span_plain_text, strip_span_dicts, text_spans
+from ..rich_text import OfficeRichTextSegment, build_rich_text_from_segments, build_rich_text_html_from_segments
+
+from .fib import parse_fib
+from ..equation.mtef import read_object_pool_equations
+from ..xls.embedded_chart import extract_embedded_chart_html
+from .models import (
+    DocCharStyle,
+    DocChartPayload,
+    DocDocument,
+    DocElement,
+    DocImage,
+    DocImagePayload,
+    DocParagraph,
+    DocSection,
+    DocTable,
+    DocTableCell,
+    DocTextRun,
+    DocVisualPayload,
+)
+from .parser import parse_doc_document
+
+_OBJECT_POOL_CHART_RE = re.compile(
+    r"^ObjectPool/_([0-9]+)/(?:Workbook|Book)$",
+    re.IGNORECASE,
+)
+
+
+def _read_object_pool_charts(ole: BoundedOleReader) -> dict[int, str]:
+    """读取 DOC ObjectPool 中带 Workbook/Book 的可编辑 chart。"""
+
+    charts: dict[int, str] = {}
+    for stream_name in ole.stream_names(prefix="ObjectPool/"):
+        match = _OBJECT_POOL_CHART_RE.match(stream_name)
+        if match is None:
+            continue
+        storage_id = int(match.group(1))
+        if storage_id in charts:
+            continue
+        content = extract_embedded_chart_html(ole.read_stream(stream_name))
+        if content:
+            charts[storage_id] = content
+    return charts
+
+
+class DocConverter:
+    """将 Word 97–2003 OLE 二进制流转换为逐 section raw blocks。"""
+
+    def __init__(self) -> None:
+        """初始化空输出。"""
+
+        self.pages: list[list[dict[str, Any]]] = []
+
+    def convert(self, file_binary: BinaryIO) -> None:
+        """读取输入 OLE streams，解析 DOC 并生成 model-list。"""
+
+        file_bytes = read_stream_bytes_from_start(file_binary)
+        with BoundedOleReader(file_bytes) as ole:
+            if ole.has_stream("EncryptedPackage") or ole.has_stream("EncryptionInfo"):
+                raise LegacyOfficeEncryptedError("encrypted OOXML package is not a binary DOC")
+            word_document = ole.read_stream("WordDocument")
+            fib = parse_fib(word_document)
+            if fib.base.encrypted or fib.base.obfuscated:
+                raise LegacyOfficeEncryptedError("password-protected DOC is unsupported")
+            preferred = "1Table" if fib.base.uses_1table else "0Table"
+            alternate = "0Table" if preferred == "1Table" else "1Table"
+            table_stream = ole.read_stream(preferred, required=False)
+            if not table_stream:
+                table_stream = ole.read_stream(alternate, required=bool(fib.base.complex))
+            data_stream = ole.read_stream("Data", required=False)
+            native_equations = read_object_pool_equations(ole)
+            native_charts = _read_object_pool_charts(ole)
+            document = parse_doc_document(
+                word_document,
+                table_stream,
+                data_stream,
+                fib,
+                native_equations=native_equations,
+                native_charts=native_charts,
+            )
+        self.pages = self._document_pages(document)
+
+    @staticmethod
+    def _style_names(style: DocCharStyle) -> list[str]:
+        """把 DOC 字符属性转换为 DocVortex 富文本样式名。"""
+
+        names: list[str] = []
+        if style.bold:
+            names.append("bold")
+        if style.italic:
+            names.append("italic")
+        if style.underline:
+            names.append("underline")
+        if style.emphasis:
+            names.append("emphasis")
+        if style.strike:
+            names.append("strikethrough")
+        if style.superscript:
+            names.append("superscript")
+        elif style.subscript:
+            names.append("subscript")
+        return names
+
+    @classmethod
+    def _rich_text(cls, runs: Iterable[DocTextRun], *, trim: bool = True) -> list[dict[str, Any]]:
+        """把 DOC runs 直接转换为结构化 Span。"""
+
+        spans: list[dict[str, Any]] = []
+        segments: list[OfficeRichTextSegment] = []
+
+        def flush_segments() -> None:
+            """输出公式边界前累计的普通富文本。"""
+
+            if not segments:
+                return
+            extend_inline_spans(spans, build_rich_text_from_segments(segments, trim_plain_edges=trim and not spans))
+            segments.clear()
+
+        for run in runs:
+            if not run.text:
+                continue
+            if run.formula:
+                flush_segments()
+                latex = run.text.replace("<", r"\lt ").replace(">", r"\gt ")
+                append_equation_span(spans, latex)
+                continue
+            segments.append(
+                OfficeRichTextSegment(
+                    text=run.text,
+                    style=cls._style_names(run.style),
+                    hyperlink=run.hyperlink,
+                )
+            )
+        flush_segments()
+        return strip_span_dicts(spans) if trim else spans
+
+    @classmethod
+    def _cell_rich_text_html(cls, runs: Iterable[DocTextRun], *, trim: bool = True) -> str:
+        """把 DOC 表格单元格 runs 序列化为安全 HTML。"""
+        parts: list[str] = []
+        segments: list[OfficeRichTextSegment] = []
+
+        def flush_segments() -> None:
+            """在公式边界输出累计单元格文字。"""
+            if not segments:
+                return
+            parts.append(build_rich_text_html_from_segments(segments, trim_plain_edges=trim and not parts))
+            segments.clear()
+
+        for run in runs:
+            if not run.text:
+                continue
+            if run.formula:
+                flush_segments()
+                latex = run.text.replace("<", r"\lt ").replace(">", r"\gt ")
+                parts.append(f"<eq>{escape(latex, quote=False)}</eq>")
+                continue
+            segments.append(
+                OfficeRichTextSegment(
+                    text=run.text,
+                    style=cls._style_names(run.style),
+                    hyperlink=run.hyperlink,
+                )
+            )
+        flush_segments()
+        return "".join(parts)
+
+    @staticmethod
+    def _plain_text(paragraph: DocParagraph) -> str:
+        """返回段落不含内部标记的可见文本。"""
+
+        return "".join(run.text for run in paragraph.runs)
+
+    @staticmethod
+    def _serialize_image(payload: DocImagePayload) -> str | None:
+        """复用 Office 图片序列化与矢量占位策略。"""
+
+        return serialize_office_image(
+            payload.data,
+            part_name=f"image.{payload.extension}",
+            content_type=payload.content_type,
+            render_size_emu=payload.render_size_emu,
+        )
+
+    @classmethod
+    def _image_block(cls, payload: DocVisualPayload) -> dict[str, Any] | None:
+        """把图片、公式或 chart 载荷转换为对应 raw block。"""
+
+        if isinstance(payload, DocChartPayload):
+            block: dict[str, Any] = {
+                "type": BlockType.CHART,
+                "content": payload.content,
+            }
+            if payload.preview is not None:
+                image_base64 = cls._serialize_image(payload.preview)
+                if image_base64:
+                    block["image_base64"] = image_base64
+            return block
+
+        if payload.equation_latex:
+            return {
+                "type": BlockType.EQUATION,
+                "content": payload.equation_latex,
+            }
+
+        image_base64 = cls._serialize_image(payload)
+        if image_base64 is None:
+            return None
+        return {"type": BlockType.IMAGE, "image_base64": image_base64}
+
+    @classmethod
+    def _toc_runs(cls, paragraph: DocParagraph) -> list[DocTextRun]:
+        """从 TOC 段落末尾移除仅用于排版的 tab/page number。"""
+
+        runs = list(paragraph.runs)
+        while runs and re.fullmatch(r"[\s\t]*\d+[\s\t]*", runs[-1].text):
+            runs.pop()
+        if runs:
+            cleaned = re.sub(r"\t+\s*\d+\s*$", "", runs[-1].text)
+            if cleaned != runs[-1].text:
+                last = runs[-1]
+                runs[-1] = DocTextRun(cleaned, last.style, last.hyperlink)
+        return runs
+
+    @classmethod
+    def _toc_anchor(cls, paragraph: DocParagraph) -> str | None:
+        """读取 TOC 超链接指向的内部书签。"""
+
+        for run in paragraph.runs:
+            if run.hyperlink and run.hyperlink.startswith("#") and len(run.hyperlink) > 1:
+                return run.hyperlink[1:]
+        return paragraph.anchor
+
+    @classmethod
+    def _append_index_item(
+        cls,
+        page: list[dict[str, Any]],
+        stack: list[dict[str, Any]],
+        paragraph: DocParagraph,
+    ) -> None:
+        """把一个 TOC 段落追加到对应层级的 index 树。"""
+
+        content = cls._rich_text(cls._toc_runs(paragraph))
+        for payload in paragraph.images:
+            if isinstance(payload, DocImagePayload) and payload.equation_latex:
+                append_equation_span(content, payload.equation_latex)
+        if not content:
+            return
+        level = min(max(paragraph.toc_level or 0, 0), 8)
+        while len(stack) > level + 1:
+            stack.pop()
+        while len(stack) < level + 1:
+            index_block: dict[str, Any] = {
+                "type": BlockType.INDEX,
+                "ilevel": len(stack),
+                "content": [],
+            }
+            if stack:
+                stack[-1]["content"].append(index_block)
+            else:
+                page.append(index_block)
+            stack.append(index_block)
+        leaf: dict[str, Any] = {"type": BlockType.TEXT, "content": content}
+        anchor = cls._toc_anchor(paragraph)
+        if anchor:
+            leaf["anchor"] = anchor
+        stack[level]["content"].append(leaf)
+
+    @classmethod
+    def _append_list_item(
+        cls,
+        page: list[dict[str, Any]],
+        stack: list[dict[str, Any]],
+        identity: int | None,
+        paragraph: DocParagraph,
+    ) -> int:
+        """把一个 DOC 列表段落追加到嵌套 raw list 树。"""
+
+        info = paragraph.list_info
+        if info is None:
+            return identity or -1
+        content = cls._rich_text(paragraph.runs)
+        for payload in paragraph.images:
+            if isinstance(payload, DocImagePayload) and payload.equation_latex:
+                append_equation_span(content, payload.equation_latex)
+        if not content and not paragraph.images:
+            return identity or info.identity
+        if identity != info.identity:
+            stack.clear()
+            identity = info.identity
+        level = min(max(info.level, 0), 8)
+        while len(stack) > level + 1:
+            stack.pop()
+        while len(stack) < level + 1:
+            list_block: dict[str, Any] = {
+                "type": BlockType.LIST,
+                "attribute": "ordered" if info.ordered else "unordered",
+                "ilevel": len(stack),
+                "content": [],
+            }
+            if info.ordered:
+                list_block["start"] = info.start
+            if stack:
+                stack[-1]["content"].append(list_block)
+            else:
+                page.append(list_block)
+            stack.append(list_block)
+        current = stack[level]
+        expected = "ordered" if info.ordered else "unordered"
+        if current.get("attribute") != expected:
+            del stack[level:]
+            return cls._append_list_item(page, stack, None, paragraph)
+        if content:
+            leaf: dict[str, Any] = {"type": BlockType.TEXT, "content": content}
+            if info.label:
+                leaf["list_label"] = info.label
+            current["content"].append(leaf)
+        return info.identity
+
+    @classmethod
+    def _paragraph_blocks(cls, paragraph: DocParagraph) -> list[dict[str, Any]]:
+        """把非目录、非普通列表段落投影为 raw blocks。"""
+
+        content = cls._rich_text(paragraph.runs)
+        blocks: list[dict[str, Any]] = []
+        formula_runs = [run for run in paragraph.runs if run.formula and run.text]
+        ordinary_text = "".join(run.text for run in paragraph.runs if not run.formula).strip()
+        list_info = paragraph.list_info
+        exact_label = list_info.label if list_info is not None and list_info.ordered else None
+        if exact_label and (paragraph.is_title or paragraph.heading_level is not None):
+            content = [*text_spans(f"{exact_label} "), *content]
+        if (
+            formula_runs
+            and not ordinary_text
+            and not (paragraph.is_title or paragraph.heading_level is not None or paragraph.is_caption or paragraph.is_code)
+        ):
+            blocks.extend({"type": BlockType.EQUATION, "content": run.text} for run in formula_runs)
+        elif content:
+            if paragraph.is_title:
+                block: dict[str, Any] = {
+                    "type": BlockType.DOC_TITLE,
+                    "level": 1,
+                    "content": content,
+                }
+            elif paragraph.heading_level is not None:
+                block = {
+                    "type": BlockType.PARAGRAPH_TITLE,
+                    "level": min(max(paragraph.heading_level + 1, 2), 6),
+                    "is_numbered_style": False,
+                    "content": content,
+                }
+            elif paragraph.is_caption:
+                block = {"type": RAW_CAPTION, "content": content}
+            elif paragraph.is_code:
+                block = {"type": BlockType.CODE, "content": cls._plain_text(paragraph)}
+            else:
+                block = {"type": BlockType.TEXT, "content": content}
+            if paragraph.anchor and block["type"] in {BlockType.DOC_TITLE, BlockType.PARAGRAPH_TITLE}:
+                block["anchor"] = paragraph.anchor
+            blocks.append(block)
+        for payload in paragraph.images:
+            image = cls._image_block(payload)
+            if image is not None:
+                blocks.append(image)
+        return blocks
+
+    @classmethod
+    def _cell_list_html(cls, paragraphs: list[DocParagraph]) -> str:
+        """把连续表格单元格列表段落序列化为嵌套 HTML list。"""
+
+        result: list[str] = []
+        stack: list[str] = []
+        for paragraph in paragraphs:
+            info = paragraph.list_info
+            if info is None:
+                while stack:
+                    result.append(f"</{stack.pop()}>")
+                result.append(cls._cell_paragraph_html(paragraph))
+                continue
+            level = min(max(info.level, 0), 8)
+            tag = "ol" if info.ordered else "ul"
+            while len(stack) > level + 1:
+                result.append(f"</{stack.pop()}>")
+            while len(stack) < level + 1:
+                result.append(f"<{tag}>")
+                stack.append(tag)
+            if stack[-1] != tag:
+                result.append(f"</{stack.pop()}><{tag}>")
+                stack.append(tag)
+            label = f"{escape(info.label)} " if info.label and info.ordered else ""
+            result.append(
+                f"<li>{label}{cls._cell_rich_text_html(paragraph.runs)}{cls._cell_images_html(paragraph.images)}</li>"
+            )
+        while stack:
+            result.append(f"</{stack.pop()}>")
+        return "".join(result)
+
+    @classmethod
+    def _cell_paragraph_html(cls, paragraph: DocParagraph) -> str:
+        """序列化一个表格单元格段落及其内联图片。"""
+
+        parts: list[str] = []
+        content = cls._cell_rich_text_html(paragraph.runs, trim=False)
+        if content:
+            parts.append(f"<p>{content}</p>")
+        parts.append(cls._cell_images_html(paragraph.images))
+        return "".join(parts)
+
+    @classmethod
+    def _cell_images_html(
+        cls,
+        payloads: list[DocVisualPayload],
+    ) -> str:
+        """把表格段落中的图片或 comment 公式序列化为内联 HTML。"""
+
+        parts: list[str] = []
+        for payload in payloads:
+            if isinstance(payload, DocChartPayload):
+                if payload.preview is not None:
+                    image = cls._serialize_image(payload.preview)
+                    if image:
+                        parts.append(f'<img src="{escape(image, quote=True)}"/>')
+                parts.append(payload.content)
+                continue
+            if payload.equation_latex:
+                parts.append(f"<eq>{escape(payload.equation_latex, quote=False)}</eq>")
+                continue
+            image = cls._serialize_image(payload)
+            if image:
+                parts.append(f'<img src="{escape(image, quote=True)}"/>')
+        return "".join(parts)
+
+    @classmethod
+    def _cell_html(cls, cell: DocTableCell) -> str:
+        """递归序列化单元格中的段落和嵌套表格。"""
+
+        parts: list[str] = []
+        paragraph_buffer: list[DocParagraph] = []
+
+        def flush() -> None:
+            """输出当前连续段落缓冲。"""
+
+            nonlocal paragraph_buffer
+            if paragraph_buffer:
+                parts.append(cls._cell_list_html(paragraph_buffer))
+                paragraph_buffer = []
+
+        for block in cell.blocks:
+            if isinstance(block, DocParagraph):
+                paragraph_buffer.append(block)
+            elif isinstance(block, DocTable):
+                flush()
+                parts.append(cls._table_html(block))
+            elif isinstance(block, DocImage):
+                flush()
+                if block.payload.equation_latex:
+                    parts.append(f"<eq>{escape(block.payload.equation_latex, quote=False)}</eq>")
+                    continue
+                image = cls._serialize_image(block.payload)
+                if image:
+                    parts.append(f'<img src="{escape(image, quote=True)}"/>')
+        flush()
+        return "".join(parts)
+
+    @classmethod
+    def _table_html(cls, table: DocTable) -> str:
+        """序列化带 rowspan/colspan 及嵌套内容的 Word 表格。"""
+
+        rows: list[str] = []
+        for row in table.rows:
+            tag = "th" if row.header else "td"
+            cells: list[str] = []
+            for cell in row.cells:
+                attributes: list[str] = []
+                if cell.row_span > 1:
+                    attributes.append(f'rowspan="{cell.row_span}"')
+                if cell.col_span > 1:
+                    attributes.append(f'colspan="{cell.col_span}"')
+                suffix = f" {' '.join(attributes)}" if attributes else ""
+                cells.append(f"<{tag}{suffix}>{cls._cell_html(cell)}</{tag}>")
+            rows.append(f"<tr>{''.join(cells)}</tr>")
+        return f"<table>{''.join(rows)}</table>"
+
+    @classmethod
+    def _element_blocks(cls, element: DocElement) -> list[dict[str, Any]]:
+        """把正文语义元素转换为 raw block。"""
+
+        if isinstance(element, DocImage):
+            image = cls._image_block(element.payload)
+            return [image] if image is not None else []
+        if isinstance(element, DocTable):
+            return [{"type": BlockType.TABLE, "content": cls._table_html(element)}]
+        return cls._paragraph_blocks(element)
+
+    @classmethod
+    def _auxiliary_contents(cls, paragraphs: list[DocParagraph]) -> list[list[dict[str, Any]]]:
+        """去重页眉页脚段落并过滤纯页码。"""
+
+        result: list[list[dict[str, Any]]] = []
+        seen: set[str] = set()
+        for paragraph in paragraphs:
+            content = cls._rich_text(paragraph.runs)
+            plain = cls._plain_text(paragraph).strip()
+            visible = inline_span_plain_text(content)
+            if not content or plain.isdigit() or visible in seen:
+                continue
+            seen.add(visible)
+            result.append(content)
+        return result
+
+    @classmethod
+    def _section_page(cls, section: DocSection) -> list[dict[str, Any]]:
+        """转换一个 section，并将页面辅助文本稳定追加到末尾。"""
+
+        page: list[dict[str, Any]] = []
+        list_stack: list[dict[str, Any]] = []
+        list_identity: int | None = None
+        index_stack: list[dict[str, Any]] = []
+        for element in section.elements:
+            if isinstance(element, DocParagraph) and element.is_toc:
+                list_stack.clear()
+                list_identity = None
+                cls._append_index_item(page, index_stack, element)
+                for payload in element.images:
+                    if isinstance(payload, DocImagePayload) and payload.equation_latex:
+                        continue
+                    image = cls._image_block(payload)
+                    if image is not None:
+                        page.append(image)
+                continue
+            index_stack.clear()
+            if (
+                isinstance(element, DocParagraph)
+                and element.list_info is not None
+                and not (element.is_title or element.heading_level is not None)
+            ):
+                list_identity = cls._append_list_item(page, list_stack, list_identity, element)
+                for payload in element.images:
+                    if isinstance(payload, DocImagePayload) and payload.equation_latex:
+                        continue
+                    image = cls._image_block(payload)
+                    if image is not None:
+                        page.append(image)
+                continue
+            list_stack.clear()
+            list_identity = None
+            page.extend(cls._element_blocks(element))
+        page.extend({"type": BlockType.HEADER, "content": content} for content in cls._auxiliary_contents(section.headers))
+        page.extend({"type": BlockType.FOOTER, "content": content} for content in cls._auxiliary_contents(section.footers))
+        page.extend(
+            {"type": BlockType.PAGE_FOOTNOTE, "content": content} for content in cls._auxiliary_contents(section.footnotes)
+        )
+        return page
+
+    @classmethod
+    def _document_pages(cls, document: DocDocument) -> list[list[dict[str, Any]]]:
+        """转换整份 DOC，并至少保留一个空 section page。"""
+
+        pages = [cls._section_page(section) for section in document.sections]
+        return pages or [[]]