cardreport 0.2.1__py3-none-any.whl

cardreport/__init__.py

@@ -0,0 +1,94 @@
+"""Compose static reports using a small renderer-independent API."""
+
+from ._inputs import BindingError, DataError, TemplateError
+from .data import (
+    DataLimits,
+    Dataset,
+    DatasetSchema,
+    FieldSpec,
+    FieldType,
+    datasets_from_json,
+    datasets_to_json,
+)
+from .document import ChartData, ChartSeries, ReportDocument
+from .model import (
+    KPI,
+    BarChart,
+    Block,
+    Card,
+    CardContent,
+    Column,
+    Component,
+    Currency,
+    DependencyError,
+    Format,
+    Funnel,
+    LayoutOverflowError,
+    LineChart,
+    Number,
+    Page,
+    PageBreak,
+    RenderError,
+    RenderTimeoutError,
+    Report,
+    ReportError,
+    Row,
+    Table,
+    TableColumn,
+    Text,
+    Theme,
+    UnsupportedFeatureError,
+    ValidationError,
+    Value,
+)
+from .renderers import ChromiumRenderer, Renderer
+from .templates import ReportTemplate
+from .weasyprint import WeasyPrintRenderer
+
+__all__ = [
+    "ReportTemplate",
+    "BindingError",
+    "DataError",
+    "TemplateError",
+    "DataLimits",
+    "Dataset",
+    "DatasetSchema",
+    "FieldSpec",
+    "FieldType",
+    "datasets_from_json",
+    "datasets_to_json",
+    "WeasyPrintRenderer",
+    "ReportDocument",
+    "ChartData",
+    "ChartSeries",
+    "BarChart",
+    "Block",
+    "CardContent",
+    "Component",
+    "Format",
+    "Number",
+    "Value",
+    "UnsupportedFeatureError",
+    "ChromiumRenderer",
+    "Renderer",
+    "Card",
+    "Column",
+    "Currency",
+    "DependencyError",
+    "Funnel",
+    "KPI",
+    "LayoutOverflowError",
+    "LineChart",
+    "Page",
+    "PageBreak",
+    "RenderError",
+    "RenderTimeoutError",
+    "Report",
+    "ReportError",
+    "Row",
+    "Table",
+    "TableColumn",
+    "Text",
+    "Theme",
+    "ValidationError",
+]

cardreport/_inputs.py

