docvortex 0.4.11__tar.gz → 0.4.13__tar.gz

{docvortex-0.4.11/src/docvortex.egg-info → docvortex-0.4.13}/PKG-INFO

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

{docvortex-0.4.11 → docvortex-0.4.13}/src/docvortex/analyzers/native/html/constants.py

@@ -8,7 +8,6 @@ MAX_HTML_NODES: Final = 2_000_000
 MAX_HTML_DEPTH: Final = 256
 MAX_HTML_IMAGE_BYTES: Final = 20 * 1024 * 1024
 MAX_HTML_IMAGE_TOTAL_BYTES: Final = 128 * 1024 * 1024
-MAX_REMOTE_IMAGE_FETCH_SECONDS: Final = 10
 MAX_HTML_STYLESHEET_BYTES: Final = 5 * 1024 * 1024
 MAX_HTML_STYLESHEET_TOTAL_BYTES: Final = 20 * 1024 * 1024
 MAX_HTML_RENDERED_BYTES: Final = 256 * 1024 * 1024
@@ -23,5 +22,4 @@ __all__ = [
     "MAX_HTML_RENDERED_BYTES",
     "MAX_HTML_STYLESHEET_BYTES",
     "MAX_HTML_STYLESHEET_TOTAL_BYTES",
-    "MAX_REMOTE_IMAGE_FETCH_SECONDS",
 ]

{docvortex-0.4.11 → docvortex-0.4.13}/src/docvortex/analyzers/native/html/resources.py

@@ -6,7 +6,6 @@ import base64
 from pathlib import Path
 from typing import Protocol
 from urllib.parse import SplitResult, unquote, urljoin, urlsplit, urlunsplit
-from urllib.request import urlopen
 
 from lxml import etree  # type: ignore[reportMissingImports]
 
@@ -21,7 +20,6 @@ from .constants import (
     MAX_HTML_IMAGE_TOTAL_BYTES,
     MAX_HTML_STYLESHEET_BYTES,
     MAX_HTML_STYLESHEET_TOTAL_BYTES,
-    MAX_REMOTE_IMAGE_FETCH_SECONDS,
 )
 from .errors import HtmlResourceLimitError
 
@@ -68,7 +66,6 @@ class HtmlResourceContext:
         self._image_bytes = 0
         self._stylesheet_bytes = 0
         self._image_cache: dict[Path, str] = {}
-        self._remote_image_cache: dict[str, str] = {}
         self._data_image_cache: dict[str, ResolvedMarkupImage] = {}
         self._stylesheet_cache: dict[Path, str] = {}
         self._local_root = source_context.local_resource_root.resolve() if source_context.local_resource_root else None
@@ -161,14 +158,14 @@ class HtmlResourceContext:
         return sanitize_hyperlink_target(normalized, allow_relative=True, allow_fragment=True)
 
     def resolve_image(self, source: str, *, alt: str = "") -> ResolvedMarkupImage | None:
-        """按 data URI、远程 URL、本地安全文件的顺序解析图片，远程图片仅在来源显式开启下载时内嵌。"""
+        """按 data URI、远程 URL、本地安全文件的顺序解析图片，远程图片仅保留受限外链。"""
         normalized = (source or "").strip()
         if not normalized:
             return ResolvedMarkupImage(alt=alt) if alt else None
         if normalized.casefold().startswith("data:"):
             return self._resolve_data_image(normalized, alt=alt)
         if remote_url := self._resolve_remote_image_url(normalized):
-            return self._resolve_remote_image(remote_url, alt=alt)
+            return ResolvedMarkupImage(image_url=remote_url, alt=alt)
         local_path = self._resolve_local_path(normalized)
         if local_path is None or not local_path.is_file():
             return ResolvedMarkupImage(alt=alt) if alt else None
@@ -258,41 +255,6 @@ class HtmlResourceContext:
         self._data_image_cache[data_uri] = resolved
         return resolved
 
