docvortex 0.2.1__py3-none-any.whl

docvortex/analyzers/native/html/selector.py

@@ -0,0 +1,421 @@
+"""基于静态 DOM 指标执行保守的 HTML 正文自动选择。"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+import re
+
+from lxml import etree  # type: ignore[reportMissingImports]
+
+from docvortex.content.markup import MarkupStylesheet, TextStyle
+from docvortex.content.markup.projector import local_name
+
+
+_CANDIDATE_TAGS = frozenset({"article", "div", "main", "section"})
+_SEMANTIC_TAGS = frozenset({"figure", "img", "math", "pre", "svg", "table"})
+_PARAGRAPH_TAGS = frozenset({"dd", "dt", "li", "p", "pre"})
+_BOILERPLATE_TAGS = frozenset({"footer", "form", "nav"})
+_POSITIVE_TOKENS = frozenset({"article", "body", "content", "entry", "main", "post", "story", "text"})
+_NEGATIVE_TOKENS = frozenset(
+    {
+        "advert",
+        "banner",
+        "comment",
+        "cookie",
+        "footer",
+        "menu",
+        "nav",
+        "newsletter",
+        "related",
+        "share",
+        "sidebar",
+        "social",
+        "widget",
+    }
+)
+_TOKEN_RE = re.compile(r"[^a-z0-9]+")
+_MIN_TEXT_CHARS = 200
+_MIN_SEMANTIC_OBJECTS = 2
+_MIN_RETAINED_RATIO = 1 / 7
+_MIN_SCORE_MARGIN = 1.25
+
+
+@dataclass(frozen=True, slots=True)
+class CandidateMetrics:
+    """保存一个 DOM 子树的可见正文与噪声统计。"""
+
+    text_chars: int = 0
+    link_chars: int = 0
+    paragraph_chars: int = 0
+    heading_count: int = 0
+    semantic_count: int = 0
+    boilerplate_count: int = 0
+
+    def __add__(self, other: CandidateMetrics) -> CandidateMetrics:
+        """合并两个子树指标。"""
+        return CandidateMetrics(
+            text_chars=self.text_chars + other.text_chars,
+            link_chars=self.link_chars + other.link_chars,
+            paragraph_chars=self.paragraph_chars + other.paragraph_chars,
+            heading_count=self.heading_count + other.heading_count,
+            semantic_count=self.semantic_count + other.semantic_count,
+            boilerplate_count=self.boilerplate_count + other.boilerplate_count,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ContentSelection:
+    """保存最终内容根、正文命中状态和可诊断的保留率。"""
+
+    root: etree._Element
+    mode_used: str
+    confidence: float
+    retained_text_ratio: float
+    reason: str
+
+
+@dataclass(frozen=True, slots=True)
+class _ScoredCandidate:
+    """绑定候选元素、指标、分数和显式语义标记。"""
+
+    element: etree._Element
+    metrics: CandidateMetrics
+    score: float
+    explicit: bool
+
+
+@dataclass(frozen=True, slots=True)
+class _SoftPruneMetrics:
+    """保存 soft prune 所需的规范文本段、链接文本和语义对象统计。"""
+
+    text_chars: int = 0
+    text_segments: int = 0
+    link_chars: int = 0
+    link_count: int = 0
+    semantic_count: int = 0
+
+
+def select_auto_content(body: etree._Element, stylesheet: MarkupStylesheet) -> ContentSelection:
+    """高置信选择正文候选，任一保守门槛失败时回退完整 body。"""
+    metrics_by_element: dict[etree._Element, CandidateMetrics] = {}
+    body_metrics = _collect_metrics(body, stylesheet, metrics_by_element, TextStyle(), False, False)
+    repeated_penalties = _repeated_short_sibling_penalties(body)
+    candidates: list[_ScoredCandidate] = []
+    for element in body.iter():
+        if not isinstance(element.tag, str) or element is body:
+            continue
+        name = local_name(element)
+        metrics = metrics_by_element.get(element, CandidateMetrics())
+        explicit = _is_explicit_candidate(element)
+        if name not in _CANDIDATE_TAGS and not explicit:
+            continue
+        if not explicit and metrics.text_chars < _MIN_TEXT_CHARS and metrics.semantic_count < _MIN_SEMANTIC_OBJECTS:
+            continue
+        candidates.append(
+            _ScoredCandidate(
+                element,
+                metrics,
+                _candidate_score(element, metrics, repeated_penalties.get(element, 0)),
+                explicit,
+            )
+        )
+    candidates.sort(key=lambda item: (-item.score, _document_order(item.element)))
+    repeated_candidate_items = _repeated_candidate_items(candidates, metrics_by_element)
+
+    for candidate in candidates:
+        if candidate.score <= 0:
+            continue
+        if candidate.element in repeated_candidate_items:
+            continue
+        second = next(
+            (
+                item
+                for item in candidates
+                if item is not candidate and item.score > 0 and not _is_containment_equivalent(candidate, item)
+            ),
+            None,
+        )
+        if not candidate.explicit and second is not None and candidate.score < second.score * _MIN_SCORE_MARGIN:
+            continue
+        selected = _copy_candidate_with_ancestors(candidate.element, body)
+        selected_metrics: dict[etree._Element, CandidateMetrics] = {}
+        final_metrics = _collect_metrics(selected, stylesheet, selected_metrics, TextStyle(), False, False)
+        retained_ratio = final_metrics.text_chars / max(1, body_metrics.text_chars)
+        if final_metrics.text_chars < _MIN_TEXT_CHARS and final_metrics.semantic_count < _MIN_SEMANTIC_OBJECTS:
+            continue
+        if body_metrics.text_chars >= _MIN_TEXT_CHARS and retained_ratio < _MIN_RETAINED_RATIO:
+            continue
+        if candidate.metrics.semantic_count and final_metrics.semantic_count == 0:
+            continue
+        confidence = candidate.score / max(candidate.score + (second.score if second is not None else 0), 1)
+        return ContentSelection(selected, "main", confidence, retained_ratio, "high_confidence_candidate")
+
+    return ContentSelection(deepcopy(body), "document", 0.0, 1.0, "body_fallback")
+
+
+def _copy_candidate_with_ancestors(candidate: etree._Element, body: etree._Element) -> etree._Element:
+    """复制正文候选及其到 body 的空祖先链，保留继承样式但不带入周边正文。"""
+    selected = deepcopy(candidate)
+    selected.tail = None
+    _soft_prune(selected)
+    root = selected
+    for ancestor in candidate.iterancestors():
+        if not isinstance(ancestor.tag, str):
+            continue
+        wrapper = _empty_ancestor_wrapper(ancestor)
+        wrapper.append(root)
+        root = wrapper
+        if ancestor is body:
+            return root
+    return root
+
+
+def _empty_ancestor_wrapper(ancestor: etree._Element) -> etree._Element:
+    """复制祖先标签和属性；非法 HTML QName 使用安全 div，避免复制整棵兄弟子树。"""
+    try:
+        wrapper = etree.Element(ancestor.tag, nsmap=ancestor.nsmap)
+    except ValueError:
+        wrapper = etree.Element("div", nsmap=ancestor.nsmap)
+    for name, value in ancestor.attrib.items():
+        try:
+            wrapper.set(name, value)
+        except ValueError:
+            continue
+    return wrapper
+
+
+def _collect_metrics(
+    element: etree._Element,
+    stylesheet: MarkupStylesheet,
+    output: dict[etree._Element, CandidateMetrics],
+    inherited: TextStyle,
+    inherited_visibility_hidden: bool,
+    inside_link: bool,
+) -> CandidateMetrics:
+    """单次深度优先遍历计算所有元素的可见指标，避免候选间重复扫描。"""
+    resolved = stylesheet.resolve(element, inherited, inherited_visibility_hidden)
+    if resolved.subtree_hidden:
+        output[element] = CandidateMetrics()
+        return output[element]
+    name = local_name(element)
+    current_inside_link = inside_link or name == "a"
+    own_text = 0 if resolved.visibility_hidden else len(_normalized_text(element.text))
+    metrics = CandidateMetrics(
+        text_chars=own_text,
+        link_chars=own_text if current_inside_link else 0,
+        paragraph_chars=own_text if name in _PARAGRAPH_TAGS else 0,
+        heading_count=1 if name in {"h1", "h2", "h3", "h4", "h5", "h6"} else 0,
+        semantic_count=1 if name in _SEMANTIC_TAGS else 0,
+        boilerplate_count=1 if name in _BOILERPLATE_TAGS or bool(_tokens(element) & _NEGATIVE_TOKENS) else 0,
+    )
+    for child in element:
+        if isinstance(child.tag, str):
+            metrics += _collect_metrics(
+                child,
+                stylesheet,
+                output,
+                resolved.text,
+                resolved.visibility_hidden,
+                current_inside_link,
+            )
+        if not resolved.visibility_hidden:
+            tail_chars = len(_normalized_text(child.tail))
+            metrics += CandidateMetrics(
+                text_chars=tail_chars,
+                link_chars=tail_chars if current_inside_link else 0,
+                paragraph_chars=tail_chars if name in _PARAGRAPH_TAGS else 0,
+            )
+    output[element] = metrics
+    return metrics
+
+
+def _candidate_score(element: etree._Element, metrics: CandidateMetrics, repeated_penalty: int) -> float:
+    """按正文、结构对象、链接与模板噪声计算确定性候选分数。"""
+    tokens = _tokens(element)
+    token_bonus = 200 if tokens & _POSITIVE_TOKENS else 0
+    token_penalty = 240 if tokens & _NEGATIVE_TOKENS else 0
+    link_density = metrics.link_chars / max(1, metrics.text_chars)
+    return (
+        metrics.text_chars
+        + metrics.paragraph_chars
+        + metrics.heading_count * 40
+        + metrics.semantic_count * 120
+        + token_bonus
+        - metrics.link_chars * (1.0 + link_density)
+        - metrics.boilerplate_count * 120
+        - repeated_penalty * 80
+        - token_penalty
+    )
+
+
+def _is_explicit_candidate(element: etree._Element) -> bool:
+    """识别标准语义 main/article/role/itemprop 正文候选。"""
+    name = local_name(element)
+    roles = frozenset((element.get("role") or "").casefold().split())
+    itemprop = frozenset((element.get("itemprop") or "").casefold().split())
+    return name in {"main", "article"} or "main" in roles or "articlebody" in itemprop
+
+
+def _tokens(element: etree._Element) -> frozenset[str]:
+    """把 class/id 拆成完整小写 token，避免任意 substring 误判。"""
+    value = f"{element.get('id') or ''} {element.get('class') or ''}".casefold()
+    return frozenset(token for token in _TOKEN_RE.split(value) if token)
+
+
+def _repeated_short_sibling_penalties(root: etree._Element) -> dict[etree._Element, int]:
+    """单次后序遍历预计算各子树的重复短同级惩罚，供嵌套候选共享。"""
+    elements = [element for element in root.iter() if isinstance(element.tag, str)]
+    short_text_lengths: dict[etree._Element, int] = {}
+    penalties: dict[etree._Element, int] = {}
+    for parent in reversed(elements):
+        text_length = min(len(_normalized_text(parent.text)), 161)
+        subtree_penalty = 0
+        groups: dict[tuple[str, tuple[str, ...]], int] = {}
+        for child in parent:
+            if isinstance(child.tag, str):
+                child_text_length = short_text_lengths[child]
+                if child_text_length:
+                    text_length = min(text_length + (1 if text_length else 0) + child_text_length, 161)
+                subtree_penalty += penalties[child]
+                if child_text_length <= 160 and child_text_length > 0:
+                    signature = (local_name(child), tuple(sorted(_tokens(child))))
+                    groups[signature] = groups.get(signature, 0) + 1
+            tail_length = len(_normalized_text(child.tail))
+            if tail_length:
+                text_length = min(text_length + (1 if text_length else 0) + tail_length, 161)
+        short_text_lengths[parent] = text_length
+        penalties[parent] = subtree_penalty + sum(count - 2 for count in groups.values() if count > 2)
+    return penalties
+
+
+def _repeated_candidate_items(
+    candidates: list[_ScoredCandidate],
+    metrics_by_element: dict[etree._Element, CandidateMetrics],
+) -> frozenset[etree._Element]:
+    """一次预计算论坛、文档页或聚合页中的重复同级候选，避免逐候选重扫兄弟节点。"""
+    semantic_tokens = frozenset({"article", "content", "entry", "post", "section"})
+    parents = {parent for candidate in candidates if (parent := candidate.element.getparent()) is not None}
+    repeated: set[etree._Element] = set()
+    for parent in parents:
+        eligible = [
+            child
+            for child in parent
+            if isinstance(child.tag, str) and metrics_by_element.get(child, CandidateMetrics()).text_chars >= 100
+        ]
+        names = {child: local_name(child) for child in eligible}
+        tokens = {child: _tokens(child) & semantic_tokens for child in eligible}
+        name_counts: dict[str, int] = {}
+        token_counts: dict[str, int] = {}
+        for child in eligible:
+            name_counts[names[child]] = name_counts.get(names[child], 0) + 1
+            for token in tokens[child]:
+                token_counts[token] = token_counts.get(token, 0) + 1
+        repeated.update(
+            child
+            for child in eligible
+            if name_counts[names[child]] >= 2 or any(token_counts[token] >= 2 for token in tokens[child])
+        )
+    return frozenset(repeated)
+
+
+def _is_containment_equivalent(first: _ScoredCandidate, second: _ScoredCandidate) -> bool:
+    """忽略高度重叠的祖先/后代候选，避免嵌套 main/article 互相压低置信度。"""
+    contains = first.element in second.element.iterancestors() or second.element in first.element.iterancestors()
+    if not contains:
+        return False
+    smaller = min(first.metrics.text_chars, second.metrics.text_chars)
+    larger = max(first.metrics.text_chars, second.metrics.text_chars, 1)
+    return smaller / larger >= 0.8
+
+
+def _soft_prune(root: etree._Element) -> None:
+    """在候选副本中删除确定的导航/表单和高噪声 token 子树。"""
+    metrics_by_element = _collect_soft_prune_metrics(root)
+    for element in list(root.iterdescendants()):
+        if not isinstance(element.tag, str):
+            continue
+        name = local_name(element)
+        tokens = _tokens(element)
+        metrics = metrics_by_element[element]
+        valuable = metrics.semantic_count > (1 if name in _SEMANTIC_TAGS else 0)
+        text_chars = metrics.text_chars + max(0, metrics.text_segments - 1)
+        link_chars = metrics.link_chars + max(0, metrics.link_count - 1)
+        link_density = link_chars / max(1, text_chars)
+        should_remove = name in _BOILERPLATE_TAGS or (
+            bool(tokens & _NEGATIVE_TOKENS) and not valuable and (text_chars < 200 or link_density > 0.5)
+        )
+        if should_remove:
+            _drop_tree_preserve_tail(element)
+
+
+def _collect_soft_prune_metrics(root: etree._Element) -> dict[etree._Element, _SoftPruneMetrics]:
+    """单次后序遍历预计算每个元素的完整子树文本、链接和语义对象统计。"""
+    elements = [element for element in root.iter() if isinstance(element.tag, str)]
+    output: dict[etree._Element, _SoftPruneMetrics] = {}
+    for element in reversed(elements):
+        own_text = _normalized_text(element.text)
+        text_chars = len(own_text)
+        text_segments = 1 if own_text else 0
+        link_chars = 0
+        link_count = 0
+        semantic_count = 1 if local_name(element) in _SEMANTIC_TAGS else 0
+        for child in element:
+            if isinstance(child.tag, str):
+                child_metrics = output[child]
+                text_chars += child_metrics.text_chars
+                text_segments += child_metrics.text_segments
+                link_chars += child_metrics.link_chars
+                link_count += child_metrics.link_count
+                semantic_count += child_metrics.semantic_count
+                if local_name(child) == "a":
+                    child_text_chars = child_metrics.text_chars + max(0, child_metrics.text_segments - 1)
+                    if child_text_chars:
+                        link_chars += child_text_chars
+                        link_count += 1
+            tail = _normalized_text(child.tail)
+            if tail:
+                text_chars += len(tail)
+                text_segments += 1
+        output[element] = _SoftPruneMetrics(
+            text_chars=text_chars,
+            text_segments=text_segments,
+            link_chars=link_chars,
+            link_count=link_count,
+            semantic_count=semantic_count,
+        )
+    return output
+
+
+def _drop_tree_preserve_tail(element: etree._Element) -> None:
+    """删除噪声子树，同时把 tail 归还到相邻文本位置。"""
+    parent = element.getparent()
+    if parent is None:
+        return
+    tail = element.tail or ""
+    previous = element.getprevious()
+    if tail:
+        if previous is not None:
+            previous.tail = (previous.tail or "") + tail
+        else:
+            parent.text = (parent.text or "") + tail
+    parent.remove(element)
+
+
+def _normalized_text(value: str | None) -> str:
+    """折叠文本空白，供字符计数和候选比较使用。"""
+    return re.sub(r"\s+", " ", value or "").strip()
+
+
+def _document_order(element: etree._Element) -> tuple[int, ...]:
+    """返回元素从根到自身的逐层索引，作为稳定排序键。"""
+    path: list[int] = []
+    current: etree._Element | None = element
+    while current is not None and current.getparent() is not None:
+        parent = current.getparent()
+        path.append(parent.index(current))
+        current = parent
+    return tuple(reversed(path))
+
+
+__all__ = ["CandidateMetrics", "ContentSelection", "select_auto_content"]

docvortex/analyzers/native/models.py

@@ -0,0 +1,209 @@
+"""Flash PDF、EPUB、HTML、OFD、CSV 与 Office/RTF 文档模型。"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, BinaryIO
+
+from docvortex.document.contracts import HtmlSourceContext
+
+if TYPE_CHECKING:
+    from ...document.pdf.document import PDFDocument
+
+
+class PdfModel:
+    """将 Flash 原生 PDF 流水线包装为无状态模型。"""
+
+    def predict(self, pdf_doc: PDFDocument) -> list[list[dict[str, Any]]]:
+        """分析调用方持有的 PDFDocument，在所有文字匹配结束后统一输出可见英数。"""
+        from .pdf import pipeline
+        from ...content import normalize_pdf_model_text
+
+        pages = pipeline._analyze_native_document(pdf_doc)
+        normalize_pdf_model_text(pages)
+        return pages
+
+
+class CsvModel:
+    """将 CSV 分隔符文本包装为无状态 Flash 模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的 CSV 二进制流，并返回单逻辑页 model_list。"""
+        from .csv import convert_csv
+
+        return convert_csv(file_binary)
+
+
+class EpubModel:
+    """将 EPUB OCF/OPF 文档包装为无状态 Flash 模型。"""
+
+    def predict(
+        self,
+        file_binary: BinaryIO,
+    ) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的整本 EPUB 流，并返回目录页和全部正文逻辑页。"""
+        from .epub.converter import EpubConverter
+
+        converter = EpubConverter()
+        converter.convert(file_binary)
+        return converter.pages
+
+
+class HtmlModel:
+    """将 standalone HTML 文档包装为无状态 Flash 模型。"""
+
+    def predict(
+        self,
+        file_binary: BinaryIO,
+        *,
+        source_context: HtmlSourceContext | None = None,
+    ) -> list[list[dict[str, Any]]]:
+        """转换静态 HTML 流，并返回单逻辑页 model_list。"""
+        from .html.converter import HtmlConverter
+
+        converter = HtmlConverter()
+        converter.convert(file_binary, source_context=source_context)
+        return converter.pages
+
+
+class OfdModel:
+    """将 OFD 固定版式文档包装为无状态 Flash 模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的整份 OFD 流，并返回逐物理页 model-list。"""
+        from .ofd.converter import OfdConverter
+
+        converter = OfdConverter()
+        converter.convert(file_binary)
+        return converter.pages
+
+
+class RtfModel:
+    """将 Rich Text Format 文档包装为无状态 Flash 模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的 RTF 二进制流，并返回单逻辑页 model_list。"""
+        from .office.rtf.converter import RtfConverter
+
+        converter = RtfConverter()
+        converter.convert(file_binary)
+        return converter.pages
+
+
+class DocxModel:
+    """将 DOCX Converter 包装为无状态模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的 DOCX 二进制流，并返回分页 model_list。"""
+
+        # 延迟加载 Converter，避免纯 PDF 路径提前加载 Office 依赖。
+        from .office.docx.docx_converter import DocxConverter
+
+        converter = DocxConverter()
+        converter.convert(file_binary)
+        return converter.pages
+
+
+class DocModel:
+    """将 Word 97–2003 Converter 包装为无状态模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的 DOC 二进制流，并返回逐 section model-list。"""
+
+        # 延迟加载旧版 DOC 解析器，避免其他格式提前加载 olefile。
+        from .office.doc.doc_converter import DocConverter
+
+        converter = DocConverter()
+        converter.convert(file_binary)
+        return converter.pages
+
+
+class PptxModel:
+    """将 PPTX Converter 包装为无状态模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的 PPTX 二进制流，并返回分页 model_list。"""
+
+        # 延迟加载 Converter，避免纯 PDF 路径提前加载 Office 依赖。
+        from .office.pptx.pptx_converter import PptxConverter
+
+        converter = PptxConverter()
+        converter.convert(file_binary)
+        return converter.pages
+
+
+class PptModel:
+    """将 PowerPoint 97–2003 Converter 包装为无状态模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的 PPT 二进制流，并返回逐幻灯片 model-list。"""
+
+        # 延迟加载旧版 PPT 解析器，避免其他格式提前加载 olefile。
+        from .office.ppt.ppt_converter import PptConverter
+
+        converter = PptConverter()
+        converter.convert(file_binary)
+        return converter.pages
+
+
+class XlsModel:
+    """将 Excel 97–2003 Converter 包装为无状态模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的 XLS 二进制流，并返回逐工作表 model-list。"""
+
+        # 延迟加载旧版 XLS 解析器，避免其他格式提前加载 olefile/openpyxl。
+        from .office.xls.xls_converter import XlsConverter
+
+        converter = XlsConverter()
+        converter.convert(file_binary)
+        return converter.pages
+
+
+class XlsxModel:
+    """将 XLSX Converter 包装为无状态模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的 XLSX 二进制流，并返回分页 model_list。"""
+
+        # 延迟加载 Converter，避免纯 PDF 路径提前加载 Office 依赖。
+        from .office.xlsx.xlsx_converter import XlsxConverter
+
+        converter = XlsxConverter()
+        converter.convert(file_binary)
+        return converter.pages
+
+
+class OdtModel:
+    """将 OpenDocument Text 包装为无状态 Flash 模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的 ODT 二进制流，并返回分页 model_list。"""
+        from .office.odf.converters import OdtConverter
+
+        converter = OdtConverter()
+        converter.convert(file_binary)
+        return converter.pages
+
+
+class OdsModel:
+    """将 OpenDocument Spreadsheet 包装为无状态 Flash 模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的 ODS 二进制流，并返回逐工作表 model_list。"""
+        from .office.odf.converters import OdsConverter
+
+        converter = OdsConverter()
+        converter.convert(file_binary)
+        return converter.pages
+
+
+class OdpModel:
+    """将 OpenDocument Presentation 包装为无状态 Flash 模型。"""
+
+    def predict(self, file_binary: BinaryIO) -> list[list[dict[str, Any]]]:
+        """转换调用方持有的 ODP 二进制流，并返回逐幻灯片 model_list。"""
+        from .office.odf.converters import OdpConverter
+
+        converter = OdpConverter()
+        converter.convert(file_binary)
+        return converter.pages

docvortex/analyzers/native/ofd/__init__.py

@@ -0,0 +1,14 @@
+"""OFD 固定版式 Flash 解析入口。"""
+
+from .errors import OfdEncryptedError, OfdParseError, OfdResourceLimitError
+from .metadata import extract_ofd_metadata
+from .package import detect_ofd, detect_ofd_path
+
+__all__ = [
+    "OfdEncryptedError",
+    "OfdParseError",
+    "OfdResourceLimitError",
+    "detect_ofd",
+    "detect_ofd_path",
+    "extract_ofd_metadata",
+]