@@ -0,0 +1,158 @@
+"""Small bounded JSON and scalar parsing helpers for the interchange layer."""
+
+import json
+import re
+from collections.abc import Mapping
+from datetime import date, datetime
+from decimal import Decimal, InvalidOperation
+from typing import cast
+
+from .model import ReportError, ValidationError
+
+
+class LocatedError(Exception):
+    dataset: str | None
+    row: int | None
+    field: str | None
+    template_path: str | None
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        dataset: str | None = None,
+        row: int | None = None,
+        field: str | None = None,
+        template_path: str | None = None,
+    ) -> None:
+        self.dataset, self.row, self.field = dataset, row, field
+        self.template_path = template_path
+        super().__init__(message)
+
+
+class DataError(LocatedError, ReportError):
+    """Invalid dataset, data transport or adapter input."""
+
+
+class TemplateError(LocatedError, ValidationError):
+    """Invalid presentation definition."""
+
+
+class BindingError(LocatedError, ValidationError):
+    """Data does not satisfy a template's contract."""
+
+
+def mapping(value: object) -> dict[str, object]:
+    if not isinstance(value, Mapping):
+        raise ValueError("expected an object")
+    result: dict[str, object] = {}
+    for key, item in cast(Mapping[object, object], value).items():
+        if not isinstance(key, str):
+            raise ValueError("object keys must be strings")
+        result[key] = item
+    return result
+
+
+def array(value: object) -> list[object]:
+    if not isinstance(value, (list, tuple)):
+        raise ValueError("expected an array")
+    return list(cast(list[object] | tuple[object, ...], value))
+
+
+def keys(obj: Mapping[str, object], required: set[str], optional: set[str]) -> None:
+    if not required <= obj.keys() or obj.keys() - required - optional:
+        raise ValueError("missing required or unknown object keys")
+
+
+def name(value: object) -> str:
+    if not isinstance(value, str) or not 1 <= len(value) <= 100:
+        raise ValueError("expected a nonempty name up to 100 characters")
+    try:
+        value.encode("utf-8")
+    except UnicodeEncodeError as exc:
+        raise ValueError("name must be valid Unicode") from exc
+    return value
+
+
+def _pairs(pairs: list[tuple[str, object]]) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError("duplicate JSON key")
+        result[key] = value
+    return result
+
+
+def _constant(value: str) -> object:
+    raise ValueError("nonfinite JSON number")
+
+
+def load_json(source: str | bytes, max_bytes: int) -> object:
+    if not isinstance(source, (str, bytes)):
+        raise ValueError("expected JSON text or bytes")
+    if len(source) > max_bytes:
+        raise ValueError("JSON byte limit exceeded")
+    if isinstance(source, str) and len(source.encode("utf-8")) > max_bytes:
+        raise ValueError("JSON byte limit exceeded")
+    if isinstance(source, bytes):
+        source = source.decode("utf-8")
+    result: object = json.loads(
+        source, object_pairs_hook=_pairs, parse_constant=_constant
+    )
+    check_tree(result)
+    return result
+
+
+def check_tree(value: object) -> None:
+    # Iterative traversal bounds native trees too, including cycles.
+    stack = [(value, 0)]
+    count = 0
+    while stack:
+        item, depth = stack.pop()
+        count += 1
+        if depth > 64 or count > 500_000:
+            raise ValueError("input tree depth/node limit exceeded")
+        if isinstance(item, Mapping):
+            stack.extend((v, depth + 1) for v in mapping(item).values())
+        elif isinstance(item, (list, tuple)):
+            stack.extend((v, depth + 1) for v in array(item))
+        elif type(item) not in (str, int, float, bool, type(None)):
+            raise ValueError("expected JSON-compatible input")
+
+
+def plain_tree(value: object) -> object:
+    """Normalize mappings after check_tree has bounded depth and rejected cycles."""
+    if isinstance(value, Mapping):
+        return {key: plain_tree(item) for key, item in mapping(value).items()}
+    if isinstance(value, (list, tuple)):
+        return [plain_tree(item) for item in array(value)]
+    return value
+
+
+INTEGER = re.compile(r"[+-]?[0-9]+\Z")
+DECIMAL = re.compile(r"[+-]?(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?\Z")
+DATE = re.compile(r"[0-9]{4}-[0-9]{2}-[0-9]{2}\Z")
+DATETIME = re.compile(
+    r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}"
+    r"(?:\.[0-9]{1,6})?(?:Z|[+-][0-9]{2}:[0-9]{2})\Z"
+)
+
+
+def parse_scalar(text: str, kind: str) -> str | int | Decimal | date:
+    if kind == "text":
+        return text
+    if kind == "integer" and INTEGER.fullmatch(text):
+        return int(text)
+    if kind in ("number", "decimal") and DECIMAL.fullmatch(text):
+        try:
+            return Decimal(text)
+        except InvalidOperation:
+            pass
+    if kind == "date" and DATE.fullmatch(text):
+        return date.fromisoformat(text)
+    if kind == "datetime" and DATETIME.fullmatch(text):
+        # fromisoformat accepts out-of-range offset minutes by normalizing them.
+        if text[-1] != "Z" and (int(text[-5:-3]) > 23 or int(text[-2:]) > 59):
+            raise ValueError("invalid datetime offset")
+        return datetime.fromisoformat(text)
+    raise ValueError(f"expected {kind} in the documented lexical format")

cardreport/_pdf_checks.py

