docvortex 0.4.18__tar.gz → 0.4.19__tar.gz

{docvortex-0.4.18/src/docvortex.egg-info → docvortex-0.4.19}/PKG-INFO

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

{docvortex-0.4.18 → docvortex-0.4.19}/docs/sdk-0.4.md

@@ -1,6 +1,6 @@
 # DocVortex 0.4 公共 SDK 与宿主迁移
 
-本文记录 0.4 系列的公共模块边界。MinerU 的页面原语复用需要 `docvortex>=0.4.15,<1`，文档协议、解析路由、模型回退与渲染语义保持不变。
+本文记录 0.4 系列的公共模块边界。MinerU 的共享图片导出需要 `docvortex>=0.4.19,<1`，文档协议、解析路由、模型回退与渲染语义保持不变。
 
 ## 公开入口
 
@@ -22,6 +22,29 @@
 
 跨库调用方可通过 `docvortex.export.materialize_middle(middle_json, assets=None)` 获取图片外置后的文档副本与 `AssetStore`，再通过 `validate_materialized_assets(document, assets)` 验证所有图片引用。直接图片和视觉 HTML 内嵌图片使用安全相对路径，原始图片字节及布局方向扩展保持不变；代码字面量不作为 HTML 素材处理。
 
+### 0.4.19 图片命名与宿主回调
+
+新物化图片统一沿用 MinerU Gradio 的命名：直接载荷为
+`images/page_{page_idx}_{owner.type}_{owner.index}.{ext}`，其中 owner 是所属
+image/table/chart 父块，独立公式使用 equation。视觉正文内的图片分别使用
+`image_{index}_{ordinal}`、`table_image_{index}_{ordinal}`、`chart_image_{index}_{ordinal}`。
+页号为从 0 开始的原始页索引；序号按每个正文的所有 `<img src=...>` 从 1 计数，外链也占序号。
+扩展名转小写，缺省 jpg；图片字节不重新编码。同名同字节复用，同名异字节追加
+`_duplicate_n`，最多检查 10000 个候选名称；不同语义名称不因字节相同而合并。
+
+`materialize_middle` 新增两个可选的仅限关键字参数：
+
+- `image_resolver: Callable[[ImagePayloadBlock, int], tuple[bytes, str] | None]`：接收副本中的载荷块和原始页号，返回字节及扩展名；返回 None 时保留载荷，不再触发默认解析。
+- `asset_resolver: Callable[[str], bytes]`：接收经过实体/URL 解码及安全校验的 HTML 图片相对路径，返回字节；扩展名从引用路径取得。仅在明确传入回调时读取宿主资源，回调负责自身根目录限制。
+
+不提供回调时保持内嵌图片的严格解析，不自动读文件或裁 PDF；已有相对路径保持原样。
+输入 `assets` 保留为独立副本并参与冲突检查，重复物化不改变路径或字节。
+新命名同步更新直接引用和 HTML src，保留 HTML 的属性、引号及其他正文。
+
+此变更会改变新生成的 CLI/API ZIP 及 DocVortex 导出图片名称，消费者应读取文档实际引用，
+不再自行拼接旧的 `*_body_*` 名称。历史结果包仍按已有引用读取，不自动迁移、不生成旧名别名；
+MiddleJson 仍为 2.0，文件写出层的 overwrite 语义不变。
+
 调用方负责将该副本及素材写入自己的结果包，不应先省略图片再从源 PDF 重裁。缺失引用、未物化网络图片或同名素材冲突会显式失败。物化不修改输入对象、不读取源 PDF、不下载网络资源；已有外部素材须通过 `AssetStore` 显式提供。
 
 ## 行为与资源所有权

docvortex-0.4.19/src/docvortex/export/_images.py