-    def _resolve_remote_image(self, remote_url: str, *, alt: str) -> ResolvedMarkupImage:
-        """远程图片默认保持外链，来源显式开启下载时按缓存下载内嵌。"""
-        if not self.source_context.fetch_remote_images:
-            return ResolvedMarkupImage(image_url=remote_url, alt=alt)
-        if cached := self._remote_image_cache.get(remote_url):
-            return ResolvedMarkupImage(image_base64=cached, alt=alt)
-        data_uri = self._fetch_remote_image(remote_url)
-        if data_uri is None:
-            return ResolvedMarkupImage(image_url=remote_url, alt=alt)
-        self._remote_image_cache[remote_url] = data_uri
-        return ResolvedMarkupImage(image_base64=data_uri, alt=alt)
-
-    def _fetch_remote_image(self, remote_url: str) -> str | None:
-        """在单图上限与超时约束内下载远程图片并复核签名，网络失败返回 None 退回外链。"""
-        try:
-            with urlopen(remote_url, timeout=MAX_REMOTE_IMAGE_FETCH_SECONDS) as response:
-                chunks: list[bytes] = []
-                remaining = MAX_HTML_IMAGE_BYTES + 1
-                while remaining > 0:
-                    chunk = response.read(remaining)
-                    if not chunk:
-                        break
-                    chunks.append(chunk)
-                    remaining -= len(chunk)
-        except (OSError, ValueError):
-            return None
-        payload = b"".join(chunks)
-        if len(payload) > MAX_HTML_IMAGE_BYTES:
-            raise HtmlResourceLimitError(f"HTML image exceeds max_html_image_bytes={MAX_HTML_IMAGE_BYTES}")
-        data_uri = _image_data_uri(payload)
-        if data_uri is None:
-            return None
-        self._charge_image_bytes(len(payload))
-        return data_uri
-
     def _charge_image_bytes(self, byte_count: int) -> None:
         """累计实际保留的图片字节，并在超限时终止整份文档。"""
         self._image_bytes += byte_count

{docvortex-0.4.11 → docvortex-0.4.13}/src/docvortex/analyzers/native/office/odf/converters.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import html
 import re
 from dataclasses import dataclass
 from typing import Any, BinaryIO, Iterator
@@ -14,7 +15,7 @@ from .constants import OdfSuffix, qname
 from .models import InlineNote
 from .package import OdfPackage
 from .styles import OdfStyles