@@ -0,0 +1,82 @@
+"""Inspect all PDF resource scopes, including nested SVG form resources."""
+
+from collections.abc import Iterator
+from importlib.resources import files
+from io import BytesIO
+from typing import Any
+
+from fontTools.ttLib import TTFont
+from pypdf import PdfReader
+
+from .model import LayoutOverflowError, RenderError
+
+
+def resource_scopes(resources: Any, seen: set[int] | None = None) -> Iterator[Any]:
+    seen = set() if seen is None else seen
+    resources = resources.get_object()
+    if id(resources) in seen:
+        return
+    seen.add(id(resources))
+    yield resources
+    if "/XObject" in resources:
+        for ref in resources["/XObject"].get_object().values():
+            obj = ref.get_object()
+            if "/Resources" in obj:
+                yield from resource_scopes(obj["/Resources"], seen)
+
+
+def font_identity(data: bytes) -> frozenset[tuple[int, str]]:
+    with TTFont(BytesIO(data)) as font:
+        return frozenset(
+            (n.nameID, n.toUnicode())
+            for n in font["name"].names
+            if n.nameID in (1, 3, 5)
+        )
+
+
+def verify_fonts(reader: PdfReader) -> None:
+    expected = {
+        font_identity(files("cardreport").joinpath("assets", name).read_bytes())
+        for name in ("DejaVuSans.ttf", "DejaVuSans-Bold.ttf")
+    }
+    for page in reader.pages:
+        for resources in resource_scopes(page["/Resources"]):
+            if "/Font" not in resources:
+                continue
+            for ref in resources["/Font"].get_object().values():
+                font = ref.get_object()
+                descendants = (
+                    font["/DescendantFonts"] if "/DescendantFonts" in font else [font]
+                )
+                for descendant in descendants:
+                    descriptor = descendant.get_object().get("/FontDescriptor")
+                    if (
+                        descriptor is None
+                        or "/FontFile2" not in descriptor.get_object()
+                    ):
+                        raise RenderError("Expected embedded bundled font")
+                    embedded = descriptor.get_object()["/FontFile2"].get_data()
+                    if font_identity(embedded) not in expected:
+                        raise RenderError("Unexpected font identity or version")
+
+
+def verify_chart_bounds(
+    data: bytes, width_px: float, height_px: float, path: str
+) -> None:
+    """Validate glyph bounds in the native SVG render, in PDF points."""
+    import pdfplumber
+
+    with pdfplumber.open(BytesIO(data)) as pdf:
+        if len(pdf.pages) != 1 or not pdf.pages[0].chars:
+            raise RenderError(f"{path}: native SVG text was lost")
+        width, height = width_px * 0.75, height_px * 0.75
+        for char in pdf.pages[0].chars:
+            if (
+                char["x0"] < 0
+                or char["top"] < 0
+                or char["x1"] > width
+                or char["bottom"] > height
+            ):
+                raise LayoutOverflowError(
+                    f"{path}: native chart label exceeds available space"
+                )

cardreport/_svg_charts.py