@@ -0,0 +1,134 @@
+"""各导出入口共享的图片命名、冲突分配与引用改写。"""
+
+from __future__ import annotations
+
+import html
+import re
+from collections.abc import Callable
+from pathlib import PurePosixPath
+from urllib.parse import unquote
+
+from ..assets import AssetStore, parse_image_data_uri_strict, validate_image_sidecar_path
+from ..content.tree import iter_child_blocks
+from ..schema import (
+    AlgorithmBodyBlock,
+    BlockBase,
+    ChartBlock,
+    ChartBodyBlock,
+    CodeBlock,
+    CodeBodyBlock,
+    ImageBlock,
+    ImageBodyBlock,
+    ImagePayloadBlock,
+    MiddleJson,
+    TableBlock,
+    TableBodyBlock,
+)
+
+_HTML_IMAGE_SOURCE_RE = re.compile(
+    r"(?P<prefix><img\b(?:[^>\"']|\"[^\"]*\"|'[^']*')*?\s+src\s*=\s*)"
+    r"(?:(?P<quote>[\"'])(?P<quoted>.*?)(?P=quote)|(?P<unquoted>[^\s>]+))",
+    re.IGNORECASE | re.DOTALL,
+)
+_IMAGE_EXTENSIONS = frozenset({"jpg", "jpeg", "png", "gif", "webp", "bmp", "tiff", "svg"})
+
+
+def _register_image(
+    assets: AssetStore,
+    payload: bytes,
+    extension: str,
+    *,
+    page_idx: int,
+    owner: BlockBase,
+    ordinal: int | None = None,
+) -> str:
+    """按原始页和视觉父块命名，冲突后缀独立于正文图片序号。"""
+    extension = extension.lower().lstrip(".") or "jpg"
+    if extension not in _IMAGE_EXTENSIONS:
+        raise ValueError(f"Unsupported image extension: {extension}")
+    if owner.index is None:
+        raise ValueError("Image owner must have a block index")
+    kind = str(owner.type)
+    if ordinal is not None and kind != "image":
+        kind += "_image"
+    suffix = f"_{ordinal}" if ordinal is not None else ""
+    stem = f"page_{page_idx}_{kind}_{owner.index}{suffix}"
+    for attempt in range(10000):
+        duplicate = f"_duplicate_{attempt}" if attempt else ""
+        path = validate_image_sidecar_path(f"images/{stem}{duplicate}.{extension}")
+        if path not in assets or assets[path] == payload:
+            assets.add(path, payload)
+            return path
+    raise ValueError("Too many conflicting image assets")
+
+
+def _materialize_markup(
+    content: str,
+    assets: AssetStore,
+    *,
+    page_idx: int,
+    owner: BlockBase,
+    asset_resolver: Callable[[str], bytes] | None,
+) -> str:
+    """按所有 img src 的出现顺序编号，仅替换图片引用的值。"""
+    ordinal = 0
+
+    def replace_source(match: re.Match[str]) -> str:
+        """保留外链及原 HTML 属性，外链同样占用正文图片序号。"""
+        nonlocal ordinal
+        ordinal += 1
+        group = "quoted" if match.group("quote") else "unquoted"
+        source = html.unescape(match.group(group)).strip()
+        if source.startswith("data:"):
+            payload, extension = parse_image_data_uri_strict(source)
+        elif re.match(r"^[A-Za-z][A-Za-z0-9+.-]*:", source) or asset_resolver is None:
+            return match.group(0)
+        else:
+            safe_path = validate_image_sidecar_path(unquote(source))
+            payload = asset_resolver(safe_path)
+            extension = PurePosixPath(safe_path).suffix.lstrip(".")
+        path = _register_image(assets, payload, extension, page_idx=page_idx, owner=owner, ordinal=ordinal)
+        start, end = match.span(group)
+        original = match.group(0)
+        return original[: start - match.start()] + path + original[end - match.start() :]
+
+    return _HTML_IMAGE_SOURCE_RE.sub(replace_source, content)
+
+
+def _materialize_images(
+    middle_json: MiddleJson,
+    assets: AssetStore | None = None,
+    *,
+    image_resolver: Callable[[ImagePayloadBlock, int], tuple[bytes, str] | None] | None = None,
+    asset_resolver: Callable[[str], bytes] | None = None,
+) -> tuple[MiddleJson, AssetStore]:
+    """复制文档及素材索引，在同一次树遍历中完成命名和引用回填。"""
+    document = middle_json.model_copy(deep=True)
+    result = assets.copy() if assets is not None else AssetStore()
+    for page in document.pages:
+        pending = [(block, block) for block in reversed(page.blocks)]
+        while pending:
+            block, owner = pending.pop()
+            if isinstance(block, (CodeBlock, CodeBodyBlock, AlgorithmBodyBlock)):
+                continue
+            if isinstance(block, (ImageBlock, TableBlock, ChartBlock)):
+                owner = block
+            if isinstance(block, ImagePayloadBlock):
+                resolved = None
+                if image_resolver is not None:
+                    resolved = image_resolver(block, page.page_idx)
+                elif block.image_base64 is not None:
+                    resolved = parse_image_data_uri_strict(block.image_base64)
+                if resolved is not None:
+                    payload, extension = resolved
+                    block.image_path = _register_image(result, payload, extension, page_idx=page.page_idx, owner=owner)
+                    block.image_base64 = None
+                    block.image_url = None
+                elif image_resolver is None and block.image_path and block.image_path in result:
+                    block.image_url = None
+            if isinstance(block, (ImageBodyBlock, TableBodyBlock, ChartBodyBlock)):
+                block.content = _materialize_markup(
+                    block.content, result, page_idx=page.page_idx, owner=owner, asset_resolver=asset_resolver
+                )
+            pending.extend((child, owner) for child in reversed(list(iter_child_blocks(block))))
+    return document, result

