docvortex 0.4.10__tar.gz → 0.4.12__tar.gz

{docvortex-0.4.10/src/docvortex.egg-info → docvortex-0.4.12}/PKG-INFO

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

{docvortex-0.4.10 → docvortex-0.4.12}/src/docvortex/analyzers/native/epub/xhtml.py

@@ -35,6 +35,7 @@ from docvortex.content.markup.projector import (
 
 from ....content.spans import normalize_span_dicts
 from ....foundation._image_payload import parse_image_data_uri_strict
+from ....foundation._svg_raster import serialize_svg_image
 from .._shared.hyperlink import sanitize_hyperlink_target
 from .constants import IMAGE_MEDIA_BY_EXTENSION, SVG_MEDIA_TYPE
 from .package import EpubPackage
@@ -275,14 +276,22 @@ class _EpubMarkupContext:
         )
 
     def resolve_image(self, source: str, *, alt: str = "") -> ResolvedMarkupImage | None:
-        """读取并严格校验一个 EPUB 包内栅格图片引用。"""
+        """读取并严格校验一个 EPUB 包内图片引用，SVG 光栅化为 PNG。"""
         target = self.package.resolve_reference(source, base_part=self.chapter_path)
         if target is None:
             return ResolvedMarkupImage(alt=alt) if alt else None
         media_type = (self.package.content_type_for(target.path) or "").casefold()
         extension = target.path.rsplit(".", 1)[-1].casefold() if "." in target.path else ""
         media_type = media_type or IMAGE_MEDIA_BY_EXTENSION.get(extension, "")
-        if not media_type.startswith("image/") or media_type == SVG_MEDIA_TYPE:
+        if media_type == SVG_MEDIA_TYPE:
+            payload = self.package.read_part(target.path, asset=True)
+            if payload is None:
+                return ResolvedMarkupImage(alt=alt) if alt else None
+            data_uri = serialize_svg_image(payload)
+            if data_uri is None:
+                return ResolvedMarkupImage(alt=alt) if alt else None
+            return ResolvedMarkupImage(image_base64=data_uri, alt=alt)
+        if not media_type.startswith("image/"):
             return ResolvedMarkupImage(alt=alt) if alt else None
         payload = self.package.read_part(target.path, asset=True)
         if payload is None:

{docvortex-0.4.10 → docvortex-0.4.12}/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.10 → docvortex-0.4.12}/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]
 
@@ -14,13 +13,13 @@ from docvortex.content.markup import ResolvedMarkupImage
 from docvortex.document.contracts import HtmlSourceContext
 
 from ....foundation._image_payload import parse_image_data_uri_strict, validate_remote_image_url
+from ....foundation._svg_raster import looks_like_svg_payload, serialize_svg_image
 from .._shared.hyperlink import sanitize_hyperlink_target
 from .constants import (
     MAX_HTML_IMAGE_BYTES,
     MAX_HTML_IMAGE_TOTAL_BYTES,
     MAX_HTML_STYLESHEET_BYTES,
     MAX_HTML_STYLESHEET_TOTAL_BYTES,
-    MAX_REMOTE_IMAGE_FETCH_SECONDS,
 )
 from .errors import HtmlResourceLimitError
 
@@ -67,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
@@ -160,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
@@ -178,7 +176,10 @@ class HtmlResourceContext:
             payload = source_file.read(MAX_HTML_IMAGE_BYTES + 1)
         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 local_path.suffix.casefold() == ".svg" or looks_like_svg_payload(payload):
+            data_uri = serialize_svg_image(payload)
+        else:
+            data_uri = _image_data_uri(payload)
         if data_uri is None:
             return ResolvedMarkupImage(alt=alt) if alt else None
         self._charge_image_bytes(len(payload))
@@ -228,7 +229,7 @@ class HtmlResourceContext:
         return self.anchors.note_anchor(note) if self.anchors else None
 
     def _resolve_data_image(self, data_uri: str, *, alt: str) -> ResolvedMarkupImage | None:
-        """严格解析 data URI，并执行单图与累计图片预算。"""
+        """严格解析 data URI 并执行图片预算，SVG 光栅化为 PNG 后内嵌。"""
         if cached := self._data_image_cache.get(data_uri):
             return ResolvedMarkupImage(image_base64=cached.image_base64, alt=alt)
         if len(data_uri) > MAX_HTML_IMAGE_BYTES * 2:
@@ -238,7 +239,15 @@ class HtmlResourceContext:
         except ValueError:
             return ResolvedMarkupImage(alt=alt) if alt else None
         if extension == "svg":
-            return ResolvedMarkupImage(alt=alt) if alt else None
+            if len(payload) > MAX_HTML_IMAGE_BYTES:
+                raise HtmlResourceLimitError(f"HTML image exceeds max_html_image_bytes={MAX_HTML_IMAGE_BYTES}")
+            raster_uri = serialize_svg_image(payload)
+            if raster_uri is None:
+                return ResolvedMarkupImage(alt=alt) if alt else None
+            self._charge_image_bytes(len(payload))
+            resolved = ResolvedMarkupImage(image_base64=raster_uri, alt=alt)
+            self._data_image_cache[data_uri] = resolved
+            return resolved
         if len(payload) > MAX_HTML_IMAGE_BYTES:
             raise HtmlResourceLimitError(f"HTML image exceeds max_html_image_bytes={MAX_HTML_IMAGE_BYTES}")
         self._charge_image_bytes(len(payload))
@@ -246,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.10 → docvortex-0.4.12}/src/docvortex/analyzers/native/office/image.py

@@ -11,6 +11,7 @@ from loguru import logger
 from metafile_render import MetafileError, MetafileResourceLimitError, render_metafile
 from PIL import Image, ImageDraw, ImageFont, UnidentifiedImageError
 
+from ....foundation._svg_raster import is_svg_image_part, looks_like_svg_payload, serialize_svg_image
 from ....foundation.image_encoding import image_to_b64str
 
 VECTOR_IMAGE_FORMATS = frozenset({"WMF", "EMF"})
@@ -267,6 +268,9 @@ def serialize_office_image(
             return rendered
         return serialize_vector_part_with_placeholder(part_name, content_type)
 
+    if is_svg_image_part(part_name, content_type) or looks_like_svg_payload(image_data):
+        return serialize_svg_image(image_data)
+
     try:
         pil_image = Image.open(BytesIO(image_data))
         if is_vector_image(pil_image):

{docvortex-0.4.10 → docvortex-0.4.12}/src/docvortex/analyzers/native/office/odf/text.py

@@ -20,6 +20,7 @@ from .....content.spans import (
     inline_span_plain_text,
     strip_span_dicts,
 )
+from .....foundation._svg_raster import serialize_svg_image
 from .....foundation.image_encoding import image_to_b64str
 from .....schema import BlockType
 from ..._shared.hyperlink import sanitize_hyperlink_target
@@ -108,16 +109,36 @@ def _style_html(text: str, style: TextStyle) -> str:
     return rendered
 
 
+_SVG_RENDER_DPI = 200
+
+
+def _frame_render_size(frame: etree._Element | None) -> tuple[int, int] | None:
+    """按 draw:frame 显示尺寸换算渲染像素，作为 SVG 光栅化的目标尺寸。"""
+    from .converters import _length_to_points
+
+    if frame is None:
+        return None
+    width = _length_to_points(frame.get(qname("svg", "width")))
+    height = _length_to_points(frame.get(qname("svg", "height")))
+    if width <= 0 or height <= 0:
+        return None
+    return (max(1, round(width / 72 * _SVG_RENDER_DPI)), max(1, round(height / 72 * _SVG_RENDER_DPI)))
+
+
 def _serialize_odf_image(
     image_bytes: bytes,
     *,
     part_name: str | None,
     content_type: str | None,
+    size_hint: tuple[int, int] | None = None,
 ) -> str | None:
-    """序列化 ODF 图片；SVG、SVM 和 GDIMeta 使用安全占位图保留对象位置。"""
+    """序列化 ODF 图片；SVG 光栅化为 PNG，SVM 和 GDIMeta 使用安全占位图保留对象位置。"""
     normalized_type = (content_type or "").split(";", 1)[0].strip().casefold()
     suffix = (part_name or "").rsplit(".", 1)[-1].casefold() if "." in (part_name or "") else ""
     if normalized_type == "image/svg+xml" or suffix == "svg":
+        rendered = serialize_svg_image(image_bytes, size_hint=size_hint)
+        if rendered is not None:
+            return rendered
         placeholder = create_text_placeholder((320, 180), ["SVG image", "Preview unavailable"])
         return image_to_b64str(placeholder, image_format="JPEG")
     if suffix == "svm" or "gdimetafile" in normalized_type or image_bytes.startswith(b"VCLMTF"):
@@ -712,7 +733,15 @@ class OdfBlockParser:
             )
         if not image_bytes:
             return None, alt
