dsh-aris-panel 0.1.0

package/skills/paper-poster-html/scripts/_posterly/canvas.py

@@ -0,0 +1,200 @@
+"""Canvas (page-size) parsing utilities, shared by all CLIs.
+
+Two input sources for canvas dimensions:
+  1. The ``@page { size: W H }`` declaration inside the poster HTML's
+     ``<style>`` blocks. This is the canonical source — every CLI parses
+     it first so layout decisions stay tied to what Chromium actually
+     renders.
+  2. The ``--canvas`` CLI argument as an override. Accepts:
+       - ``60x36in``, ``914x1194mm`` (numeric W x H + unit)
+       - ``A0 portrait``, ``A1 landscape`` (ISO 216 named sizes)
+
+Returns inches everywhere; callers convert to viewport px via
+``viewport_for(canvas_in)`` at 96 ppi (Chromium's print pixel basis).
+"""
+from __future__ import annotations
+
+import argparse
+import re
+from pathlib import Path
+
+from .textutil import ascii_safe
+
+
+# Conversion factors → inches.
+UNIT_TO_IN: dict[str, float] = {
+    "in": 1.0,
+    "mm": 1.0 / 25.4,
+    "cm": 1.0 / 2.54,
+    "pt": 1.0 / 72.0,
+}
+
+# ISO 216 paper sizes (portrait W x H, in mm).
+NAMED_SIZES_MM: dict[str, tuple[float, float]] = {
+    "A0": (841.0, 1189.0),
+    "A1": (594.0, 841.0),
+    "A2": (420.0, 594.0),
+    "A3": (297.0, 420.0),
+    "A4": (210.0, 297.0),
+}
+
+
+def _extract_style_css(html_text: str) -> str:
+    """Concatenate the contents of all ``<style>…</style>`` blocks with
+    CSS comments stripped. The only place to look for ``@page`` — never
+    raw HTML body, never ``<script>``.
+    """
+    blocks = re.findall(
+        r"<style[^>]*>(.*?)</style>",
+        html_text,
+        flags=re.DOTALL | re.IGNORECASE,
+    )
+    css = "\n".join(blocks)
+    css = re.sub(r"/\*.*?\*/", "", css, flags=re.DOTALL)
+    return css
+
+
+def read_canvas_from_html(html_path: Path) -> tuple[float, float] | None:
+    """Parse ``@page { size: ... }`` from ``<style>`` blocks.
+
+    Supports both numeric and named-size forms:
+
+      - ``@page { size: 60in 36in; }`` (numeric, `in`/`mm`/`cm`/`pt`)
+      - ``@page { size: A0 portrait; }`` / ``A1 landscape`` (CSS named
+        page sizes — same set as ``parse_canvas_arg``)
+
+    Numeric dimensions may mix units (``24in 914mm``). Named pages
+    (``@page poster { size: ... }``) are recognised too. Returns
+    ``(width_in, height_in)`` or ``None`` on parse failure — callers
+    must either require ``--canvas`` or exit non-zero. We refuse to
+    silently fall back to a hardcoded default.
+    """
+    txt = html_path.read_text(encoding="utf-8", errors="ignore")
+    css = _extract_style_css(txt)
+
+    # Find EVERY `@page … { … size: <value>; … }` candidate (numeric
+    # or named) and try to parse each. Earlier versions stopped at the
+    # first numeric match, so an `@page { size: auto }` declaration
+    # before a real `@page { size: A0 landscape }` would mask the latter
+    # and the parser returned None. Iterate and accept the LAST that
+    # parses — matching CSS cascade for paged media.
+    pattern = re.compile(
+        r"@page(?:\s+[A-Za-z_-][\w:-]*)?\s*\{[^}]*?size\s*:\s*"
+        r"([^;{}]+?)\s*(?:!\s*important\s*)?[;}]",
+        re.IGNORECASE,
+    )
+    last_parsed: tuple[float, float] | None = None
+    for m in pattern.finditer(css):
+        raw = m.group(1).strip()
+        # 1) Numeric form: `<num><unit> <num><unit>` (units may differ).
+        m_num = re.fullmatch(
+            r"((?:\d+(?:\.\d*)?|\.\d+))\s*(in|mm|cm|pt)\s+"
+            r"((?:\d+(?:\.\d*)?|\.\d+))\s*(in|mm|cm|pt)",
+            raw,
+            re.IGNORECASE,
+        )
+        if m_num:
+            w = float(m_num.group(1)) * UNIT_TO_IN[m_num.group(2).lower()]
+            h = float(m_num.group(3)) * UNIT_TO_IN[m_num.group(4).lower()]
+            last_parsed = (w, h)
+            continue
+        # 2) Named form: delegate to parse_canvas_arg so both code paths
+        #    agree on what counts as a valid `<NamedSize> [orient]` /
+        #    `<orient> <NamedSize>` value.
+        try:
+            last_parsed = parse_canvas_arg(raw)
+        except argparse.ArgumentTypeError:
+            # Skip this @page (e.g. `size: auto`) and keep looking.
+            continue
+    return last_parsed
+
+
+def parse_canvas_arg(s: str) -> tuple[float, float]:
+    """Argparse-friendly parser for ``--canvas`` values.
+
+    Accepts:
+      - ``60x36in``, ``914x1194mm``, ``60x36cm`` (one unit at end)
+      - ``A0 portrait``, ``A0 landscape``, ``A1 portrait``, …
+    Returns ``(width_in, height_in)``.
+
+    Raises ``argparse.ArgumentTypeError`` so argparse formats the error
+    cleanly without a stack trace.
+    """
+    s = s.strip()
+    # Form 1: <W>x<H><unit>
+    m = re.fullmatch(
+        r"((?:\d+(?:\.\d*)?|\.\d+))\s*[x×]\s*"
+        r"((?:\d+(?:\.\d*)?|\.\d+))\s*(in|mm|cm|pt)",
+        s,
+        re.IGNORECASE,
+    )
+    if m:
+        unit = m.group(3).lower()
+        w = float(m.group(1)) * UNIT_TO_IN[unit]
+        h = float(m.group(2)) * UNIT_TO_IN[unit]
+        return w, h
+    # Form 2: CSS Paged Media value `<NamedSize> | <Orient> |
+    # <NamedSize> <Orient> | <Orient> <NamedSize>` (the spec lets
+    # orientation appear before OR after the size keyword).
+    parts = re.split(r"\s+", s)
+    if 1 <= len(parts) <= 2:
+        name_token = orient_token = None
+        for part in parts:
+            up = part.upper()
+            lo = part.lower()
+            if up in NAMED_SIZES_MM and name_token is None:
+                name_token = up
+            elif lo in ("portrait", "landscape") and orient_token is None:
+                orient_token = lo
+            else:
+                name_token = orient_token = None
+                break
+        if name_token is not None:
+            orient = orient_token or "portrait"
+            w_mm, h_mm = NAMED_SIZES_MM[name_token]
+            if orient == "landscape":
+                w_mm, h_mm = h_mm, w_mm
+            return w_mm / 25.4, h_mm / 25.4
+    raise argparse.ArgumentTypeError(
+        f"--canvas expects '<W>x<H><unit>' (e.g. '60x36in') or "
+        f"'<NamedSize> [portrait|landscape]' (e.g. 'A0 portrait'); "
+        f"got {ascii_safe(s)!r}. Named sizes: "
+        f"{', '.join(sorted(NAMED_SIZES_MM))}."
+    )
+
+
+def viewport_for(canvas_in: tuple[float, float]) -> tuple[int, int]:
+    """Convert (W_in, H_in) to (W_px, H_px) at 96 ppi.
+
+    Playwright's print-emulation uses CSS pixels at 96 ppi, so the
+    viewport must match that basis or measurement units shift.
+    """
+    w_in, h_in = canvas_in
+    return (int(round(w_in * 96)), int(round(h_in * 96)))
+
+
+def resolve_canvas(
+    html_path: Path,
+    canvas_override: tuple[float, float] | None,
+    label: str,
+) -> tuple[tuple[float, float], tuple[int, int]] | None:
+    """Resolve canvas from CLI override (preferred) or HTML's ``@page``.
+
+    Prints a one-liner to stdout describing which source was used.
+    Returns ``(canvas_in, viewport_px)`` on success, ``None`` on failure
+    (caller exits 2 after this). ``label`` is the CLI's logger prefix
+    (e.g. ``[measure]``).
+    """
+    if canvas_override is not None:
+        canvas = canvas_override
+        print(f"{label} canvas (--canvas override) = "
+              f"{canvas[0]:.2f}in x {canvas[1]:.2f}in")
+    else:
+        parsed = read_canvas_from_html(html_path)
+        if parsed is None:
+            return None
+        canvas = parsed
+        print(f"{label} canvas = {canvas[0]:.2f}in x {canvas[1]:.2f}in")
+    viewport = viewport_for(canvas)
+    print(f"{label} viewport = {viewport[0]} x {viewport[1]} px")
+    return canvas, viewport