@sdelsad/commodity-desk-daily 1.0.18 → 1.13.2

package/chart.py

@@ -0,0 +1,563 @@
+#!/usr/bin/env python3
+"""Soft Commodity Trading - chart renderer.
+
+One chart spec, two outputs:
+
+  * **SVG** for the episode page. It carries no fonts and no colours of its
+    own: it inherits the page's CSS variables, so it follows the light/dark
+    toggle automatically.
+  * **PNG** for the e-mail, because Gmail and Outlook do not render inline
+    SVG. Drawn with Pillow so nothing outside the standard toolkit is needed.
+
+A spec is a small JSON object. Three shapes cover almost everything a
+commodity episode needs:
+
+```json
+{"type":"line","unit":"c/bu","x":["4 Aug","5 Aug","6 Aug"],
+ "series":[{"name":"Dec 26","values":[465,462,469]},
+           {"name":"Mar 27","values":[478,477,482]}]}
+```
+
+```json
+{"type":"bar","unit":"$/t","x":["Freight","Insurance","Finance"],
+ "series":[{"name":"Cost","values":[38,4,9]}]}
+```
+
+```json
+{"type":"waterfall","unit":"c/bu","steps":[
+  {"label":"Gross spread","value":100,"kind":"base"},
+  {"label":"Freight","value":-60},
+  {"label":"Costs","value":-10},
+  {"label":"Margin","kind":"total"}]}
+```
+
+`null` inside `values` is a gap, not a zero: use it when a series genuinely
+has no print for that day rather than inventing one.
+
+CLI:
+
+    python3 chart.py spec.json --svg out.svg --png out.png
+"""
+
+import argparse
+import json
+import math
+import os
+import sys
+
+# ---------------------------------------------------------------- geometry --
+
+W = 640
+H = 330
+PAD_L = 56
+PAD_R = 18
+PAD_T = 26
+PAD_B = 44
+LEGEND_H = 26
+
+SERIES_VARS = ["--c-a", "--c-b", "--c-c"]
+# fallbacks, also used for the PNG (light theme, which is what mail clients show)
+SERIES_HEX = ["#1d4032", "#a8813c", "#496b86"]
+INK = "#16110c"
+INK_SOFT = "#4a4238"
+LINE = "#ddd6c9"
+PAPER = "#faf7f1"
+POS = "#1d4032"
+NEG = "#8a3b2f"
+
+
+def nice_ticks(lo, hi, target=5):
+    """Round tick values that bracket [lo, hi]."""
+    if hi == lo:
+        hi = lo + (abs(lo) or 1) * 0.1
+        lo = lo - (abs(lo) or 1) * 0.1
+    raw = (hi - lo) / max(target, 2)
+    mag = 10 ** math.floor(math.log10(raw)) if raw > 0 else 1
+    for mult in (1, 2, 2.5, 5, 10):
+        if raw / mag <= mult:
+            step = mult * mag
+            break
+    else:
+        step = 10 * mag
+    start = math.floor(lo / step) * step
+    ticks, v = [], start
+    while v < hi + step * 0.5:
+        ticks.append(round(v, 10))
+        v += step
+    return ticks
+
+
+def fmt_num(v):
+    if v is None:
+        return ""
+    a = abs(v)
+    if a >= 1000:
+        return f"{v:,.0f}"
+    if a >= 100:
+        return f"{v:.0f}"
+    if a >= 10:
+        return f"{v:.1f}".rstrip("0").rstrip(".")
+    return f"{v:.2f}".rstrip("0").rstrip(".")
+
+
+def _rebase(values):
+    base = next((v for v in values if v not in (None, 0)), None)
+    if base is None:
+        return values
+    return [None if v is None else round(v / base * 100, 2) for v in values]
+
+
+def edge_anchor(x, left, right, svg=True):
+    """Keep the first and last x labels inside the frame."""
+    if x - left < 26:
+        return ("start" if svg else "la")
+    if right - x < 26:
+        return ("end" if svg else "ra")
+    return ("middle" if svg else "ma")
+
+
+def thin(labels, keep=8):
+    """Return the indices of at most `keep` labels, evenly spread, ends kept."""
+    n = len(labels)
+    if n <= keep:
+        return list(range(n))
+    step = (n - 1) / (keep - 1)
+    return sorted({int(round(i * step)) for i in range(keep)} | {0, n - 1})
+
+
+class Frame:
+    """Shared layout maths, so the SVG and the PNG agree pixel for pixel."""
+
+    def __init__(self, spec):
+        self.spec = spec
+        self.kind = spec.get("type", "line")
+        self.unit = spec.get("unit", "")
+        if self.kind == "waterfall":
+            self.labels, self.bars, lo, hi = self._waterfall()
+            self.series = []
+        else:
+            self.labels = [str(x) for x in spec.get("x", [])]
+            self.series = spec.get("series", [])
+            if spec.get("mode") == "index":
+                # rebase every series to 100 at its first print, so two markets
+                # trading at different levels can be compared on one axis
+                self.series = [dict(s, values=_rebase(s.get("values", [])))
+                               for s in self.series]
+                self.unit = self.unit or "index, first day = 100"
+            vals = [v for s in self.series for v in s.get("values", []) if v is not None]
+            if not vals:
+                vals = [0, 1]
+            lo, hi = min(vals), max(vals)
+            if self.kind == "bar":
+                lo = min(lo, 0)
+                hi = max(hi, 0)
+            else:
+                pad = (hi - lo) * 0.12 or abs(hi) * 0.1 or 1
+                lo, hi = lo - pad, hi + pad
+        self.ticks = nice_ticks(lo, hi)
+        self.lo, self.hi = min(self.ticks[0], lo), max(self.ticks[-1], hi)
+        self.legend = len([s for s in self.series if s.get("name")]) > 1
+        self.h = H + (LEGEND_H if self.legend else 0)
+        self.top = PAD_T + (LEGEND_H if self.legend else 0)
+        self.bottom = self.h - PAD_B
+        self.left = PAD_L
+        self.right = W - PAD_R
+
+    def _waterfall(self):
+        steps = self.spec.get("steps", [])
+        bars, running, labels = [], 0.0, []
+        lo = hi = 0.0
+        for st in steps:
+            label = st.get("label", "")
+            kind = st.get("kind", "delta")
+            if kind == "total":
+                bars.append((label, 0.0, running, "total"))
+                lo, hi = min(lo, 0, running), max(hi, 0, running)
+            elif kind == "base":
+                v = float(st.get("value", 0))
+                bars.append((label, 0.0, v, "base"))
+                running = v
+                lo, hi = min(lo, 0, v), max(hi, 0, v)
+            else:
+                v = float(st.get("value", 0))
+                start, end = running, running + v
+                bars.append((label, start, end, "up" if v >= 0 else "down"))
+                running = end
+                lo, hi = min(lo, start, end), max(hi, start, end)
+            labels.append(label)
+        span = (hi - lo) or 1
+        # never open a gap below zero when nothing in the chart is negative
+        lo_pad = lo if lo >= 0 else lo - span * 0.08
+        return labels, bars, lo_pad, hi + span * 0.08
+
+    # -- coordinate helpers ------------------------------------------------
+    def y(self, v):
+        f = (v - self.lo) / (self.hi - self.lo or 1)
+        return self.bottom - f * (self.bottom - self.top)
+
+    def xs(self):
+        n = max(len(self.labels), 1)
+        if self.kind in ("bar", "waterfall") or n == 1:
+            slot = (self.right - self.left) / n
+            return [self.left + slot * (i + 0.5) for i in range(n)]
+        step = (self.right - self.left) / (n - 1)
+        return [self.left + step * i for i in range(n)]
+
+    def band(self):
+        return (self.right - self.left) / max(len(self.labels), 1)
+
+
+# --------------------------------------------------------------------- SVG --
+
+def to_svg(spec):
+    f = Frame(spec)
+    xs = f.xs()
+    esc = lambda s: (str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;"))
+    out = [
+        f'<svg class="chart" viewBox="0 0 {W} {f.h}" width="100%" '
+        f'preserveAspectRatio="xMidYMid meet" xmlns="http://www.w3.org/2000/svg" role="img">',
+        # Type is sized in viewBox units, so it shrinks with the chart. A phone
+        # renders these 640 units into ~360 CSS pixels, which turns 12px into 7px
+        # — unreadable. The sizes below are bumped back up under a media query,
+        # which works because an inline SVG's <style> is part of the document.
+        "<style>"
+        ".chart{--c-a:var(--accent,#1d4032);--c-b:var(--gold,#a8813c);--c-c:#4a6f8c;"
+        "font-family:inherit}"
+        "html[data-theme=\"dark\"] .chart{--c-c:#7ba3c4}"
+        ".chart .grid{stroke:var(--line,#ddd6c9);stroke-width:1}"
+        ".chart .axis{fill:var(--ink-soft,#4a4238);font-size:12px}"
+        ".chart .unit{fill:var(--ink-soft,#4a4238);font-size:11px;letter-spacing:.06em;"
+        "text-transform:uppercase}"
+        ".chart .ln{fill:none;stroke-width:2.25;stroke-linejoin:round;stroke-linecap:round}"
+        ".chart .lg{fill:var(--ink,#16110c);font-size:12.5px}"
+        ".chart .vlabel{fill:var(--ink,#16110c);font-size:11.5px;font-weight:600}"
+        "@media (max-width:900px){"
+        ".chart .axis{font-size:14px}.chart .unit{font-size:13px}"
+        ".chart .lg{font-size:14.5px}.chart .vlabel{font-size:13.5px}"
+        ".chart .ln{stroke-width:2.6}}"
+        "@media (max-width:640px){"
+        ".chart .axis{font-size:16px}.chart .unit{font-size:14px}"
+        ".chart .lg{font-size:16px}.chart .vlabel{font-size:15px}"
+        ".chart .ln{stroke-width:3.1}}"
+        "</style>",
+    ]
+
+    # horizontal grid + y labels
+    for t in f.ticks:
+        y = f.y(t)
+        faint = ' opacity=".45"' if t else ""
+        out.append(f'<line class="grid" x1="{f.left}" y1="{y:.1f}" x2="{f.right}" '
+                   f'y2="{y:.1f}"{faint}/>')
+        out.append(f'<text class="axis" x="{f.left - 10}" y="{y + 4:.1f}" '
+                   f'text-anchor="end">{esc(fmt_num(t))}</text>')
+    if f.unit:
+        long_unit = len(f.unit) > 8
+        ux, uanc = (f.right, "end") if long_unit else (f.left - 10, "end")
+        out.append(f'<text class="unit" x="{ux}" y="{f.top - 10}" '
+                   f'text-anchor="{uanc}">{esc(f.unit)}</text>')
+
+    # x labels
+    for i in thin(f.labels):
+        if i < len(xs):
+            anc = edge_anchor(xs[i], 0, W)
+            out.append(f'<text class="axis" x="{xs[i]:.1f}" y="{f.bottom + 20}" '
+                       f'text-anchor="{anc}">{esc(f.labels[i])}</text>')
+
+    if f.kind == "waterfall":
+        bw = min(f.band() * 0.62, 74)
+        for i, (label, a, b, kind) in enumerate(f.bars):
+            y0, y1 = f.y(a), f.y(b)
+            top, height = min(y0, y1), max(abs(y1 - y0), 2)
+            fill = {"up": "var(--c-a)", "down": NEG, "base": "var(--c-a)",
+                    "total": "var(--c-b)"}[kind]
+            op = ".92" if kind in ("base", "total") else ".78"
+            out.append(f'<rect x="{xs[i] - bw / 2:.1f}" y="{top:.1f}" width="{bw:.1f}" '
+                       f'height="{height:.1f}" rx="2" fill="{fill}" opacity="{op}"/>')
+            val = b if kind in ("base", "total") else b - a
+            out.append(f'<text class="vlabel" x="{xs[i]:.1f}" y="{top - 7:.1f}" '
+                       f'text-anchor="middle">{esc(("+" if val > 0 and kind == "delta" else "") + fmt_num(val))}</text>')
+            if i + 1 < len(f.bars) and kind != "total":
+                out.append(f'<line class="grid" x1="{xs[i] + bw / 2:.1f}" y1="{f.y(b):.1f}" '
+                           f'x2="{xs[i + 1] - bw / 2:.1f}" y2="{f.y(b):.1f}" '
+                           f'stroke-dasharray="3 3" opacity=".5"/>')
+
+    elif f.kind == "bar":
+        n = max(len(f.series), 1)
+        bw = min(f.band() * 0.7 / n, 46)
+        zero = f.y(0)
+        for si, s in enumerate(f.series):
+            col = f"var({SERIES_VARS[si % 3]})"
+            for i, v in enumerate(s.get("values", [])):
+                if v is None or i >= len(xs):
+                    continue
+                cx = xs[i] + (si - (n - 1) / 2) * bw
+                y = f.y(v)
+                out.append(f'<rect x="{cx - bw * 0.44:.1f}" y="{min(y, zero):.1f}" '
+                           f'width="{bw * 0.88:.1f}" height="{max(abs(zero - y), 1.5):.1f}" '
+                           f'rx="2" fill="{col}" opacity=".85"/>')
+        out.append(f'<line class="grid" x1="{f.left}" y1="{zero:.1f}" x2="{f.right}" '
+                   f'y2="{zero:.1f}"/>')
+
+    else:  # line
+        for si, s in enumerate(f.series):
+            col = f"var({SERIES_VARS[si % 3]})"
+            seg, path = [], []
+            for i, v in enumerate(s.get("values", [])):
+                if v is None or i >= len(xs):
+                    if seg:
+                        path.append(seg)
+                        seg = []
+                    continue
+                seg.append((xs[i], f.y(v)))
+            if seg:
+                path.append(seg)
+            for run in path:
+                d = "M" + " L".join(f"{x:.1f} {y:.1f}" for x, y in run)
+                out.append(f'<path class="ln" d="{d}" stroke="{col}"/>')
+                if len(run) == 1:
+                    out.append(f'<circle cx="{run[0][0]:.1f}" cy="{run[0][1]:.1f}" r="3" '
+                               f'fill="{col}"/>')
+            vals = [v for v in s.get("values", []) if v is not None]
+            if vals and path:
+                lx, ly = path[-1][-1]
+                out.append(f'<circle cx="{lx:.1f}" cy="{ly:.1f}" r="3.4" fill="{col}"/>')
+
+    # legend
+    if f.legend:
+        x = f.left
+        for si, s in enumerate(f.series):
+            name = s.get("name") or f"Series {si + 1}"
+            col = f"var({SERIES_VARS[si % 3]})"
+            out.append(f'<rect x="{x}" y="{PAD_T - 4}" width="18" height="3" rx="1.5" fill="{col}"/>')
+            out.append(f'<text class="lg" x="{x + 25}" y="{PAD_T + 3}">{esc(name)}</text>')
+            x += 40 + 7.2 * len(name)
+    out.append("</svg>")
+    return "\n".join(out)
+
+
+def figure_html(spec):
+    """The SVG wrapped in a captioned <figure>, ready to drop into a page."""
+    esc = lambda s: (str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;"))
+    title = spec.get("title", "")
+    caption = spec.get("caption", "")
+    source = spec.get("source", "")
+    bits = [f'<figure class="chartfig">']
+    if title:
+        bits.append(f'<figcaption class="charttitle">{esc(title)}</figcaption>')
+    bits.append(to_svg(spec))
+    tail = []
+    if caption:
+        tail.append(esc(caption))
+    if source:
+        tail.append(f'<span class="chartsrc">{esc(source)}</span>')
+    if tail:
+        bits.append(f'<figcaption class="chartcap">{" ".join(tail)}</figcaption>')
+    bits.append("</figure>")
+    return "\n".join(bits)
+
+
+CHART_CSS = """
+.chartfig{margin:36px 0;padding:22px 22px 16px;border:1px solid var(--line);
+          border-radius:10px;background:var(--tint-2,var(--tint))}
+.charttitle{font:600 17.5px/1.3 var(--serif,Georgia,serif);color:var(--ink);
+            margin:0 0 16px;letter-spacing:-.012em}
+.chartcap{font:italic 15.5px/1.55 var(--serif,Georgia,serif);color:var(--ink-soft);
+          margin:14px 2px 0;text-wrap:pretty}
+.chartsrc{display:block;font:500 11.5px/1.5 var(--sans,ui-sans-serif,system-ui,sans-serif);
+          font-style:normal;letter-spacing:.05em;opacity:.8;margin-top:7px}
+.chart{display:block;overflow:visible;font-variant-numeric:tabular-nums}
+@media (max-width:640px){
+  .charttitle{font-size:16.5px;margin-bottom:12px}
+  .chartcap{font-size:15px}
+}
+"""
+
+# --------------------------------------------------------------------- PNG --
+
+def to_png(spec, path, scale=2):
+    """Render the same chart to a PNG for e-mail. Returns the path, or None."""
+    try:
+        from PIL import Image, ImageDraw, ImageFont
+    except ImportError:
+        return None
+
+    f = Frame(spec)
+    xs = f.xs()
+    title = spec.get("title", "")
+    caption = spec.get("caption", "")
+    source = spec.get("source", "")
+
+    def fnt(size, bold=False):
+        """A scalable font, wherever this happens to be running.
+
+        The old list only knew the container's Linux paths; anywhere else it
+        fell through to load_default(), which used to ignore the size and drew
+        every label at the same unreadable 11px. The last resort now asks for
+        a size too, so a chart built on a laptop matches one built in CI.
+        """
+        for p in ("/usr/share/fonts/truetype/google-fonts/Poppins-%s.ttf"
+                  % ("Medium" if bold else "Regular"),
+                  "/usr/share/fonts/truetype/dejavu/DejaVuSans%s.ttf"
+                  % ("-Bold" if bold else ""),
+                  "C:/Windows/Fonts/%s.ttf" % ("segoeuib" if bold else "segoeui"),
+                  "C:/Windows/Fonts/%s.ttf" % ("arialbd" if bold else "arial"),
+                  "/System/Library/Fonts/Supplemental/%s.ttf"
+                  % ("Arial Bold" if bold else "Arial"),
+                  "/Library/Fonts/Arial.ttf"):
+            if os.path.exists(p):
+                return ImageFont.truetype(p, int(size * scale))
+        try:                                   # Pillow >= 10.1 scales this one
+            return ImageFont.load_default(size=int(size * scale))
+        except TypeError:
+            return ImageFont.load_default()
+
+    # Titles, captions and sources are prose, and prose does not fit on one
+    # line. Measure and wrap them first, on a scratch canvas, so the header and
+    # footer are tall enough for however many lines it turns out to be.
+    TEXT_L = 14
+    TEXT_W = W - TEXT_L - 12
+    _scratch = ImageDraw.Draw(Image.new("RGB", (1, 1)))
+
+    def wrap(s, size, bold=False):
+        if not s:
+            return []
+        font = fnt(size, bold)
+        lines, cur = [], ""
+        for word in str(s).split():
+            trial = (cur + " " + word).strip()
+            if not cur or _scratch.textlength(trial, font=font) / scale <= TEXT_W:
+                cur = trial
+            else:
+                lines.append(cur)
+                cur = word
+        if cur:
+            lines.append(cur)
+        return lines
+
+    title_lines = wrap(title, 19, bold=True)
+    cap_lines = wrap(caption, 15)
+    src_lines = wrap(source, 12)
+    head = (8 + 26 * len(title_lines)) if title_lines else 8
+    foot = 8 + 22 * len(cap_lines) + 17 * len(src_lines) + 8
+    w, h = W, f.h + head + foot
+
+    im = Image.new("RGB", (w * scale, h * scale), PAPER)
+    d = ImageDraw.Draw(im)
+    S = lambda v: v * scale
+    off = head
+
+    def text(x, y, s, size=12, fill=INK_SOFT, anchor="la", bold=False):
+        d.text((S(x), S(y)), str(s), font=fnt(size, bold), fill=fill, anchor=anchor)
+
+    for n, line in enumerate(title_lines):
+        text(TEXT_L, 6 + 26 * n, line, 19, INK, bold=True)
+
+    for t in f.ticks:
+        y = f.y(t) + off
+        d.line([(S(f.left), S(y)), (S(f.right), S(y))], fill=LINE, width=max(1, scale // 2))
+        text(f.left - 10, y, fmt_num(t), 15, INK_SOFT, anchor="rm")
+    if f.unit:
+        if len(f.unit) > 8:
+            text(f.right, f.top + off - 12, f.unit.upper(), 12, INK_SOFT, anchor="rm")
+        else:
+            text(f.left - 10, f.top + off - 12, f.unit.upper(), 12, INK_SOFT, anchor="rm")
+    for i in thin(f.labels):
+        if i < len(xs):
+            text(xs[i], f.bottom + off + 16, f.labels[i], 15, INK_SOFT,
+                 anchor=edge_anchor(xs[i], 0, W, svg=False))
+
+    if f.kind == "waterfall":
+        bw = min(f.band() * 0.62, 74)
+        for i, (label, a, b, kind) in enumerate(f.bars):
+            y0, y1 = f.y(a) + off, f.y(b) + off
+            top, bot = min(y0, y1), max(y0, y1)
+            fill = {"up": POS, "down": NEG, "base": POS, "total": SERIES_HEX[1]}[kind]
+            d.rectangle([S(xs[i] - bw / 2), S(top), S(xs[i] + bw / 2), S(max(bot, top + 2))],
+                        fill=fill)
+            val = b if kind in ("base", "total") else b - a
+            lbl = ("+" if val > 0 and kind == "delta" else "") + fmt_num(val)
+            text(xs[i], top - 7, lbl, 14, INK, anchor="md", bold=True)
+            if i + 1 < len(f.bars) and kind != "total":
+                d.line([(S(xs[i] + bw / 2), S(y1)), (S(xs[i + 1] - bw / 2), S(y1))],
+                       fill=LINE, width=max(1, scale))
+    elif f.kind == "bar":
+        n = max(len(f.series), 1)
+        bw = min(f.band() * 0.7 / n, 46)
+        zero = f.y(0) + off
+        for si, s in enumerate(f.series):
+            col = SERIES_HEX[si % 3]
+            for i, v in enumerate(s.get("values", [])):
+                if v is None or i >= len(xs):
+                    continue
+                cx = xs[i] + (si - (n - 1) / 2) * bw
+                y = f.y(v) + off
+                d.rectangle([S(cx - bw * 0.44), S(min(y, zero)),
+                             S(cx + bw * 0.44), S(max(y, zero))], fill=col)
+        d.line([(S(f.left), S(zero)), (S(f.right), S(zero))], fill=LINE, width=scale)
+    else:
+        for si, s in enumerate(f.series):
+            col = SERIES_HEX[si % 3]
+            run = []
+            for i, v in enumerate(s.get("values", [])):
+                if v is None or i >= len(xs):
+                    if len(run) > 1:
+                        d.line([(S(x), S(y)) for x, y in run], fill=col,
+                               width=max(2, int(2.2 * scale)), joint="curve")
+                    run = []
+                    continue
+                run.append((xs[i], f.y(v) + off))
+            if len(run) > 1:
+                d.line([(S(x), S(y)) for x, y in run], fill=col,
+                       width=max(2, int(2.2 * scale)), joint="curve")
+            if run:
+                x, y = run[-1]
+                r = 3.4 * scale
+                d.ellipse([S(x) - r, S(y) - r, S(x) + r, S(y) + r], fill=col)
+
+    if f.legend:
+        x = f.left
+        for si, s in enumerate(f.series):
+            name = s.get("name") or f"Series {si + 1}"
+            col = SERIES_HEX[si % 3]
+            d.rectangle([S(x), S(PAD_T + off - 6), S(x + 18), S(PAD_T + off - 3)], fill=col)
+            text(x + 27, PAD_T + off - 4, name, 15, INK, anchor="lm")
+            x += 44 + 8.6 * len(name)
+
+    y = f.h + off + 8
+    for line in cap_lines:
+        text(TEXT_L, y, line, 15, INK_SOFT)
+        y += 22
+    for line in src_lines:
+        text(TEXT_L, y, line, 12, INK_SOFT)
+        y += 17
+
+    im.save(path, "PNG", optimize=True)
+    return path
+
+
+# --------------------------------------------------------------------- CLI --
+
+def main():
+    ap = argparse.ArgumentParser(description="Render a chart spec to SVG and/or PNG.")
+    ap.add_argument("spec", help="JSON file, or '-' for stdin")
+    ap.add_argument("--svg")
+    ap.add_argument("--png")
+    ap.add_argument("--scale", type=int, default=2)
+    a = ap.parse_args()
+
+    raw = sys.stdin.read() if a.spec == "-" else open(a.spec, encoding="utf-8").read()
+    spec = json.loads(raw)
+
+    if a.svg:
+        open(a.svg, "w", encoding="utf-8").write(figure_html(spec))
+        print(f"[chart] {a.svg}")
+    if a.png:
+        got = to_png(spec, a.png, a.scale)
+        print(f"[chart] {got}" if got else "[chart] PNG skipped (Pillow missing)")
+    if not a.svg and not a.png:
+        print(figure_html(spec))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())