-        return _serialize_odf_image(image_bytes, part_name=part_name, content_type=content_type), alt
+        return (
+            _serialize_odf_image(
+                image_bytes,
+                part_name=part_name,
+                content_type=content_type,
+                size_hint=_frame_render_size(parent),
+            ),
+            alt,
+        )
 
     def _object_root(self, object_element: etree._Element) -> tuple[etree._Element | None, str | None]:
         """读取 draw:object 指向的子文档内容树和成员路径。"""

{docvortex-0.4.10 → docvortex-0.4.12}/src/docvortex/analyzers/native/office/pptx/resources.py

@@ -1,6 +1,5 @@
 """PPTX 图片、图表与公式资源，复用当前转换器的单文档状态。"""
 
-import base64
 from typing import Any, Optional
 from loguru import logger
 from pptx.enum.shapes import MSO_SHAPE_TYPE
@@ -222,11 +221,19 @@ class _PptxResources:
             return
 
         if content_type == "image/svg+xml":
-            image_block = {
-                "type": BlockType.IMAGE,
-                "image_base64": self._bytes_to_data_uri(image_bytes, content_type),
-            }
-            self.cur_page.append(image_block)
+            img_base64 = serialize_office_image(image_bytes, content_type=content_type)
+            if img_base64 is None:
+                # SVG 光栅化失败时回退到 PowerPoint 为 SVG 原生伴随存储的栅量 blip。
+                fallback_data = self._get_shape_image_data(shape, include_svg=False)
+                if fallback_data is not None and fallback_data[1] != "image/svg+xml":
+                    img_base64 = serialize_office_image(fallback_data[0], content_type=fallback_data[1])
+            if img_base64 is not None:
+                self.cur_page.append(
+                    {
+                        "type": BlockType.IMAGE,
+                        "image_base64": img_base64,
+                    }
+                )
             return
 
         img_base64 = serialize_office_image(
@@ -256,19 +263,14 @@ class _PptxResources:
         )
 
     @staticmethod
-    def _bytes_to_data_uri(image_bytes: bytes, content_type: str) -> str:
-        """按原有图片、图表与公式资源规则执行 _bytes_to_data_uri，保持输入顺序与降级行为。"""
-        encoded = base64.b64encode(image_bytes).decode("utf-8")
-        return f"data:{content_type};base64,{encoded}"
-
-    @staticmethod
-    def _find_first_embedded_image_rid(shape) -> Optional[str]:
+    def _find_first_embedded_image_rid(shape, *, include_svg: bool = True) -> Optional[str]:
         """按原有图片、图表与公式资源规则执行 _find_first_embedded_image_rid，保持输入顺序与降级行为。"""
-        svg_blips = shape._element.findall(f".//{{{SVG_BLIP_NS}}}svgBlip")
-        for svg_blip in svg_blips:
-            relationship_id = svg_blip.get(f"{{{RELATIONSHIP_NS}}}embed")
-            if relationship_id:
-                return relationship_id
+        if include_svg:
+            svg_blips = shape._element.findall(f".//{{{SVG_BLIP_NS}}}svgBlip")
+            for svg_blip in svg_blips:
+                relationship_id = svg_blip.get(f"{{{RELATIONSHIP_NS}}}embed")
+                if relationship_id:
+                    return relationship_id
 
         blips = shape._element.findall(f".//{{{DRAWINGML_NS}}}blip")
         for blip in blips:
@@ -296,11 +298,11 @@ class _PptxResources:
                 return False
         return True
 
-    def _get_shape_image_data(self, shape) -> Optional[tuple[bytes, Optional[str]]]:
+    def _get_shape_image_data(self, shape, *, include_svg: bool = True) -> Optional[tuple[bytes, Optional[str]]]:
         """按原有图片、图表与公式资源规则执行 _get_shape_image_data，保持输入顺序与降级行为。"""
         relationship_id = None
         if hasattr(shape, "_element"):
-            relationship_id = self._find_first_embedded_image_rid(shape)
+            relationship_id = self._find_first_embedded_image_rid(shape, include_svg=include_svg)
 
         if relationship_id:
             try:

{docvortex-0.4.10 → docvortex-0.4.12}/src/docvortex/content/mathml.py

@@ -6,6 +6,7 @@ import re
 
 from lxml import etree  # type: ignore[reportMissingImports]
 
+from ..foundation._text import normalize_formula_tag_content
 from ..foundation.xml_names import local_name
 
 _OPERATOR_MAP = {
@@ -71,6 +72,8 @@ _LATEX_MATH_TOKEN_ESCAPES = {
     "}": r"\}",
     "~": r"\~{}",
 }
+# Word 线性格式把公式编号分隔符写作 ``#(n)``；经 mo 转义后行尾呈现为 ``\#(n)``。
+_EQUATION_TAG_RE = re.compile(r"\\#\s*\(([^()]*)\)\s*$")
 
 
 def _escape_text(value: str) -> str:
@@ -83,6 +86,22 @@ def _escape_math_token(value: str) -> str:
     return "".join(_LATEX_MATH_TOKEN_ESCAPES.get(char, char) for char in value)
 
 
+def _tag_equation_number(latex: str) -> str | None:
+    """把 Word 公式编号分隔符残留的行尾 ``\\#(n)`` 转换为 LaTeX ``\\tag``。
+
+    参考 OMML 转换器 ``do_eqarr`` 的既有语义：单行公式数组末尾的编号
+    ``#(n)`` 输出为 ``公式\\tag{n}``，同时避免 ``\\tag`` 进入 matrix 环境。
+    """
+    match = _EQUATION_TAG_RE.search(latex)
+    if match is None:
+        return None
+    formula = latex[: match.start()].rstrip()
+    tag_content = normalize_formula_tag_content(match.group(1))
+    if not formula or not tag_content:
+        return None
+    return rf"{formula}\tag{{{tag_content}}}"
+
+
 def _children(element: etree._Element) -> list[etree._Element]:
     """返回当前元素的全部普通 XML 子元素。"""
     return [child for child in element if isinstance(child.tag, str)]
@@ -107,7 +126,7 @@ def _convert(element: etree._Element) -> str:
     if name in {"mi", "mn"}:
         return _GREEK_MAP.get(text, _escape_math_token(text))
     if name == "mo":
-        return _OPERATOR_MAP.get(text, text)
+        return _OPERATOR_MAP.get(text, _escape_math_token(text))
     if name == "mtext":
         return rf"\text{{{_escape_text(text)}}}"
     if name == "mspace":
@@ -139,6 +158,8 @@ def _convert(element: etree._Element) -> str:
         return rf"\left{opening}{separators[0].join(values)}\right{closing}"
     if name == "mtable":
         rows = [_convert(child) for child in children if local_name(child) in {"mtr", "mlabeledtr"}]
+        if len(rows) == 1 and (tagged := _tag_equation_number(rows[0])) is not None:
+            return tagged
         return r"\begin{matrix}" + r" \\ ".join(rows) + r"\end{matrix}"
     if name in {"mtr", "mlabeledtr"}:
         return " & ".join(_convert(child) for child in children)
@@ -160,7 +181,7 @@ def mathml_to_latex(math_element: etree._Element) -> str | None:
         if "tex" in encoding and (annotation.text or "").strip():
             return (annotation.text or "").strip()
     latex = _convert(math_element).strip()
-    return latex or None
+    return _tag_equation_number(latex) or latex or None
 
 
 __all__ = ["mathml_to_latex"]

{docvortex-0.4.10 → docvortex-0.4.12}/src/docvortex/document/contracts.py

@@ -10,14 +10,12 @@ from pathlib import Path
 class HtmlSourceContext:
     """保存相对链接解析及 HTML 解码所需的来源上下文。
 
-    fetch_remote_images 默认关闭，远程图片仅记录 URL；开启后解析阶段会对受限
-    HTTP(S) 图片发起网络请求并内嵌，不可信输入的 SSRF 风险由调用者承担。
+    远程图片永不下载，仅在结果中保留受限 HTTP(S) 外链，解析过程保持零网络请求。
     """
 
     source_uri: str | None = None
     local_resource_root: Path | None = None
     transport_encoding: str | None = None
-    fetch_remote_images: bool = False
 
 
 __all__ = ["HtmlSourceContext"]

{docvortex-0.4.10 → docvortex-0.4.12}/src/docvortex/export/files.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from pathlib import Path
+from urllib.parse import urlsplit
 
 from ..assets import AssetStore
 from ..content.tree import iter_child_blocks
@@ -28,7 +29,7 @@ def materialize_middle(middle_json: MiddleJson, assets: AssetStore | None = None
 
 
 def validate_materialized_assets(middle_json: MiddleJson, assets: AssetStore) -> None:
-    """拒绝依赖外部文件或网络的未物化图片，保证结果包能离线重渲染。"""
+    """拒绝缺失的已物化素材，保证结果包内部引用完整；源文档外链原样保留。"""
     from bs4 import BeautifulSoup
 
     pending = [block for page in middle_json.pages for block in page.blocks]
@@ -38,8 +39,6 @@ def validate_materialized_assets(middle_json: MiddleJson, assets: AssetStore) ->
         image_path = getattr(block, "image_path", None)
         if image_path and image_path not in assets:
             raise ValueError(f"Missing materialized asset: {image_path}")
-        if getattr(block, "image_url", None) and not image_path:
-            raise ValueError("An external image must be materialized before saving a bundle")
         content = getattr(block, "content", None)
         if str(block.type) not in {"table_body", "chart_body", "image_body"} or not isinstance(content, str):
             continue
@@ -47,6 +46,8 @@ def validate_materialized_assets(middle_json: MiddleJson, assets: AssetStore) ->
             continue
         for image in BeautifulSoup(content, "html.parser").find_all("img"):
             reference = image.get("src")
+            if reference and _is_external_reference(reference):
+                continue
             if reference and reference not in assets:
                 raise ValueError(f"Missing materialized HTML image: {reference}")
 
@@ -63,4 +64,12 @@ def write_artifact(artifact: RenderArtifact, path: Path, *, overwrite: bool) ->
     return ExportResult(path=path, asset_paths=tuple(path.parent / name for name in artifact.assets))
 
 
+def _is_external_reference(reference: str) -> bool:
+    """判断富文本图片引用是否为保留的受限 HTTP(S) 外链。"""
+    try:
+        return urlsplit(reference).scheme.casefold() in {"http", "https"}
+    except ValueError:
+        return False
+
+
 __all__ = ["materialize_middle", "validate_materialized_assets", "write_artifact"]

docvortex-0.4.12/src/docvortex/foundation/_svg_raster.py

@@ -0,0 +1,158 @@
+"""把外部 SVG 图片资源受控光栅化为 PNG data URI 的共享能力。"""
+
+from __future__ import annotations
+
+import base64
+import math
+import re
+import xml.etree.ElementTree as ElementTree
+from io import BytesIO
+from pathlib import PurePosixPath
+from typing import Final
+
+from loguru import logger
+
+from ._image_payload import (
+    MAX_DECODED_RASTER_DIMENSION,
+    MAX_DECODED_RASTER_PIXELS,
+    _parse_svg_root_strict,
+)
+
+SVG_MEDIA_TYPE: Final = "image/svg+xml"
+SVG_IMAGE_EXTENSION: Final = ".svg"
+# 小尺寸 logo 按固有像素直出会明显发虚，统一放大到最小可视长边。
+_MIN_RENDER_LONG_EDGE: Final = 512
+_SVG_LENGTH_RE = re.compile(r"^([0-9]*\.?[0-9]+)\s*(px|pt|pc|mm|cm|in|q|%)?$", re.IGNORECASE)
+_LENGTH_TO_PX: Final = {
+    "": 1.0,
+    "px": 1.0,
+    "pt": 96.0 / 72.0,
+    "pc": 16.0,
+    "mm": 96.0 / 25.4,
+    "cm": 96.0 / 2.54,
+    "in": 96.0,
+    "q": 96.0 / 101.6,
+}
+_SVG_PAYLOAD_SNIFF_WINDOW: Final = 4096
+
+
+def is_svg_image_part(part_name: object | None = None, content_type: str | None = None) -> bool:
+    """根据部件扩展名和声明媒体类型判断是否为 SVG 图片部件。"""
+    normalized_type = (content_type or "").split(";", 1)[0].strip().casefold()
+    if normalized_type == SVG_MEDIA_TYPE:
+        return True
+    suffix = PurePosixPath(str(part_name or "")).suffix.casefold()
+    return suffix == SVG_IMAGE_EXTENSION
+
+
+def looks_like_svg_payload(image_data: bytes) -> bool:
+    """按载荷前缀嗅探 SVG 根节点，兜底识别被错误标注的图片部件。"""
+    head = image_data[:_SVG_PAYLOAD_SNIFF_WINDOW].lstrip()
+    if head.startswith(b"<svg") or head.startswith(b"<svg:"):
+        return True
+    return head.startswith(b"<?xml") and b"<svg" in head
+
+
+def _length_to_px(value: str | None) -> float | None:
+    """把 SVG width/height 长度解析为像素值，百分比等上下文相关单位返回 None。"""
+    match = _SVG_LENGTH_RE.match((value or "").strip())
+    if match is None:
+        return None
+    unit = match.group(2) or ""
+    if unit == "%":
+        return None
+    return float(match.group(1)) * _LENGTH_TO_PX[unit.casefold()]
+
+
+def _intrinsic_size(root: ElementTree.Element) -> tuple[int, int] | None:
+    """从 svg 根元素解析固有像素尺寸，width/height 不可用时回退 viewBox。"""
+    width = _length_to_px(root.get("width"))
+    height = _length_to_px(root.get("height"))
+    if width is not None and height is not None and width > 0 and height > 0:
+        return max(1, round(width)), max(1, round(height))
+    view_box = (root.get("viewBox") or "").replace(",", " ").split()
+    if len(view_box) == 4:
+        try:
+            box_width, box_height = float(view_box[2]), float(view_box[3])
+        except ValueError:
+            return None
+        if box_width > 0 and box_height > 0:
+            return max(1, round(box_width)), max(1, round(box_height))
+    return None
+
+
+def _clamped_size(width: int, height: int) -> tuple[int, int]:
+    """按光栅单边与总像素预算等比收缩目标尺寸。"""
+    scale = min(
+        1.0,
+        MAX_DECODED_RASTER_DIMENSION / width,
+        MAX_DECODED_RASTER_DIMENSION / height,
+        math.sqrt(MAX_DECODED_RASTER_PIXELS / (width * height)),
+    )
+    if scale >= 1.0:
+        return width, height
+    return max(1, round(width * scale)), max(1, round(height * scale))
+
+
+def _render_size(
+    intrinsic: tuple[int, int] | None,
+    size_hint: tuple[int, int] | None,
+) -> tuple[int, int] | None:
+    """解析渲染目标尺寸：显式提示优先，其次固有尺寸并放大到最小长边。"""
+    if size_hint is not None and size_hint[0] > 0 and size_hint[1] > 0:
+        return _clamped_size(max(1, round(size_hint[0])), max(1, round(size_hint[1])))
+    if intrinsic is None:
+        return None
+    width, height = intrinsic
+    long_edge = max(width, height)
+    if long_edge < _MIN_RENDER_LONG_EDGE:
+        width = max(1, round(width * _MIN_RENDER_LONG_EDGE / long_edge))
+        height = max(1, round(height * _MIN_RENDER_LONG_EDGE / long_edge))
+    return _clamped_size(width, height)
+
+
+def _is_fully_transparent(png: bytes) -> bool:
+    """检测光栅化结果是否全透明，用于让无视觉内容的 SVG 走调用方降级。"""
+    from PIL import Image
+
+    with Image.open(BytesIO(png)) as image:
+        if image.mode not in {"RGBA", "LA"}:
+            return False
+        return image.getextrema()[-1][1] == 0
+
+
+def serialize_svg_image(image_data: bytes, *, size_hint: tuple[int, int] | None = None) -> str | None:
+    """把外部 SVG 字节光栅化为透明 PNG data URI，无法安全渲染时返回 None。
+
+    resvg 不执行脚本也不加载外部资源，是外部 SVG 进入输出的安全净化边界；
+    ``skip_system_fonts=True`` 保证跨平台输出确定，代价是未转路径的 ``<text>``
+    不渲染文字。DTD、实体声明和超预算载荷在解析阶段即被拒绝。
+    """
+    try:
+        root = _parse_svg_root_strict(image_data)
+    except ValueError as exc:
+        logger.warning(f"SVG image payload cannot be parsed safely: {exc}")
+        return None
+
+    import resvg_py
+
+    target_size = _render_size(_intrinsic_size(root), size_hint)
+    # 严格解析后的树重序列化为 UTF-8，避免原始声明的非 UTF-8 编码干扰渲染输入。
+    markup = ElementTree.tostring(root, encoding="unicode")
+    render_options: dict[str, int] = {}
+    if target_size is not None:
+        render_options["width"] = target_size[0]
+        render_options["height"] = target_size[1]
+    try:
+        png = resvg_py.svg_to_bytes(svg_string=markup, skip_system_fonts=True, **render_options)
+        if not png:
+            return None
+        if _is_fully_transparent(png):
+            logger.debug("Rasterized SVG image is fully transparent; degrading to caller fallback")
+            return None
+    except Exception as exc:  # noqa: BLE001 - resvg 异常面未定型，统一降级由调用方兜底
+        logger.warning(f"SVG image cannot be rasterized: {exc}")
+        return None
+
+    encoded = base64.b64encode(png).decode("ascii")
+    return f"data:image/png;base64,{encoded}"

{docvortex-0.4.10 → docvortex-0.4.12}/src/docvortex/version.py

@@ -1,3 +1,3 @@
-__version__ = "0.4.10"
+__version__ = "0.4.12"
 
 __all__ = ["__version__"]

{docvortex-0.4.10 → docvortex-0.4.12/src/docvortex.egg-info}/PKG-INFO

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

{docvortex-0.4.10 → docvortex-0.4.12}/src/docvortex.egg-info/SOURCES.txt

@@ -352,6 +352,7 @@ src/docvortex/foundation/_hyperlink.py
 src/docvortex/foundation/_image.py
 src/docvortex/foundation/_image_operations.py
 src/docvortex/foundation/_image_payload.py
+src/docvortex/foundation/_svg_raster.py
 src/docvortex/foundation/_text.py
 src/docvortex/foundation/image_encoding.py
 src/docvortex/foundation/language.py
@@ -628,6 +629,7 @@ tests/unittest/test_render_html_table.py
 tests/unittest/test_render_image_renderer.py
 tests/unittest/test_render_list_index_utils.py
 tests/unittest/test_structured_content_render.py
+tests/unittest/test_svg_raster.py
 tests/unittest/test_table_merge.py
 tests/unittest/test_table_merge_cell_merge.py
 tests/unittest/test_text_block_anchor.py