metafile-render 0.1.0__py3-none-any.whl

metafile_render/__init__.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2026 Xiaomeng Zhao (myhloli)
+# SPDX-License-Identifier: MIT
+"""WMF/EMF 的跨平台渲染 API。"""
+
+from .api import render_metafile
+from .models import (
+    MetafileDiagnostic,
+    MetafileError,
+    MetafileMalformedError,
+    MetafileOutputFormat,
+    MetafileRenderResult,
+    MetafileResourceLimitError,
+    MetafileUnsupportedError,
+)
+
+__all__ = [
+    "MetafileDiagnostic",
+    "MetafileError",
+    "MetafileMalformedError",
+    "MetafileOutputFormat",
+    "MetafileRenderResult",
+    "MetafileResourceLimitError",
+    "MetafileUnsupportedError",
+    "render_metafile",
+]

metafile_render/__main__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2026 Xiaomeng Zhao (myhloli)
+# SPDX-License-Identifier: MIT
+"""支持 python -m metafile_render。"""
+
+from .cli import main
+
+__all__: list[str] = []
+
+if __name__ == "__main__":
+    raise SystemExit(main())

metafile_render/api.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2026 Xiaomeng Zhao (myhloli)
+# SPDX-License-Identifier: MIT
+"""WMF/EMF 公共渲染入口。"""
+
+from __future__ import annotations
+
+from .models import MetafileOutputFormat, MetafileRenderResult
+from .parser import parse_metafile
+from .render import encode_document
+
+
+def render_metafile(
+    data: bytes,
+    *,
+    output_format: MetafileOutputFormat = "png",
+    dpi: int = 144,
+    size_hint: tuple[int, int] | None = None,
+) -> MetafileRenderResult:
+    """把 WMF/EMF 字节渲染为 PNG、JPEG、WebP 或安全 SVG。"""
+    if output_format not in {"png", "jpeg", "svg", "webp"}:
+        raise ValueError(f"unsupported metafile output format: {output_format}")
+    document = parse_metafile(data, dpi=dpi, size_hint=size_hint)
+    output, media_type = encode_document(document, output_format)
+    return MetafileRenderResult(
+        data=output,
+        output_format=output_format,
+        media_type=media_type,
+        width=document.width,
+        height=document.height,
+        source_format=document.source_format,
+        emfplus_mode=document.emfplus_mode,
+        partial=document.partial,
+        diagnostics=document.diagnostics,
+    )
+
+
+__all__ = ["render_metafile"]

metafile_render/binary.py

@@ -0,0 +1,77 @@
+# Copyright (c) 2026 Xiaomeng Zhao (myhloli)
+# SPDX-License-Identifier: MIT
+"""WMF/EMF 使用的严格有界二进制读取器。"""
+
+from __future__ import annotations
+
+import struct
+
+from .models import MetafileMalformedError
+
+
+class BoundedReader:
+    """在固定 memoryview 边界内读取小端标量和切片。"""
+
+    def __init__(self, data: bytes | memoryview, *, base_offset: int = 0) -> None:
+        """保存输入视图与用于诊断的绝对起始偏移。"""
+        self.data = memoryview(data)
+        self.base_offset = base_offset
+
+    def _require(self, offset: int, size: int) -> None:
+        """验证读取范围，不允许负数或越过当前视图。"""
+        if offset < 0 or size < 0 or offset > len(self.data) - size:
+            raise MetafileMalformedError(
+                f"metafile field exceeds record boundary: offset={self.base_offset + offset}, size={size}"
+            )
+
+    def u8(self, offset: int) -> int:
+        """读取小端无符号 8 位整数。"""
+        self._require(offset, 1)
+        return int(self.data[offset])
+
+    def i16(self, offset: int) -> int:
+        """读取小端有符号 16 位整数。"""
+        self._require(offset, 2)
+        return int(struct.unpack_from("<h", self.data, offset)[0])
+
+    def u16(self, offset: int) -> int:
+        """读取小端无符号 16 位整数。"""
+        self._require(offset, 2)
+        return int(struct.unpack_from("<H", self.data, offset)[0])
+
+    def i32(self, offset: int) -> int:
+        """读取小端有符号 32 位整数。"""
+        self._require(offset, 4)
+        return int(struct.unpack_from("<i", self.data, offset)[0])
+
+    def u32(self, offset: int) -> int:
+        """读取小端无符号 32 位整数。"""
+        self._require(offset, 4)
+        return int(struct.unpack_from("<I", self.data, offset)[0])
+
+    def f32(self, offset: int) -> float:
+        """读取小端 IEEE-754 单精度浮点数。"""
+        self._require(offset, 4)
+        return float(struct.unpack_from("<f", self.data, offset)[0])
+
+    def bytes(self, offset: int, size: int) -> bytes:
+        """返回经过边界校验的不可变字节切片。"""
+        self._require(offset, size)
+        return self.data[offset : offset + size].tobytes()
+
+    def subreader(self, offset: int, size: int) -> BoundedReader:
+        """返回继承绝对偏移信息的有界子读取器。"""
+        self._require(offset, size)
+        return BoundedReader(self.data[offset : offset + size], base_offset=self.base_offset + offset)
+
+    def remaining(self, offset: int) -> int:
+        """返回从指定位置到当前视图末尾的剩余字节数。"""
+        self._require(offset, 0)
+        return len(self.data) - offset
+
+    def __len__(self) -> int:
+        """返回当前视图的总字节数。"""
+        return len(self.data)
+
+
+__all__ = ["BoundedReader"]