-from .table import OdfTableExpansionBudget, parse_table_grid, split_table_regions, table_grid_to_html
+from .table import OdfTableExpansionBudget, TableGrid, parse_table_grid, split_table_regions, table_grid_to_html
 from .text import (
     OdfBlockParser,
     OdfMasterPageChange,
@@ -27,6 +28,29 @@ from .text import (
 _LENGTH_RE = re.compile(r"^\s*(?P<value>[+-]?(?:\d+(?:\.\d*)?|\.\d+))(?P<unit>cm|mm|in|pt|pc|px)?\s*$")
 _LENGTH_TO_PT = {"": 1.0, "pt": 1.0, "pc": 12.0, "in": 72.0, "cm": 72.0 / 2.54, "mm": 72.0 / 25.4, "px": 0.75}
 
+_PARAGRAPH_JOIN_RE = re.compile(r"\s*</p>\s*<p>\s*")
+_BREAK_TAG_RE = re.compile(r"<br\s*/?>")
+_PARAGRAPH_TAG_RE = re.compile(r"</?p>")
+
+
+def _singleton_region_plain_text(region: TableGrid) -> str | None:
+    """把无结构的单格区域还原为可降级的纯文本。
+
+    对齐 Excel 投影的单格降级条件：1x1、无合并跨度、无媒体公式等结构化
+    HTML；仅由段落包装与换行组成的单元格才视为普通文本。
+    """
+    if len(region.rows) != 1 or region.width != 1 or (0, 0) in region.covered:
+        return None
+    cell = region.rows[0][0] if region.rows[0] else None
+    if cell is None or cell.row_span > 1 or cell.col_span > 1:
+        return None
+    normalized = _BREAK_TAG_RE.sub("\n", _PARAGRAPH_JOIN_RE.sub("\n", cell.html))
+    normalized = _PARAGRAPH_TAG_RE.sub("", normalized)
+    if "<" in normalized:
+        return None
+    plain = html.unescape(normalized).strip()
+    return plain or None
+
 
 @dataclass(frozen=True, slots=True)
 class _OdfContext:
@@ -319,6 +343,10 @@ def _sheet_blocks(sheet: etree._Element, parser: OdfBlockParser) -> list[dict[st
     grid = parse_table_grid(sheet, parser.render_cell_html, expansion_budget=parser.table_expansion_budget)
     blocks: list[dict[str, Any]] = []
     for region in split_table_regions(grid):
+        plain_text = _singleton_region_plain_text(region)
+        if plain_text is not None:
+            blocks.append({"type": BlockType.TEXT, "content": text_spans(plain_text)})
+            continue
         content = table_grid_to_html(region)
         if content:
             blocks.append({"type": BlockType.TABLE, "content": content})

{docvortex-0.4.11 → docvortex-0.4.13}/src/docvortex/analyzers/native/office/odf/table.py

@@ -10,6 +10,12 @@ from dataclasses import dataclass
 from lxml import etree  # type: ignore[reportMissingImports]
 
 from ..limits import MAX_GRID_SLOTS
+from ..spreadsheet.region_discovery import (
+    discover_connected_regions,
+    keep_maximal_by_semantic_sets,
+    region_semantic_positions,
+    select_best_gap_candidate,
+)
 from .constants import MAX_EXPANSION_TEXT_BYTES, qname
 from .errors import OdfResourceLimitError
 from .models import GridCell, TableGrid
@@ -326,37 +332,64 @@ def crop_table_grid(grid: TableGrid, bounds: tuple[int, int, int, int]) -> Table
     return trim_table_grid(TableGrid(rows=rows, header_rows=header_rows, covered=covered))
 
 
+def _grid_cell_at(grid: TableGrid, row: int, col: int) -> GridCell | None:
+    """安全返回网格坐标上的原点单元格，越界或未物化位置返回 None。"""
+    cells = grid.rows[row] if 0 <= row < len(grid.rows) else []
+    return cells[col] if 0 <= col < len(cells) else None
+
+
 def split_table_regions(grid: TableGrid) -> list[TableGrid]:
-    """按至少两条全空行列分隔电子表格中的离散数据区域。"""
-    nonempty = [
-        (row_index, col_index)
-        for row_index, row in enumerate(grid.rows)
-        for col_index, cell in enumerate(row)
+    """洪水填充发现离散数据区域，并按 gap 候选评分选择稳定分割。
+
+    与 XLS/XLSX 投影器共用区域发现算法：连通性掩码把可见内容、合并跨度和
+    covered 占位都视为内容格，BFS 四向连通并在容忍距离内跨越空白；对候选
+    tolerance 按惩罚指标选优后，逐区域裁剪出包围盒网格。
+    """
+    max_row = len(grid.rows) - 1
+    max_col = grid.width - 1
+    if max_row < 0 or max_col < 0:
+        return []
+
+    def has_content(row: int, col: int) -> bool:
+        """判断坐标是否有可见内容或属于合并占位（对齐 Excel 投影语义）。"""
+        if (row, col) in grid.covered:
+            return True
+        cell = _grid_cell_at(grid, row, col)
+        return cell is not None and (cell.has_content or cell.row_span > 1 or cell.col_span > 1)
+
+    # 仅从有可见内容的坐标出发，对齐 Excel 投影只以有值格为起点的行为。
+    starts = [
+        (row, col)
+        for row, cells in enumerate(grid.rows)
+        for col, cell in enumerate(cells)
         if cell is not None and cell.has_content
     ]
-    if not nonempty:
+    if not starts:
         return []
-    row_values = sorted({row for row, _ in nonempty})
-    row_bands: list[tuple[int, int]] = []
-    start = previous = row_values[0]
-    for current in row_values[1:]:
-        if current - previous > 2:
-            row_bands.append((start, previous))
-            start = current
-        previous = current
-    row_bands.append((start, previous))
-    result: list[TableGrid] = []
-    for row_start, row_end in row_bands:
-        cols = sorted({col for row, col in nonempty if row_start <= row <= row_end})
-        col_start = col_previous = cols[0]
-        for current in cols[1:] + [cols[-1] + 3]:
-            if current - col_previous > 2:
-                region = crop_table_grid(grid, (row_start, row_end, col_start, col_previous))
-                if region.rows:
-                    result.append(region)
-                col_start = current
-            col_previous = current
-    return result
+
+    def has_semantic_content(row: int, col: int) -> bool:
+        """判断坐标是否包含可见或结构化 HTML 语义。"""
+        cell = _grid_cell_at(grid, row, col)
+        return cell is not None and cell.has_content
+
+    def span_at(row: int, col: int) -> tuple[int, int]:
+        """返回原点单元格的合并跨度，非原点或空位返回 1x1。"""
+        cell = _grid_cell_at(grid, row, col)
+        return (cell.row_span, cell.col_span) if cell is not None else (1, 1)
+
+    _, _, best_regions = select_best_gap_candidate(
+        lambda tolerance: discover_connected_regions(has_content, starts, max_row, max_col, tolerance),
+        has_semantic_content,
+        span_at,
+    )
+    semantic_sets = [region_semantic_positions(region, has_semantic_content) for region in best_regions]
+    regions: list[TableGrid] = []
+    for index in keep_maximal_by_semantic_sets(semantic_sets):
+        region = best_regions[index]
+        cropped = crop_table_grid(grid, (region.row_start, region.row_end, region.col_start, region.col_end))
+        if cropped.rows:
+            regions.append(cropped)
+    return regions
 
 
 def _render_html_row(grid: TableGrid, row_index: int, *, header: bool) -> str: