weasyvsdx 0.1.0__py3-none-any.whl

weasyvsdx/__init__.py

@@ -0,0 +1,88 @@
+"""Visio drawings for WeasyPrint, drawn as vector SVG through libvisio.
+
+Call ``install()`` once, before the first rendering. It patches WeasyPrint in place, for the process: an
+image with a Visio media type renders as the SVG of its first page. The package targets WeasyPrint 70.x and
+warns on any other version.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import weasyprint
+import weasysvg
+
+from . import fetch as _fetch
+from .convert import CONVERTER, LIBVISIO, MIB, Limits, Tools, find_converter, find_tools, libvisio_version
+from .errors import ConversionError
+
+__all__ = ["LIBVISIO", "SUPPORTED_MAJOR", "ConversionError", "ConverterNotFoundError", "install", "installed"]
+
+SUPPORTED_MAJOR = 70
+_INSTALLED: dict[str, str] = {}
+
+
+class ConverterNotFoundError(FileNotFoundError):
+    """vsd2xhtml is not on the PATH: install libvisio-tools."""
+
+
+def _check_version() -> None:
+    version = getattr(weasyprint, "__version__", "")
+    if version.split(".", 1)[0] != str(SUPPORTED_MAJOR):
+        warnings.warn(
+            f"weasyvsdx targets WeasyPrint {SUPPORTED_MAJOR}.x, found {version or 'unknown'}: the patch may not apply",
+            RuntimeWarning,
+            stacklevel=3,
+        )
+
+
+def _check_libvisio(converter: str) -> None:
+    version = libvisio_version(converter)
+    if version != LIBVISIO:
+        warnings.warn(
+            f"weasyvsdx is tested with libvisio {LIBVISIO}, found {version or 'unknown'}: libvisio 0.1.8 to 0.1.11 fill the shapes of a VSDX with theme colors",
+            RuntimeWarning,
+            stacklevel=3,
+        )
+
+
+def install(
+    *,
+    converter: str | None = None,
+    text: bool = True,
+    emf: bool = True,
+    timeout: float = 30.0,
+    max_input_mb: int = 64,
+    max_output_mb: int = 256,
+    max_memory_mb: int = 2048,
+) -> str:
+    """Render Visio drawings in WeasyPrint, and return the path of the converter.
+
+    ``converter`` is the vsd2xhtml to run, found on the PATH by default. ``text`` lays the text out anew
+    from vsd2raw, next to it, as HTML in a foreignObject: it wraps and aligns as in Visio. weasysvg draws the
+    foreignObject, so install() installs weasysvg with its defaults unless its foreign_object is already
+    installed. Without vsd2raw the text stays as vsd2xhtml writes it. ``emf`` turns EMF images into SVG
+    through emf2svg-conv, where it is on the PATH; WeasyPrint cannot read EMF. One run of a tool may take
+    ``timeout`` seconds, read ``max_input_mb`` of drawing and, on Linux, write ``max_output_mb`` of SVG and
+    use ``max_memory_mb`` of memory. A drawing past a limit renders as a broken image. A later call
+    changes the converter and the limits. Raises ConverterNotFoundError when there is no converter, and
+    warns when it reports another libvisio than ``LIBVISIO``.
+    """
+    _check_version()
+    path = find_converter(converter or CONVERTER)
+    if path is None:
+        raise ConverterNotFoundError(f"{converter or CONVERTER} not found: install libvisio-tools")
+    _check_libvisio(path)
+    found = find_tools(path)
+    tools = Tools(path, found.raw if text else None, found.emf if emf else None)
+    if tools.raw is not None and "foreign_object" not in weasysvg.installed():
+        weasysvg.install()
+    limits = Limits(timeout=timeout, max_input=max_input_mb * MIB, max_output=max_output_mb * MIB, max_memory=max_memory_mb * MIB)
+    _fetch.install(tools, limits)
+    _INSTALLED["converter"] = path
+    return path
+
+
+def installed() -> str | None:
+    """The path of the converter of the last install(), or None before the first."""
+    return _INSTALLED.get("converter")

weasyvsdx/convert.py

@@ -0,0 +1,223 @@
+"""A Visio drawing to the SVG of its first page, through the tools of libvisio.
+
+libvisio is the importer of LibreOffice. Its tool vsd2xhtml writes each page of a drawing as an SVG inside
+one XHTML document. The first page is the image, as LibreOffice exports it. Its text and its arrowheads are
+drawn anew from the output of vsd2raw (text.py, markers.py), and its EMF images become SVG through
+emf2svg-conv (images.py). A path that starts without a moveto gets one (paths.py). Both tools are optional: without them the page stays as vsd2xhtml writes it.
+
+The tools parse untrusted input in C, and a broken file can crash them: ``recursion-cycle.vsdx`` of the
+libvisio tests ends in a segmentation fault. So each runs in a process of its own, in a temporary
+directory, with a time limit, and on Linux with a limit on its memory and on the size of its output.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import shutil
+import subprocess
+import tempfile
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+from . import geometry, gradients, hatch, hidden, hidden_text, images, markers, paths, raw, text
+from .errors import ConversionError
+
+SVG_NS = "http://www.w3.org/2000/svg"
+CONVERTER = "vsd2xhtml"
+RAW_CONVERTER = "vsd2raw"
+EMF_CONVERTER = "emf2svg-conv"
+MIB = 1024 * 1024
+# The release of libvisio weasyvsdx is tested with. 0.1.8 to 0.1.11 fill the shapes of a VSDX with the
+# colors of its theme over their own.
+LIBVISIO = "0.1.7"
+VERSION_TIMEOUT = 10.0
+VERSION = re.compile(r"\d+(?:\.\d+)+")
+# The part of the error output of a tool that an error message quotes
+STDERR_CHARS = 300
+LOGGER = logging.getLogger("weasyvsdx")
+
+# The limits run through the shell: subprocess has no parameter for them, and its preexec_fn is not safe
+# in a process with threads, such as a service that renders in a thread pool. ulimit -v and -f fail on
+# macOS, where the limits are then left out; the time limit holds everywhere.
+LIMITED = 'ulimit -v "$1" 2>/dev/null; ulimit -f "$2" 2>/dev/null; shift 2; exec "$@"'
+
+
+@dataclass(frozen=True)
+class Limits:
+    """What one run of a tool may take: seconds, and bytes of input, output and memory."""
+
+    timeout: float = 30.0
+    max_input: int = 64 * MIB
+    max_output: int = 256 * MIB
+    max_memory: int = 2048 * MIB
+
+    def with_timeout(self, timeout: float) -> Limits:
+        """The same limits with another timeout."""
+        return Limits(timeout=timeout, max_input=self.max_input, max_output=self.max_output, max_memory=self.max_memory)
+
+
+@dataclass(frozen=True)
+class Tools:
+    """The paths of the tools: vsd2xhtml, and vsd2raw and emf2svg-conv where found."""
+
+    converter: str
+    raw: str | None = None
+    emf: str | None = None
+
+
+def libvisio_version(converter: str) -> str | None:
+    """The release of libvisio that vsd2xhtml reports, such as 0.1.7; None where it reports none."""
+    try:
+        result = subprocess.run([converter, "--version"], stdin=subprocess.DEVNULL, capture_output=True, timeout=VERSION_TIMEOUT, check=False)
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    words = result.stdout.decode(errors="replace").split()
+    if result.returncode != 0 or len(words) != 2 or VERSION.fullmatch(words[1]) is None:
+        return None
+    return words[1]
+
+
+def find_converter(name: str = CONVERTER) -> str | None:
+    """The path of vsd2xhtml, or None when it is not on the PATH."""
+    return shutil.which(name)
+
+
+def find_tools(converter: str) -> Tools:
+    """vsd2xhtml with the vsd2raw next to it, both of libvisio-tools, and emf2svg-conv on the PATH."""
+    return Tools(converter, shutil.which(str(Path(converter).with_name(RAW_CONVERTER))), shutil.which(EMF_CONVERTER))
+
+
+class Job:
+    """A tool running in a process of its own, in folder, with the limits. result() waits for its output."""
+
+    def __init__(self, command: list[str], folder: Path, limits: Limits) -> None:
+        self.name = Path(command[0]).name
+        self._limits = limits
+        self._started = time.monotonic()
+        self._output, self._errors = folder / f"{self.name}.out", folder / f"{self.name}.err"
+        # ulimit -v counts KiB, ulimit -f blocks of 512 bytes
+        limited = ["/bin/sh", "-c", LIMITED, "sh", str(limits.max_memory // 1024), str(limits.max_output // 512), *command]
+        # Fixed tools on a file of the temporary directory: no shell reads the drawing
+        with self._output.open("wb") as stdout, self._errors.open("wb") as stderr:
+            self._process = subprocess.Popen(limited, stdin=subprocess.DEVNULL, stdout=stdout, stderr=stderr, cwd=folder)
+
+    def result(self) -> bytes:
+        """What the tool wrote to its output. Raises ConversionError."""
+        try:
+            returncode = self._process.wait(timeout=max(self._limits.timeout - (time.monotonic() - self._started), 0))
+        except subprocess.TimeoutExpired as e:
+            self.cancel()
+            raise ConversionError(f"{self.name} took more than {self._limits.timeout} s") from e
+        if returncode != 0:
+            message = self._errors.read_text(errors="replace")[:STDERR_CHARS].strip()
+            raise ConversionError(f"{self.name} failed with exit code {returncode}{': ' + message if message else ''}")
+        if self._output.stat().st_size > self._limits.max_output:
+            raise ConversionError(f"{self.name} wrote more than {self._limits.max_output} bytes")
+        return self._output.read_bytes()
+
+    def cancel(self) -> None:
+        """Stop the tool, if it still runs."""
+        if self._process.poll() is None:
+            self._process.kill()
+            self._process.wait()
+
+
+def run(command: list[str], folder: Path, limits: Limits) -> bytes:
+    """What the command writes to its output, run in folder. Raises ConversionError."""
+    return Job(command, folder, limits).result()
+
+
+def convert(data: bytes, tools: Tools, limits: Limits) -> bytes:
+    """The SVG of the first page of the drawing, as bytes. Raises ConversionError."""
+    if len(data) > limits.max_input:
+        raise ConversionError(f"the drawing has more than {limits.max_input} bytes")
+    with tempfile.TemporaryDirectory(prefix="weasyvsdx-") as directory:
+        folder = Path(directory)
+        source = folder / "drawing"
+        source.write_bytes(data)
+        # vsd2raw parses the drawing as long as vsd2xhtml: both run at once, which halves the time
+        raw_job = Job([tools.raw, str(source)], folder, limits) if tools.raw is not None else None
+        try:
+            page = first_page(run([tools.converter, str(source)], folder, limits))
+            paths.start_with_moveto(page)
+            if raw_job is not None:
+                redraw(page, raw_job, data)
+        finally:
+            if raw_job is not None:
+                raw_job.cancel()
+        if tools.emf is not None:
+            images.replace_emf(page, emf_converter(tools.emf, folder, limits), folder)
+    return serialize(page)
+
+
+def emf_converter(emf: str, folder: Path, limits: Limits) -> images.Converter:
+    """emf2svg-conv for each EMF of a page. All of them share one timeout: a page may hold thousands."""
+    deadline = time.monotonic() + limits.timeout
+
+    def to_svg(path: Path) -> bytes:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            raise ConversionError(f"the EMF images took more than {limits.timeout} s")
+        return run([emf, "-i", str(path), "-o", "/dev/stdout"], folder, limits.with_timeout(remaining))
+
+    return to_svg
+
+
+def redraw(page: ET.Element, job: Job, document: bytes) -> None:
+    """Draw the text, arrowheads, hatches and gradients of the page anew from what vsd2raw prints, and drop its hidden shapes."""
+    try:
+        calls = raw.first_page(job.result().decode("utf-8", errors="replace"))
+    except ConversionError as e:
+        LOGGER.warning("The text and arrowheads of a Visio drawing stay as vsd2xhtml writes them: %s", e)
+        return
+    # First: the steps after it pair the paths of the page with the drawPath calls, and pass by the paths it adds
+    if geometry.add_missing(page, calls, document) is None:
+        LOGGER.warning("Parts of shapes of master groups of a Visio drawing may be missing: vsd2raw and vsd2xhtml count other paths")
+    # Before hidden shapes go: both pair the paths of the page with the drawPath calls
+    if not hatch.fill_hatches(page, calls):
+        LOGGER.warning("Hatched shapes of a Visio drawing may fill black: vsd2raw and vsd2xhtml count other paths")
+    filled = gradients.shape_gradients(document)
+    if filled and not gradients.fill_gradients(page, calls, filled):
+        LOGGER.warning("Shapes of a Visio drawing that fill with a gradient may fill black: vsd2raw and vsd2xhtml count other paths")
+    if not hidden.remove_hidden(page, calls):
+        LOGGER.warning("Hidden shapes of a Visio drawing may show: vsd2raw and vsd2xhtml count other paths")
+    objects = text.text_objects(calls)
+    # The text that the shapes of a VSDX hide, which libvisio writes
+    shapes = hidden_text.shape_texts(document)
+    hidden_texts = hidden_text.hidden_indexes(shapes, [text.plain(item) for item in objects]) if shapes else frozenset()
+    if not text.replace_text(page, objects, hidden_texts):
+        LOGGER.warning("The text of a Visio drawing stays as vsd2xhtml writes it: vsd2raw and vsd2xhtml count other text objects")
+    if not markers.replace_markers(page, calls):
+        LOGGER.warning("Some arrowheads of a Visio drawing stay as vsd2xhtml writes them: vsd2raw and vsd2xhtml count other markers")
+
+
+def first_page(document: bytes) -> ET.Element:
+    """The first SVG of the XHTML of vsd2xhtml."""
+    try:
+        # The output of libvisio, which escapes the text of the drawing and declares no entities
+        root = ET.fromstring(document)
+    except ET.ParseError as e:
+        raise ConversionError(f"{CONVERTER} wrote no well-formed XHTML: {e}") from e
+    page = root.find(f".//{{{SVG_NS}}}svg")
+    if page is None:
+        raise ConversionError(f"the drawing has no page that {CONVERTER} draws")
+    # libvisio 0.1.9 and later write a page of no size for a drawing they cannot read, where 0.1.7 failed
+    if raw.points(page.get("width")) <= 0 or raw.points(page.get("height")) <= 0:
+        raise ConversionError(f"the first page that {CONVERTER} draws has no size")
+    return page
+
+
+def serialize(page: ET.Element) -> bytes:
+    """The page as an SVG document of its own."""
+    # The SVG namespace as the default one, without the prefix of the XHTML. The default_namespace of
+    # tostring() cannot do it: it refuses attributes without a namespace, which is nearly all of them.
+    prefix = f"{{{SVG_NS}}}"
+    for element in page.iter():
+        if isinstance(element.tag, str) and element.tag.startswith(prefix):
+            element.tag = element.tag[len(prefix) :]
+    page.set("xmlns", SVG_NS)
+    svg: bytes = ET.tostring(page, encoding="utf-8")
+    return svg

weasyvsdx/errors.py

@@ -0,0 +1,5 @@
+"""The error of a drawing that does not convert, shared by the modules that run the tools."""
+
+
+class ConversionError(Exception):
+    """A drawing that the converter cannot turn into SVG."""

weasyvsdx/fetch.py

@@ -0,0 +1,99 @@
+"""Hands WeasyPrint each Visio drawing as the SVG of its first page.
+
+Touches: ``document.original_get_image_from_uri``, the name under which ``Document`` binds the image loader
+of each rendering: an ``<img>``, ``<object>`` or ``<embed>``, a CSS image, an ``<image>`` inside an SVG. The
+wrapper puts a fetcher in front of the fetcher of the caller. A response that holds a Visio drawing comes
+back as SVG; any other response passes unchanged. WeasyPrint then builds an SVGImage from it, as from any
+SVG, and every URL inside the SVG still goes through the fetcher of the caller.
+"""
+
+from __future__ import annotations
+
+from posixpath import splitext
+from typing import Any
+from urllib.parse import urlsplit
+
+from weasyprint import document as wp_document
+from weasyprint.urls import URLFetcherResponse
+
+from .convert import Limits, Tools, convert
+
+# The media types of Visio drawings, templates and stencils, binary (.vsd) and Open XML (.vsdx). They match
+# lowercase: the headers of a response give the type lowercase.
+VISIO_TYPES = frozenset(
+    {
+        "application/vnd.visio",
+        "application/vnd.ms-visio.drawing",
+        "application/vnd.ms-visio.drawing.main+xml",
+        "application/vnd.ms-visio.drawing.macroenabled.12",
+        "application/vnd.ms-visio.drawing.macroenabled.main+xml",
+        "application/vnd.ms-visio.template",
+        "application/vnd.ms-visio.template.main+xml",
+        "application/vnd.ms-visio.template.macroenabled.12",
+        "application/vnd.ms-visio.stencil",
+        "application/vnd.ms-visio.stencil.macroenabled.12",
+    }
+)
+VISIO_SUFFIXES = frozenset({".vsd", ".vsdx", ".vsdm", ".vst", ".vstx", ".vstm", ".vss", ".vssx", ".vssm"})
+# The types that say nothing of the content. A file URL of an unknown suffix gets text/plain from urllib.
+UNTYPED = frozenset({"", "application/octet-stream", "text/plain"})
+SVG_TYPE = "image/svg+xml"
+
+_ORIGINAL_GET_IMAGE_FROM_URI = wp_document.original_get_image_from_uri
+
+
+def is_visio(content_type: str, url: str) -> bool:
+    """A Visio drawing by its media type, or by the suffix of its path where the type says nothing."""
+    if content_type in VISIO_TYPES:
+        return True
+    return content_type in UNTYPED and not url.startswith("data:") and splitext(urlsplit(url).path)[1].lower() in VISIO_SUFFIXES
+
+
+class VisioFetcher:
+    """The fetcher of the caller, with each Visio drawing turned into SVG."""
+
+    def __init__(self, inner: Any, tools: Tools, limits: Limits) -> None:
+        self._inner = inner
+        self._tools = tools
+        self._limits = limits
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._inner, name)
+
+    def __call__(self, url: str) -> Any:
+        response = self._inner(url)
+        # A redirect may lead to the suffix, or away from it
+        if not (is_visio(response.content_type, url) or is_visio(response.content_type, response.url or "")):
+            return response
+        try:
+            # One byte past the limit is enough to know that the drawing is too large
+            data = response.read(self._limits.max_input + 1)
+        finally:
+            response.close()
+        # A ConversionError fails the fetch: WeasyPrint logs it and leaves the image out, as any broken image
+        svg = convert(data, self._tools, self._limits)
+        return URLFetcherResponse(response.url, svg, {"Content-Type": SVG_TYPE}, response.status)
+
+
+_SETTINGS: dict[str, Any] = {}
+
+
+def _get_image_from_uri(
+    cache: Any,
+    url_fetcher: Any,
+    options: Any,
+    url: str,
+    forced_mime_type: str | None = None,
+    context: Any = None,
+    orientation: str = "from-image",
+) -> Any:
+    if url_fetcher is not None and not isinstance(url_fetcher, VisioFetcher):
+        url_fetcher = VisioFetcher(url_fetcher, _SETTINGS["tools"], _SETTINGS["limits"])
+    return _ORIGINAL_GET_IMAGE_FROM_URI(cache, url_fetcher, options, url, forced_mime_type=forced_mime_type, context=context, orientation=orientation)
+
+
+def install(tools: Tools, limits: Limits) -> None:
+    """Hook the image loader of WeasyPrint. A second call changes the tools and the limits."""
+    _SETTINGS["tools"] = tools
+    _SETTINGS["limits"] = limits
+    wp_document.original_get_image_from_uri = _get_image_from_uri