metafile_render/cli.py

@@ -0,0 +1,97 @@
+# Copyright (c) 2026 Xiaomeng Zhao (myhloli)
+# SPDX-License-Identifier: MIT
+"""单文件 WMF/EMF 转换命令行。"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import tempfile
+from importlib.metadata import version
+from pathlib import Path
+from typing import Sequence
+
+from .api import render_metafile
+from .limits import MAX_METAFILE_BYTES
+from .models import MetafileError, MetafileOutputFormat, MetafileResourceLimitError
+
+_OUTPUT_FORMATS: dict[str, MetafileOutputFormat] = {
+    ".png": "png",
+    ".jpg": "jpeg",
+    ".jpeg": "jpeg",
+    ".svg": "svg",
+    ".webp": "webp",
+}
+
+
+def _positive_integer(value: str) -> int:
+    """将命令行尺寸解析为正整数，错误交由 argparse 报告。"""
+    try:
+        number = int(value)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("must be a positive integer") from exc
+    if number <= 0:
+        raise argparse.ArgumentTypeError("must be a positive integer")
+    return number
+
+
+def _read_input(path: Path) -> bytes:
+    """最多读取输入预算加一字节，避免完整载入超大文件。"""
+    with path.open("rb") as stream:
+        data = stream.read(MAX_METAFILE_BYTES + 1)
+    if len(data) > MAX_METAFILE_BYTES:
+        raise MetafileResourceLimitError(f"metafile exceeds max_metafile_bytes={MAX_METAFILE_BYTES}")
+    return data
+
+
+def _write_output(path: Path, data: bytes, *, overwrite: bool) -> None:
+    """在目标目录原子发布完整文件，并保证默认模式不会覆盖并发创建的文件。"""
+    descriptor, filename = tempfile.mkstemp(prefix=f".{path.name}.", suffix=".tmp", dir=path.parent)
+    temporary = Path(filename)
+    try:
+        with os.fdopen(descriptor, "wb") as stream:
+            stream.write(data)
+        if overwrite:
+            os.replace(temporary, path)
+        else:
+            os.link(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """解析转换参数并返回稳定退出码，所有运行诊断写入 stderr。"""
+    parser = argparse.ArgumentParser(prog="metafile-render", description="Render WMF/EMF to SVG, PNG, JPEG or WebP.")
+    parser.add_argument("input", type=Path, help="input WMF or EMF file")
+    parser.add_argument("-o", "--output", type=Path, required=True, help="output .svg, .png, .jpg, .jpeg or .webp file")
+    parser.add_argument("--dpi", type=_positive_integer, default=144, help="render DPI, 1–1200 (default: 144)")
+    parser.add_argument("--size", type=_positive_integer, nargs=2, metavar=("WIDTH", "HEIGHT"), help="pixel size hint")
+    parser.add_argument("--force", action="store_true", help="replace an existing output file")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {version('metafile-render')}")
+    arguments = parser.parse_args(argv)
+    output_format = _OUTPUT_FORMATS.get(arguments.output.suffix.lower())
+    if output_format is None:
+        parser.error("output extension must be .svg, .png, .jpg, .jpeg or .webp")
+    if arguments.dpi > 1200:
+        parser.error("--dpi must be between 1 and 1200")
+    try:
+        source, destination = arguments.input, arguments.output
+        if source.resolve() == destination.resolve() or destination.exists() and source.samefile(destination):
+            parser.error("input and output must refer to different files")
+        if (destination.exists() or destination.is_symlink()) and not arguments.force:
+            raise FileExistsError(f"output already exists: {destination}; use --force to replace it")
+        size_hint = (arguments.size[0], arguments.size[1]) if arguments.size else None
+        result = render_metafile(_read_input(source), output_format=output_format, dpi=arguments.dpi, size_hint=size_hint)
+        _write_output(destination, result.data, overwrite=arguments.force)
+    except (MetafileError, OSError) as exc:
+        print(f"metafile-render: {exc}", file=sys.stderr)
+        return 1
+    if result.partial:
+        print("metafile-render: partial rendering", file=sys.stderr)
+    for diagnostic in result.diagnostics:
+        print(f"metafile-render: {diagnostic.level} [{diagnostic.code}] {diagnostic.message}", file=sys.stderr)
+    return 0
+
+
+__all__ = ["main"]

metafile_render/font.py

@@ -0,0 +1,112 @@
+# Copyright (c) 2026 Xiaomeng Zhao (myhloli)
+# SPDX-License-Identifier: MIT
+"""WMF/EMF parser 与 renderer 共享的跨平台字体解析和度量。"""
+
+from __future__ import annotations
+
+import platform
+from functools import lru_cache
+from pathlib import Path
+
+from PIL import ImageFont
+
+from .models import Font
+
+
+def _font_search_roots() -> tuple[Path, ...]:
+    """返回当前平台常见字体目录，不在模块导入时访问文件系统。"""
+    system = platform.system()
+    roots: list[Path] = []
+    if system == "Darwin":
+        roots.extend((Path("/System/Library/Fonts"), Path("/Library/Fonts"), Path.home() / "Library/Fonts"))
+    elif system == "Windows":
+        import os
+
+        windows_dir = Path(os.environ.get("WINDIR", "C:/Windows"))
+        roots.append(windows_dir / "Fonts")
+    else:
+        roots.extend(
+            (
+                Path("/usr/share/fonts"),
+                Path("/usr/local/share/fonts"),
+                Path.home() / ".fonts",
+                Path.home() / ".local/share/fonts",
+            )
+        )
+    return tuple(root for root in roots if root.is_dir())
+
+
+@lru_cache(maxsize=1)
+def _font_file_index() -> dict[str, str]:
+    """惰性建立字体文件名索引，避免 import 时扫描系统目录。"""
+    index: dict[str, str] = {}
+    for root in _font_search_roots():
+        try:
+            candidates = root.rglob("*")
+            for candidate in candidates:
+                if candidate.suffix.lower() not in {".ttf", ".ttc", ".otf"}:
+                    continue
+                index.setdefault(candidate.stem.casefold().replace(" ", ""), str(candidate))
+        except OSError:
+            continue
+    return index
+
+
+def _font_aliases(face_name: str, charset: int) -> tuple[str, ...]:
+    """返回 Windows 字体名在 Linux/macOS 上的固定替代顺序。"""
+    normalized = face_name.casefold().replace(" ", "")
+    alias_map = {
+        "arial": ("Arial", "LiberationSans-Regular", "DejaVuSans"),
+        "calibri": ("Calibri", "Carlito-Regular", "Arial", "DejaVuSans"),
+        "cambria": ("Cambria", "Caladea-Regular", "DejaVuSerif"),
+        "timesnewroman": ("Times New Roman", "LiberationSerif-Regular", "DejaVuSerif"),
+        "couriernew": ("Courier New", "LiberationMono-Regular", "DejaVuSansMono"),
+        "simsun": ("SimSun", "Songti SC", "NotoSerifCJKsc-Regular", "DejaVuSans"),
+        "microsoftyahei": ("Microsoft YaHei", "PingFang SC", "NotoSansCJKsc-Regular", "DejaVuSans"),
+    }
+    aliases = alias_map.get(normalized, (face_name,))
+    if charset in {128, 129, 134, 136}:
+        aliases = (*aliases, "PingFang SC", "NotoSansCJKsc-Regular", "NotoSansCJK-Regular", "DejaVuSans")
+    return tuple(dict.fromkeys((*aliases, "DejaVuSans")))
+
+
+@lru_cache(maxsize=256)
+def load_font(
+    face_name: str,
+    size: int,
+    weight: int,
+    italic: bool,
+    charset: int,
+) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
+    """按字体名、别名和文件索引加载 Pillow 字体。"""
+    normalized_size = max(1, min(size, 4096))
+    index = _font_file_index()
+    for alias in _font_aliases(face_name, charset):
+        keys = [alias.casefold().replace(" ", "")]
+        if weight >= 700:
+            keys.insert(0, f"{keys[0]}bold")
+        if italic:
+            keys.insert(0, f"{keys[0]}italic")
+        candidates = [alias, f"{alias}.ttf", *(index[key] for key in keys if key in index)]
+        for candidate in candidates:
+            try:
+                return ImageFont.truetype(candidate, normalized_size)
+            except OSError:
+                continue
+    return ImageFont.load_default(size=normalized_size)
+
+
+def measure_text_advance(font: Font, text: str) -> float:
+    """用 renderer 同款字体回退规则估算无显式 spacing 的逻辑 advance。"""
+    if not text:
+        return 0.0
+    font_size = max(1, round(abs(font.height or -12.0)))
+    loaded = load_font(font.face_name, font_size, font.weight, font.italic, font.charset)
+    advance = float(loaded.getlength(text))
+    if font.width:
+        natural_width = max(float(loaded.getlength("0")), 1e-9)
+        advance *= abs(font.width) / natural_width
+    return max(advance, 0.0)
+
+
+__all__ = ["load_font", "measure_text_advance"]