{docvortex-0.4.18 → docvortex-0.4.19}/src/docvortex/export/files.py

@@ -2,30 +2,32 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from pathlib import Path
 from urllib.parse import urlsplit
 
 from ..assets import AssetStore
 from ..content.tree import iter_child_blocks
-from ..schema import MiddleJson
 from ..result import ExportResult, RenderArtifact
-from .middle import _commit_export_files, _prepare_export_copy, _resolve_export_target, _validate_export_path_relationships
+from ..schema import ImagePayloadBlock, MiddleJson
+from ._images import _materialize_images
+from .middle import _commit_export_files, _resolve_export_target, _validate_export_path_relationships
 
 
-def materialize_middle(middle_json: MiddleJson, assets: AssetStore | None = None) -> tuple[MiddleJson, AssetStore]:
-    """在文档副本上外置所有内嵌图片，保留调用者提供的外部素材。"""
-    document, embedded = _prepare_export_copy(middle_json)
-    result = assets.copy() if assets is not None else AssetStore()
-    for path, payload in embedded.items():
-        result.add(path, payload)
-    pending = [block for page in document.pages for block in page.blocks]
-    while pending:
-        block = pending.pop()
-        pending.extend(iter_child_blocks(block))
-        image_path = getattr(block, "image_path", None)
-        if image_path and image_path in result and getattr(block, "image_url", None):
-            block.image_url = None
-    return document, result
+def materialize_middle(
+    middle_json: MiddleJson,
+    assets: AssetStore | None = None,
+    *,
+    image_resolver: Callable[[ImagePayloadBlock, int], tuple[bytes, str] | None] | None = None,
+    asset_resolver: Callable[[str], bytes] | None = None,
+) -> tuple[MiddleJson, AssetStore]:
+    """在副本上按视觉父块外置图片；仅通过显式回调获取宿主文件或裁图。
+
+    image_resolver 接收载荷块和原始页索引，返回字节与扩展名；返回 None
+    表示保留当前载荷，不触发默认解析。asset_resolver 仅接收经过校验的
+    HTML 图片相对路径。不提供回调时，只解析内嵌图片并保留已有素材引用。
+    """
+    return _materialize_images(middle_json, assets, image_resolver=image_resolver, asset_resolver=asset_resolver)
 
 
 def validate_materialized_assets(middle_json: MiddleJson, assets: AssetStore) -> None:

{docvortex-0.4.18 → docvortex-0.4.19}/src/docvortex/export/middle.py

@@ -6,9 +6,9 @@ import os
 from dataclasses import dataclass
 from pathlib import Path
 from tempfile import NamedTemporaryFile
-from typing import Any, Sequence
 
-from ..schema import BlockBase, MiddleJson, _iter_child_blocks
+from ..schema import MiddleJson
+from ._images import _materialize_images
 
 
 @dataclass(frozen=True, slots=True)
@@ -20,65 +20,10 @@ class MiddleJsonExportResult:
     image_paths: tuple[Path, ...]
 
 
-def _iter_page_blocks(blocks: Sequence[BlockBase]) -> list[BlockBase]:
-    """按深度优先顺序展开页面 block 树，供图片外置统一遍历。"""
-    result: list[BlockBase] = []
-    pending: list[BlockBase] = list(reversed(blocks))
-    while pending:
-        block = pending.pop()
-        result.append(block)
-        pending.extend(reversed(_iter_child_blocks(block)))
-    return result
-
-
-def _register_export_file(files: dict[str, bytes], relative_path: str, payload: bytes) -> None:
-    """登记待写文件，并在同名内容冲突时立即终止导出。"""
-    existing = files.get(relative_path)
-    if existing is not None and existing != payload:
-        raise ValueError(f"Conflicting image payload for path: {relative_path}")
-    files[relative_path] = payload
-
-
 def _prepare_export_copy(middle_json: MiddleJson) -> tuple[MiddleJson, dict[str, bytes]]:
-    """复制对象、解析直接及 HTML 图片，并回填副本中的相对路径。"""
-    from ..foundation._image_payload import INLINE_IMAGE_DATA_URI_RE, parse_image_data_uri_strict
-
-    exported = middle_json.model_copy(deep=True)
-    image_files: dict[str, bytes] = {}
-    for page in exported.pages:
-        for block in _iter_page_blocks(page.blocks):
-            data_uri = getattr(block, "image_base64", None)
-            if data_uri is not None:
-                if block.index is None:
-                    raise ValueError(f"Image carrier requires index: page_idx={page.page_idx}, type={block.type}")
-                image_bytes, extension = parse_image_data_uri_strict(data_uri)
-                relative_path = f"images/page_{page.page_idx}_{block.type}_{block.index}.{extension}"
-                _register_export_file(image_files, relative_path, image_bytes)
-                block.image_path = relative_path  # type: ignore[attr-defined]
-                block.image_base64 = None  # type: ignore[attr-defined]
-
-            content = getattr(block, "content", None)
-            if (
-                str(block.type) not in {"table_body", "chart_body", "image_body"}
-                or not isinstance(content, str)
-                or "data:image/" not in content
-            ):
-                continue
-            if block.index is None:
-                raise ValueError(f"HTML image carrier requires index: page_idx={page.page_idx}, type={block.type}")
-            ordinal = 0
-
-            def _replace_data_uri(match: Any) -> str:
-                """将当前 HTML data URI 登记为 sidecar，并返回确定性相对路径。"""
-                nonlocal ordinal
-                ordinal += 1
-                image_bytes, extension = parse_image_data_uri_strict(match.group(0))
-                relative_path = f"images/page_{page.page_idx}_{block.type}_{block.index}_{ordinal}.{extension}"
-                _register_export_file(image_files, relative_path, image_bytes)
-                return relative_path
-
-            block.content = INLINE_IMAGE_DATA_URI_RE.sub(_replace_data_uri, content)  # type: ignore[assignment]
-    return exported, image_files
+    """复用统一物化流程，为原子文件导出提供文档副本及图片字节。"""
+    document, assets = _materialize_images(middle_json)
+    return document, dict(assets)
 
 
 def _resolve_export_target(output_root: Path, relative_path: str) -> Path:

{docvortex-0.4.18 → docvortex-0.4.19}/src/docvortex/version.py

@@ -1,3 +1,3 @@
-__version__ = "0.4.18"
+__version__ = "0.4.19"
 
 __all__ = ["__version__"]

{docvortex-0.4.18 → docvortex-0.4.19/src/docvortex.egg-info}/PKG-INFO

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

{docvortex-0.4.18 → docvortex-0.4.19}/src/docvortex.egg-info/SOURCES.txt

@@ -343,6 +343,7 @@ src/docvortex/document/pdf/text/extract.py
 src/docvortex/document/pdf/text/geometry.py
 src/docvortex/document/pdf/text/groups.py
 src/docvortex/export/__init__.py
+src/docvortex/export/_images.py
 src/docvortex/export/bundle.py
 src/docvortex/export/files.py
 src/docvortex/export/middle.py
@@ -446,6 +447,7 @@ tests/test_complete_pipeline.py
 tests/test_converter_lifecycle.py
 tests/test_document_envelope.py
 tests/test_document_metadata.py
+tests/test_export_image_names.py
 tests/test_format_matrix.py
 tests/test_geometry_api.py
 tests/test_history_geometry_tools.py

docvortex-0.4.19/tests/test_export_image_names.py

@@ -0,0 +1,152 @@
+"""公共物化接口的命名、宿主回调、历史引用及冲突回归。"""
+
+from __future__ import annotations
+
+import base64
+
+import pytest
+
+from docvortex.assets import AssetStore
+from docvortex.export import materialize_middle, validate_materialized_assets
+from docvortex.schema import ImagePayloadBlock, MiddleJson, PageInfo, TableBlock, TableBodyBlock
+
+
+def _uri(payload: bytes = b"\xff\xd8\xffimage") -> str:
+    """生成可通过签名校验的 JPEG 载荷，避免引入图像解码依赖。"""
+    return "data:image/jpeg;base64," + base64.b64encode(payload).decode()
+
+
+def _document(content: str = "", image_base64: str | None = None) -> MiddleJson:
+    """构造原始第六页的表格，父块和正文索引遵守共享协议。"""
+    return MiddleJson(
+        pages=[
+            PageInfo(
+                page_idx=5,
+                blocks=[
+                    TableBlock(
+                        type="table",
+                        index=3,
+                        content=[TableBodyBlock(type="table_body", index=3, content=content, image_base64=image_base64)],
+                    )
+                ],
+            )
+        ],
+        metadata={"file_suffix": "docx", "producer": {"name": "test", "version": "1"}},
+        is_full_document=False,
+    )
+
+
+def test_markup_ordinals_preserve_attributes_and_count_external_sources() -> None:
+    """单双引号、无引号和外链按位置编号，非 src 属性及格式原样保留。"""
+    uri = _uri()
+    markup = (
+        '<img src="https://example.test/a.png">'
+        f'<IMG alt="a > b" data-src="untouched" SRC = \'{uri}\' width="20">'
+        f"<img src={uri} height=3>"
+        f'<img src="{uri}">'
+    )
+    middle = _document(markup)
+    original = middle.to_json()
+    saved, assets = materialize_middle(middle)
+    expected = markup
+    for ordinal in (2, 3, 4):
+        expected = expected.replace(uri, f"images/page_5_table_image_3_{ordinal}.jpg", 1)
+    assert saved.pages[0].blocks[0].content[0].content == expected
+    assert set(assets) == {f"images/page_5_table_image_3_{ordinal}.jpg" for ordinal in (2, 3, 4)}
+    validate_materialized_assets(saved, assets)
+    assert middle.to_json() == original
+    repeated, repeated_assets = materialize_middle(saved, assets)
+    assert repeated == saved and dict(repeated_assets) == dict(assets)
+
+
+def test_collision_allocation_preserves_existing_assets_and_inline_ordinals() -> None:
+    """同名异内容分配独立后缀，相同载荷复用，输入素材不被覆盖。"""
+    red, blue = b"\xff\xd8\xffred", b"\xff\xd8\xffblue"
+    direct = "images/page_5_table_3.jpg"
+    inline = "images/page_5_table_image_3_1.jpg"
+    supplied = AssetStore({direct: red, inline: red, "images/unrelated.png": b"keep"})
+    middle = _document(f'<img src="{_uri(blue)}">', _uri(blue))
+    saved, assets = materialize_middle(middle, supplied)
+    body = saved.pages[0].blocks[0].content[0]
+    assert body.image_path == "images/page_5_table_3_duplicate_1.jpg"
+    assert body.content == '<img src="images/page_5_table_image_3_1_duplicate_1.jpg">'
+    assert assets[direct] == supplied[direct] == red
+    assert assets[inline] == supplied[inline] == red
+    assert assets[body.image_path] == blue
+    assert set(supplied) == {direct, inline, "images/unrelated.png"}
+    repeated, repeated_assets = materialize_middle(middle, assets)
+    assert repeated == saved and dict(repeated_assets) == dict(assets)
+    with pytest.raises(ValueError, match="Conflicting asset payload"):
+        supplied.add(direct, blue)
+
+
+def test_collision_candidates_are_bounded() -> None:
+    """全部候选名称被不同内容占用时，明确失败而不覆盖任意素材。"""
+    assets = AssetStore({f"images/page_5_table_3{'_duplicate_' + str(n) if n else ''}.jpg": b"occupied" for n in range(10000)})
+    with pytest.raises(ValueError, match="Too many conflicting image assets"):
+        materialize_middle(_document(image_base64=_uri()), assets)
+    assert len(assets) == 10000
+
+
+def test_callbacks_receive_original_page_and_validated_relative_path() -> None:
+    """宿主只提供字节，图片扩展名和旧 HTML 属性由共享导出逻辑保留。"""
+    middle = _document('<img src="图%20片.JPEG">', _uri())
+    calls: list[object] = []
+
+    def image_resolver(block: ImagePayloadBlock, page_idx: int) -> tuple[bytes, str]:
+        """记录原始页号，模拟宿主从源 PDF 或本地文件取得载荷。"""
+        calls.append((block.type, page_idx))
+        return b"direct", ".PNG"
+
+    def asset_resolver(path: str) -> bytes:
+        """接收完成 URL 解码及安全检查后的相对路径。"""
+        calls.append(path)
+        return b"inline"
+
+    saved, assets = materialize_middle(middle, image_resolver=image_resolver, asset_resolver=asset_resolver)
+    assert calls == [("table_body", 5), "图 片.JPEG"]
+    assert dict(assets) == {"images/page_5_table_3.png": b"direct", "images/page_5_table_image_3_1.jpeg": b"inline"}
+    assert saved.pages[0].blocks[0].content[0].content == '<img src="images/page_5_table_image_3_1.jpeg">'
+    assert middle.pages[0].blocks[0].content[0].image_base64 == _uri()
+    validate_materialized_assets(saved, assets)
+
+
+def test_callback_none_preserves_payload_without_default_fallback() -> None:
+    """宿主获取失败不会隐式回退，兼容 Gradio 忽略非法直接载荷的行为。"""
+    middle = _document(image_base64="invalid")
+
+    def unavailable(block: ImagePayloadBlock, page_idx: int) -> None:
+        """模拟宿主无法取得图片字节。"""
+        return None
+
+    saved, assets = materialize_middle(middle, image_resolver=unavailable)
+    assert saved == middle and not assets
+    with pytest.raises(ValueError, match="Invalid image data URI"):
+        materialize_middle(middle)
+
+
+@pytest.mark.parametrize("reference", ["../outside.jpg", "%2e%2e/outside.jpg", "/outside.jpg"])
+def test_unsafe_paths_rejected_before_asset_callback(reference: str) -> None:
+    """宿主读取回调不能接收到目录穿越或绝对路径。"""
+
+    def reject_call(path: str) -> bytes:
+        """安全校验失败时不允许触发真实文件读取。"""
+        raise AssertionError(path)
+
+    with pytest.raises(ValueError):
+        materialize_middle(_document(f'<img src="{reference}">'), asset_resolver=reject_call)
+
+
+def test_historical_paths_stay_unchanged_and_missing_assets_still_fail() -> None:
+    """默认不重命名历史引用，也不自动从当前目录读取缺失图片。"""
+    direct = "images/page_5_table_body_3.jpg"
+    inline = "images/page_5_table_body_3_1.jpg"
+    middle = _document(f'<img src="{inline}">')
+    middle.pages[0].blocks[0].content[0].image_path = direct
+    supplied = AssetStore({direct: b"old-direct", inline: b"old-inline"})
+    saved, assets = materialize_middle(middle, supplied)
+    assert saved == middle and dict(assets) == dict(supplied)
+    validate_materialized_assets(saved, assets)
+    missing, missing_assets = materialize_middle(middle)
+    with pytest.raises(ValueError, match="Missing materialized asset"):
+        validate_materialized_assets(missing, missing_assets)

{docvortex-0.4.18 → docvortex-0.4.19}/tests/test_public_export_api.py

@@ -56,7 +56,7 @@ def test_public_export_preserves_payloads_geometry_and_code() -> None:
     before = middle.to_json()
     exported, assets = materialize_middle(middle)
     validate_materialized_assets(exported, assets)
-    assert set(assets) == {"images/page_4_table_body_2.jpg", "images/page_4_table_body_2_1.jpg"}
+    assert set(assets) == {"images/page_4_table_2.jpg", "images/page_4_table_image_2_1.jpg"}
     assert all(payload == image for payload in assets.values())
     assert exported.extensions == middle.extensions
     assert exported.pages[0].blocks[1].content[0].content == markup

{docvortex-0.4.18 → docvortex-0.4.19}/tests/unittest/test_middle_json_export.py

@@ -85,17 +85,17 @@ def test_export_writes_direct_and_multiple_html_images_without_mutating_source(t
     exported_body = result.middle_json.pages[0].blocks[0].content[0]
 
     assert {path.name for path in result.image_paths} == {
-        "page_3_table_body_4.jpg",
-        "page_3_table_body_4_1.gif",
-        "page_3_table_body_4_2.png",
+        "page_3_table_4.jpg",
+        "page_3_table_image_4_1.gif",
+        "page_3_table_image_4_2.png",
     }
-    assert (tmp_path / "images/page_3_table_body_4.jpg").read_bytes() == jpeg_payload
-    assert (tmp_path / "images/page_3_table_body_4_1.gif").read_bytes() == gif_payload
-    assert (tmp_path / "images/page_3_table_body_4_2.png").read_bytes() == png_payload
-    assert exported_body.image_path == "images/page_3_table_body_4.jpg"
+    assert (tmp_path / "images/page_3_table_4.jpg").read_bytes() == jpeg_payload
+    assert (tmp_path / "images/page_3_table_image_4_1.gif").read_bytes() == gif_payload
+    assert (tmp_path / "images/page_3_table_image_4_2.png").read_bytes() == png_payload
+    assert exported_body.image_path == "images/page_3_table_4.jpg"
     assert exported_body.image_base64 is None
-    assert "images/page_3_table_body_4_1.gif" in exported_body.content
-    assert "images/page_3_table_body_4_2.png" in exported_body.content
+    assert "images/page_3_table_image_4_1.gif" in exported_body.content
+    assert "images/page_3_table_image_4_2.png" in exported_body.content
     assert "image_base64" not in exported_json
     assert "data:image/" not in exported_json
     assert middle_json.pages[0].blocks[0].content[0].image_base64 == jpeg_uri
@@ -116,7 +116,7 @@ def test_export_supports_strict_svg_payload(tmp_path: Path) -> None:
 
     result = export_middle_json(middle_json, tmp_path)
 
-    assert (tmp_path / "images/page_3_table_body_2.svg").read_bytes() == svg_payload
+    assert (tmp_path / "images/page_3_table_2.svg").read_bytes() == svg_payload
     assert result.middle_json.pages[0].blocks[0].content[0].image_path.endswith(".svg")
 
 
@@ -136,9 +136,9 @@ def test_export_supports_direct_png_and_html_jpeg(tmp_path: Path) -> None:
 
     result = export_middle_json(middle_json, tmp_path)
 
-    assert (tmp_path / "images/page_3_table_body_5.png").read_bytes() == png_payload
-    assert (tmp_path / "images/page_3_table_body_5_1.jpg").read_bytes() == jpeg_payload
-    assert "images/page_3_table_body_5_1.jpg" in result.middle_json.pages[0].blocks[0].content[0].content
+    assert (tmp_path / "images/page_3_table_5.png").read_bytes() == png_payload
+    assert (tmp_path / "images/page_3_table_image_5_1.jpg").read_bytes() == jpeg_payload
+    assert "images/page_3_table_image_5_1.jpg" in result.middle_json.pages[0].blocks[0].content[0].content
 
 
 @pytest.mark.parametrize(
@@ -174,7 +174,7 @@ def test_export_rejects_unparsed_inline_data_uri_before_writing(tmp_path: Path)
         )
     )
 
-    with pytest.raises(ValueError, match="inline image data URI"):
+    with pytest.raises(ValueError, match="Invalid image data URI"):
         export_middle_json(middle_json, output_dir)
 
     assert not output_dir.exists()
@@ -203,7 +203,7 @@ def test_export_preflights_conflicts_and_supports_explicit_overwrite(tmp_path: P
 
     export_middle_json(first, tmp_path)
     export_middle_json(first, tmp_path)
-    image_path = tmp_path / "images/page_3_table_body_0.jpg"
+    image_path = tmp_path / "images/page_3_table_0.jpg"
     with pytest.raises(FileExistsError):
         export_middle_json(second, tmp_path)
     assert image_path.read_bytes() == first_payload
@@ -227,7 +227,7 @@ def test_export_conflicting_json_rolls_back_before_any_image_write(tmp_path: Pat
     with pytest.raises(FileExistsError):
         export_middle_json(middle_json, tmp_path)
 
-    assert not (tmp_path / "images/page_3_table_body_9.jpg").exists()
+    assert not (tmp_path / "images/page_3_table_9.jpg").exists()
     assert (tmp_path / "middle_json.json").read_text() == "occupied"
 
 
@@ -236,7 +236,7 @@ def test_export_restores_existing_files_after_commit_failure(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     """验证提交中途失败时会恢复已覆盖文件，并清理全部临时文件。"""
-    image_path = tmp_path / "images/page_3_table_body_0.jpg"
+    image_path = tmp_path / "images/page_3_table_0.jpg"
     image_path.parent.mkdir()
     image_path.write_bytes(b"old-image")
     json_path = tmp_path / "middle_json.json"