@@ -0,0 +1,129 @@
+"""Experimental SVG bars, using Matplotlib for axes and text measurement."""
+
+from __future__ import annotations
+
+from importlib.resources import files
+from io import StringIO
+from typing import Any
+from xml.etree import ElementTree as ET
+
+from .model import Currency, Format, LayoutOverflowError, format_value
+
+
+def render_svg(spec: dict[str, Any], width: float, height: float, path: str) -> str:
+    from matplotlib import rc_context, rcdefaults, rcParams
+    from matplotlib.backends.backend_agg import FigureCanvasAgg
+    from matplotlib.figure import Figure
+    from matplotlib.font_manager import FontProperties
+    from matplotlib.layout_engine import ConstrainedLayoutEngine
+    from matplotlib.text import Text
+    from matplotlib.ticker import FuncFormatter, MaxNLocator
+
+    if width < 40 or height < 35 * 96 / 25.4 - 1:
+        raise LayoutOverflowError(f"{path}: chart has insufficient allocated space")
+    font = FontProperties(
+        fname=str(files("cardreport").joinpath("assets", "DejaVuSans.ttf")),
+        size=spec["font_size"],
+    )
+    fmt: Format = (
+        Currency(spec["format"]) if len(spec["format"]) == 3 else spec["format"]
+    )
+    with rc_context():
+        rcdefaults()
+        rcParams.update(
+            {
+                "svg.fonttype": "none",
+                "text.usetex": False,
+                "text.parse_math": False,
+                "font.size": spec["font_size"],
+            }
+        )
+        fig = Figure(figsize=(width / 96, height / 96), dpi=96, layout="constrained")
+        layout = fig.get_layout_engine()
+        assert isinstance(layout, ConstrainedLayoutEngine)
+        layout.set(w_pad=12 / 96, h_pad=8 / 96)
+        canvas = FigureCanvasAgg(fig)
+        ax = fig.subplots()
+        positions = list(range(len(spec["labels"])))
+        horizontal = spec["horizontal"]
+        if horizontal:
+            bars = ax.barh(positions, spec["values"], color=spec["color"])
+            ax.set_yticks(positions, spec["labels"])
+            ax.invert_yaxis()
+            ax.xaxis.set_major_formatter(
+                FuncFormatter(lambda v, _: format_value(v, fmt))
+            )
+            ax.margins(x=0.22)
+        else:
+            bars = ax.bar(positions, spec["values"], color=spec["color"])
+            ax.set_xticks(positions, spec["labels"])
+            ax.yaxis.set_major_formatter(
+                FuncFormatter(lambda v, _: format_value(v, fmt))
+            )
+            ax.margins(y=0.22)
+        if fmt == "integer":
+            (ax.xaxis if horizontal else ax.yaxis).set_major_locator(
+                MaxNLocator(integer=True)
+            )
+        labels = (
+            ax.bar_label(bars, labels=spec["value_labels"], padding=4)
+            if spec["show_labels"]
+            else []
+        )
+        ax.spines[["top", "right"]].set_visible(False)
+        ax.set_axisbelow(True)
+        ax.grid(axis="x" if horizontal else "y", alpha=0.2)
+        ax.set_facecolor("none")
+        fig.patch.set_alpha(0)
+        # Force tick creation before applying the exact bundled font and literal text.
+        canvas.draw()  # type: ignore[no-untyped-call]
+        for label in fig.findobj(Text):
+            label.set_fontproperties(font)
+            label.set_parse_math(False)
+            label.set_color(spec["text_color"])
+        canvas.draw()  # type: ignore[no-untyped-call]
+        renderer = canvas.get_renderer()  # type: ignore[no-untyped-call]
+        area = ax.get_window_extent(renderer)
+        if area.width < 40 or area.height < 40:
+            raise LayoutOverflowError(
+                f"{path}: labels leave insufficient plotting area"
+            )
+        texts: list[Text] = list(labels)
+        for axis, limits in ((ax.xaxis, ax.get_xlim()), (ax.yaxis, ax.get_ylim())):
+            lo, hi = sorted(limits)
+            texts.extend(
+                t.label1 for t in axis.get_major_ticks() if lo <= t.get_loc() <= hi
+            )
+        boxes = []
+        for label in texts:
+            if not label.get_visible() or not label.get_text():
+                continue
+            b = label.get_window_extent(renderer)
+            if b.x0 < 2 or b.y0 < 2 or b.x1 > width - 2 or b.y1 > height - 2:
+                raise LayoutOverflowError(
+                    f"{path}: chart label exceeds available space"
+                )
+            boxes.append(b)
+        for i, a in enumerate(boxes):
+            for b in boxes[i + 1 :]:
+                if (
+                    min(a.x1, b.x1) - max(a.x0, b.x0) > 1
+                    and min(a.y1, b.y1) - max(a.y0, b.y0) > 1
+                ):
+                    raise LayoutOverflowError(f"{path}: chart labels overlap")
+        fig.set_layout_engine("none")
+        out = StringIO()
+        fig.savefig(out, format="svg")
+        svg = out.getvalue()
+        svg = svg[svg.index("<svg") :]
+        # Only style attributes are changed; literal user labels stay untouched.
+        root = ET.fromstring(svg)
+        namespace = "http://www.w3.org/2000/svg"
+        ET.register_namespace("", namespace)
+        ET.register_namespace("xlink", "http://www.w3.org/1999/xlink")
+        for element in root.iter():
+            if element.tag in (f"{{{namespace}}}text", f"{{{namespace}}}tspan"):
+                element.set(
+                    "style", element.get("style", "") + ";font-family:CardReport"
+                )
+        return ET.tostring(root, encoding="unicode")

cardreport/_weasy_boxes.py

@@ -0,0 +1,109 @@
+"""The only adapter to WeasyPrint private boxes. Pinned and guarded by canaries."""
+
+from __future__ import annotations
+
+from base64 import b64encode
+from collections.abc import Iterator
+from importlib.resources import files
+from typing import Any
+
+from .model import DependencyError, LayoutOverflowError
+
+VERSION = "70.0"
+TOLERANCE = 1.0  # CSS px; rounding only, never a text-fit heuristic.
+
+
+def walk(box: Any) -> Iterator[Any]:
+    yield box
+    for child in getattr(box, "children", ()):
+        yield from walk(child)
+
+
+def bounds(box: Any) -> tuple[float, float, float, float]:
+    x, y = float(box.position_x), float(box.position_y)
+    return x, y, x + float(box.margin_width()), y + float(box.margin_height())
+
+
+def inspect(
+    document: Any, expected_pages: int, expected_paths: set[str] | None = None
+) -> dict[str, tuple[float, float]]:
+    """Check page/content bounds and fragmentation, return chart content sizes."""
+    if len(document.pages) != expected_pages:
+        raise LayoutOverflowError("report: dashboard content produced unexpected pages")
+    charts: dict[str, tuple[float, float]] = {}
+    locations: dict[str, set[int]] = {}
+    try:
+        for page_number, page in enumerate(document.pages):
+            root = page._page_box
+            for box in walk(root):
+                element = box.element
+                if element is None:
+                    continue
+                path = element.get("data-path")
+                # Inline text/line boxes repeat their element; inspect the principal box.
+                if not path or type(box).__name__ in ("TextBox", "LineBox"):
+                    continue
+                locations.setdefault(path, set()).add(page_number)
+                x, y = float(box.content_box_x()), float(box.content_box_y())
+                right, bottom = x + float(box.width), y + float(box.height)
+                if element.get("data-chart"):
+                    charts[path] = float(box.width), float(box.height)
+                for child in walk(box):
+                    if child is box:
+                        continue
+                    left, top, r, b = bounds(child)
+                    if (
+                        r > right + TOLERANCE
+                        or b > bottom + TOLERANCE
+                        or left < x - TOLERANCE
+                        or top < y - TOLERANCE
+                    ):
+                        raise LayoutOverflowError(
+                            f"{path}: content exceeds allocated width/height"
+                        )
+        if expected_paths is not None and set(locations) != expected_paths:
+            raise LayoutOverflowError("report: components missing from measured layout")
+        if any(len(pages) > 1 for pages in locations.values()):
+            raise LayoutOverflowError(
+                "report: indivisible dashboard block was fragmented"
+            )
+    except (AttributeError, TypeError, ValueError) as exc:
+        raise DependencyError(
+            "WeasyPrint box adapter is incompatible with this runtime"
+        ) from exc
+    return charts
+
+
+def verify_adapter(html_class: Any, font_config: Any, fetcher: Any) -> None:
+    """A native text-overflow canary must be rejected before trusting private boxes."""
+    import weasyprint
+
+    if weasyprint.__version__ != VERSION:
+        raise DependencyError(f"WeasyPrintRenderer requires WeasyPrint {VERSION}")
+    font = b64encode(
+        files("cardreport").joinpath("assets", "DejaVuSans.ttf").read_bytes()
+    ).decode()
+    css = f"@font-face{{font-family:Canary;src:url(data:font/ttf;base64,{font})}}@page{{size:200px 200px;margin:0}}body{{margin:0;font:12px Canary}}"
+    good = html_class(
+        string=f'<style>{css}</style><div data-path="canary" style="width:150px;height:50px">Fits</div>',
+        url_fetcher=fetcher,
+    ).render(font_config=font_config)
+    try:
+        inspect(good, 1)
+    except LayoutOverflowError as exc:
+        raise DependencyError("WeasyPrint detector rejected a fitting canary") from exc
+    for style, text in (
+        ("width:25px;height:8px", "word " * 30),
+        ("width:10px;height:80px;white-space:nowrap", "unbreakableword"),
+    ):
+        html = (
+            f'<style>{css}</style><div data-path="canary" style="{style}">{text}</div>'
+        )
+        doc = html_class(string=html, url_fetcher=fetcher).render(
+            font_config=font_config
+        )
+        try:
+            inspect(doc, 1)
+        except LayoutOverflowError:
+            continue
+        raise DependencyError("WeasyPrint overflow detector failed its canary")

cardreport/_weasy_worker.py

@@ -0,0 +1,115 @@
+"""Owned WeasyPrint process; imports native dependencies only inside the worker."""
+
+from __future__ import annotations
+
+import io
+import json
+import re
+import sys
+from base64 import b64encode
+from importlib.resources import files
+from typing import Any
+
+from .model import DependencyError, RenderError, ReportError
+
+
+def main() -> None:
+    try:
+        from weasyprint import HTML
+        from weasyprint.text.fonts import FontConfiguration
+    except (ImportError, OSError) as exc:
+        raise DependencyError(
+            "WeasyPrint native libraries unavailable; see README native-library setup"
+        ) from exc
+    from ._svg_charts import render_svg
+    from ._weasy_boxes import inspect, verify_adapter
+
+    payload = json.loads(sys.stdin.buffer.read())
+    fonts = {}
+    for name in ("DejaVuSans.ttf", "DejaVuSans-Bold.ttf"):
+        data = files("cardreport").joinpath("assets", name).read_bytes()
+        fonts["data:font/ttf;base64," + b64encode(data).decode()] = data
+
+    class BundledFonts:
+        _fail_on_errors = False  # Record denial; fail explicitly after native layout.
+        blocked: bool = False
+
+        def __call__(self, url: str) -> Any:
+            from weasyprint.urls import URLFetcherResponse
+
+            if url not in fonts:
+                self.blocked = True
+                raise ValueError("External resource blocked")
+            return URLFetcherResponse(url, fonts[url], {"Content-Type": "font/ttf"})
+
+    fetch = BundledFonts()
+
+    config = FontConfiguration()
+    verify_adapter(HTML, config, fetch)
+    html = payload["html"]
+    expected_paths = set(re.findall(r'data-path="([^"]+)"', html))
+    first = HTML(string=html, url_fetcher=fetch).render(font_config=config)
+    if fetch.blocked:
+        raise RenderError("Unexpected external resource request")
+    sizes = inspect(first, payload["pages"], expected_paths)
+    if set(sizes) != set(payload["charts"]):
+        raise RenderError("Measured chart set differs from the input")
+    for path, spec in payload["charts"].items():
+        width, height = sizes[path]
+        svg = render_svg(spec, width, height, path)
+        # The measured CSS box is the SVG viewport; SVG viewBox retains its coordinates.
+        svg = svg.replace(
+            "<svg ", f'<svg style="width:{width}px;height:{height}px" ', 1
+        )
+        # Check actual Pango-drawn glyphs as well as Matplotlib measurements.
+        # A standalone viewport uses the same font bytes, SVG and CSS pixel size.
+        from ._pdf_checks import verify_chart_bounds
+
+        font_css = "".join(
+            f"@font-face{{font-family:CardReport;src:url({url});font-weight:{weight}}}"
+            for url, weight in zip(fonts, (400, 700), strict=True)
+        )
+        chart_html = f"<style>{font_css}@page{{size:{width}px {height}px;margin:0}}body{{margin:0}}svg{{display:block}}</style>{svg}"
+        chart_pdf = HTML(string=chart_html, url_fetcher=fetch).write_pdf(
+            font_config=config
+        )
+        verify_chart_bounds(chart_pdf, width, height, path)
+        html = html.replace(f"<!--chart:{path}-->", svg)
+    final = HTML(string=html, url_fetcher=fetch).render(font_config=config)
+    final_sizes = inspect(final, payload["pages"], expected_paths)
+    if set(final_sizes) != set(sizes) or any(
+        abs(a - b) > 1
+        for key in sizes
+        for a, b in zip(sizes[key], final_sizes[key], strict=True)
+    ):
+        raise RenderError("Chart geometry changed after SVG insertion")
+    if fetch.blocked:
+        raise RenderError("Unexpected external resource request")
+    if payload["pdf"]:
+        pdf_data: bytes = final.write_pdf()
+        from pypdf import PdfReader
+
+        reader = PdfReader(io.BytesIO(pdf_data))
+        if len(reader.pages) != payload["pages"]:
+            raise RenderError("PDF page count differs from measured layout")
+        from ._pdf_checks import verify_fonts
+
+        verify_fonts(reader)
+        sys.stdout.buffer.write(pdf_data)
+    else:
+        sys.stdout.buffer.write(html.encode("utf-8"))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as exc:
+        # This boundary converts native-library failures into the worker protocol.
+        kind = type(exc).__name__ if isinstance(exc, ReportError) else "RenderError"
+        message = (
+            str(exc)
+            if isinstance(exc, ReportError)
+            else f"WeasyPrint renderer failed ({type(exc).__name__})"
+        )
+        sys.stderr.write("\n" + json.dumps({"kind": kind, "message": message}) + "\n")
+        sys.exit(1)