pptd-utils 2026.10.2.dev3__py3-none-any.whl

pptd_utils/rich.py

@@ -0,0 +1,213 @@
+"""Rich-text parser: pptd subset of HTML -> paragraph/run model.
+
+Also handles: plain-text shorthand (multi-line -> <p> per line), <br/>,
+LaTeX \\(...\\) segments, list styles, span/p/li style attributes.
+"""
+import html.parser
+import re
+
+from .style import css_px
+
+MATH_RE = re.compile(r"\\\((.+?)\\\)", re.S)
+STYLE_RE = re.finditer  # alias used inline
+
+
+def _parse_style(s):
+    """'color:#f00; font-size:24px' -> dict."""
+    out = {}
+    for m in re.finditer(r"([\w-]+)\s*:\s*([^;]+)", s or ""):
+        out[m.group(1).strip().lower()] = m.group(2).strip()
+    return out
+
+
+LIST_TYPES = {
+    "decimal": "arabicPeriod", "disc": "\u2022", "circle": "\u25E6",
+    "square": "\u25AA", "none": None,
+    "lower-alpha": "alphaLcPeriod", "upper-alpha": "alphaUcPeriod",
+    "lower-roman": "romanLcPeriod", "upper-roman": "romanUcPeriod",
+}
+
+
+class Run:
+    __slots__ = ("text", "span", "bold", "italic", "underline", "strike",
+                 "sub", "sup", "link", "math")
+
+    def __init__(self, text, span=None, bold=False, italic=False,
+                 underline=False, strike=False, sub=False, sup=False,
+                 link=None, math=None):
+        self.text = text
+        self.span = span or {}
+        self.bold = bold
+        self.italic = italic
+        self.underline = underline
+        self.strike = strike
+        self.sub = sub
+        self.sup = sup
+        self.link = link
+        self.math = math
+
+
+class Para:
+    def __init__(self, bullet=False, ordered=False):
+        self.bullet = bullet
+        self.ordered = ordered
+        self.align = None      # from p/li style
+        self.lh = None         # line-height (mult) or px
+        self.lh_px = None
+        self.mt = None         # margin-top px
+        self.ml = None         # margin-left px
+        self.mr = None         # margin-right px
+        self.ls = None         # letter-spacing (li only)
+        self.list_style = None  # list-style-type key or char
+        self.runs = []
+        self.br_pending = False
+
+
+class _Parser(html.parser.HTMLParser):
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self.paras = []
+        self.cur = None
+        self.spans = []
+        self.bold = self.italic = self.underline = self.strike = 0
+        self.sub = self.sup = 0
+        self.link = None
+        self._in_ol = False
+
+    def new_para(self, bullet=False, ordered=False):
+        self.cur = Para(bullet, ordered)
+        self.paras.append(self.cur)
+        return self.cur
+
+    def _li_style(self, p, attrs):
+        for k, v in attrs.items():
+            if k == "text-align":
+                p.align = v
+            elif k == "line-height":
+                if str(v).endswith("px"):
+                    p.lh_px = css_px(v)
+                else:
+                    p.lh = float(v)
+            elif k == "margin-top":
+                p.mt = css_px(v)
+            elif k == "margin-left":
+                p.ml = css_px(v)
+            elif k == "margin-right":
+                p.mr = css_px(v)
+            elif k == "letter-spacing":
+                p.ls = css_px(v)
+            elif k in ("list-style-type", "list-style"):
+                key = v.split()[0] if v else "disc"
+                p.list_style = key
+
+    def handle_starttag(self, tag, attrs):
+        a = dict(attrs)
+        if tag in ("p", "li"):
+            p = self.new_para(bullet=(tag == "li"))
+            if tag == "li":
+                p.ordered = self._in_ol
+            self._li_style(p, _parse_style(a.get("style", "")))
+        elif tag in ("ul", "ol"):
+            self._in_ol = tag == "ol"
+        elif tag == "span":
+            self.spans.append(_parse_style(a.get("style", "")))
+        elif tag in ("strong", "b"):
+            self.bold += 1
+        elif tag in ("em", "i"):
+            self.italic += 1
+        elif tag == "u":
+            self.underline += 1
+        elif tag == "s":
+            self.strike += 1
+        elif tag == "sup":
+            self.sup += 1
+        elif tag == "sub":
+            self.sub += 1
+        elif tag == "a":
+            self.link = a.get("href")
+        elif tag == "br":
+            if self.cur is not None and self.cur.runs:
+                self.cur.runs.append(Run("\n"))
+
+    def handle_startendtag(self, tag, attrs):
+        if tag == "br":
+            self.handle_starttag("br", attrs)
+            return
+        self.handle_starttag(tag, attrs)
+        self.handle_endtag(tag)
+
+    def handle_endtag(self, tag):
+        if tag in ("p", "li"):
+            self.cur = None
+        elif tag in ("ul", "ol"):
+            self._in_ol = False
+        elif tag == "span":
+            if self.spans:
+                self.spans.pop()
+        elif tag in ("strong", "b"):
+            self.bold -= 1
+        elif tag in ("em", "i"):
+            self.italic -= 1
+        elif tag == "u":
+            self.underline -= 1
+        elif tag == "s":
+            self.strike -= 1
+        elif tag == "sup":
+            self.sup -= 1
+        elif tag == "sub":
+            self.sub -= 1
+        elif tag == "a":
+            self.link = None
+
+    def handle_data(self, data):
+        if self.cur is None:
+            if not data.strip():
+                return
+            self.new_para()
+        # split LaTeX out of text runs
+        pos = 0
+        for m in MATH_RE.finditer(data):
+            self._emit_text(data[pos:m.start()])
+            span = {}
+            for st in self.spans:
+                span.update(st)
+            self.cur.runs.append(Run("", span=span, math=m.group(1).strip()))
+            pos = m.end()
+        self._emit_text(data[pos:])
+
+    def _emit_text(self, text):
+        if not text:
+            return
+        text = re.sub(r"\s+", " ", text)
+        if not text.strip():
+            if not self.cur.runs and text == " ":
+                return  # leading whitespace before first run
+            if not self.cur.runs:
+                return
+        span = {}
+        for st in self.spans:
+            span.update(st)
+        self.cur.runs.append(Run(
+            text, span,
+            self.bold > 0, self.italic > 0, self.underline > 0,
+            self.strike > 0, self.sub > 0, self.sup > 0, self.link))
+
+
+def parse_rich(text):
+    """Parse pptd rich text -> list[Para]."""
+    text = str(text or "")
+    if "<" not in text:
+        # plain-text shorthand: lines -> paragraphs
+        paras = []
+        for line in text.split("\n"):
+            p = Para()
+            if line:
+                p.runs.append(Run(re.sub(r"\s+", " ", line)))
+            paras.append(p)
+        return paras
+    p = _Parser()
+    p.feed(text)
+    p.close()
+    if not p.paras:
+        p.new_para()
+    return p.paras

pptd_utils/shapes.py

@@ -0,0 +1,334 @@
+"""Shape element: 130 OOXML presets + custom SVG-path geometry (custGeom)."""
+import math
+import re
+
+from lxml import etree
+from pptx.enum.shapes import MSO_SHAPE
+from pptx.oxml.ns import qn
+from pptx.util import Pt
+
+from ._shape_data import SHAPES
+from .style import fill_xml, ln_xml, shadow_xml
+from .xmlutil import sub, insert_ordered, SPPR_ORDER, set_xfrm_flip_rot
+
+_PRESSET = {m.xml_value: m for m in MSO_SHAPE}
+
+
+def apply_preset_geometry(shape, shape_name, adjustments):
+    """Set prstGeom preset + avLst adjustments on an autoshape."""
+    enum = _PRESSET.get(shape_name)
+    if enum is None:
+        raise ValueError(f"unknown shapeName {shape_name!r}")
+    spPr = shape._element.spPr
+    geom = spPr.find(qn("a:prstGeom"))
+    geom.set("prst", shape_name)
+    avLst = geom.find(qn("a:avLst"))
+    for gd in list(avLst):
+        avLst.remove(gd)
+    defaults = SHAPES.get(shape_name, [])
+    values = adjustments if adjustments is not None else defaults
+    for i, v in enumerate(values[:len(defaults)] if defaults else values):
+        val = int(v)
+        gd = sub(avLst, "a:gd", {"name": f"adj{i + 1}", "fmla": f"val {val}"})
+
+
+# ------------------------------------------------------------- SVG path
+
+_NUM = r"[-+]?(?:\d*\.\d+|\d+\.?)"
+_PATH_TOKEN = re.compile(
+    r"([MLHVCSQAZmlhvcsqaz])|(" + _NUM + ")")
+
+
+def _tokens(d):
+    cmd = None
+    for m in _PATH_TOKEN.finditer(d):
+        if m.group(1):
+            cmd = m.group(1)
+            yield (cmd, None)
+        else:
+            yield (cmd, float(m.group(0)))
+
+
+def parse_svg_path(d, vw, vh):
+    """SVG path string -> list of custGeom path elements (a:lnTo etc.).
+
+    Returns list of (tag, values) tuples with absolute coords:
+      ("M",[x,y]) ("L",[x,y]) ("C",[x1,y1,x2,y2,x,y]) ("Q",[x1,y1,x,y])
+      ("Z",[]) — arcs pre-converted to beziers.
+    """
+    out = []
+    cur = (0.0, 0.0)
+    start = (0.0, 0.0)
+    last_c2 = None
+    last_q = None
+    i = 0
+    toks = list(_tokens(d))
+    n = len(toks)
+    rel = False
+    cmd = None
+    args = []
+
+    def nxt(k):
+        nonlocal i
+        vals = []
+        for _ in range(k):
+            if i >= n:
+                raise ValueError("svg path: missing parameters")
+            vals.append(toks[i][1])
+            i += 1
+        return vals
+
+    def emit(tag, vals):
+        out.append((tag, vals))
+
+    while i < n:
+        t = toks[i]
+        if t[0] is not None:
+            cmd = t[0]
+            rel = cmd.islower()
+            cmdU = cmd.upper()
+            i += 1
+            args = []
+        if cmdU is None:
+            break
+        if cmdU == "M":
+            x, y = nxt(2)
+            if rel:
+                x += cur[0]
+                y += cur[1]
+            emit("M", [x, y])
+            cur = (x, y)
+            start = cur
+            cmd = "l" if rel else "L"  # subsequent implicit lineTo
+            cmdU = "L"
+        elif cmdU == "L":
+            x, y = nxt(2)
+            if rel:
+                x += cur[0]
+                y += cur[1]
+            emit("L", [x, y])
+            cur = (x, y)
+        elif cmdU == "H":
+            (x,) = nxt(1)
+            if rel:
+                x += cur[0]
+            emit("L", [x, cur[1]])
+            cur = (x, cur[1])
+        elif cmdU == "V":
+            (y,) = nxt(1)
+            if rel:
+                y += cur[1]
+            emit("L", [cur[0], y])
+            cur = (cur[0], y)
+        elif cmdU in ("C", "S"):
+            if cmdU == "C":
+                x1, y1, x2, y2, x, y = nxt(6)
+                if rel:
+                    x1 += cur[0]; y1 += cur[1]; x2 += cur[0]; y2 += cur[1]
+                    x += cur[0]; y += cur[1]
+            else:  # S: reflect previous control
+                x2, y2, x, y = nxt(4)
+                if rel:
+                    x2 += cur[0]; y2 += cur[1]; x += cur[0]; y += cur[1]
+                if last_c2 is None:
+                    x1, y1 = cur
+                else:
+                    x1, y1 = (2 * cur[0] - last_c2[0], 2 * cur[1] - last_c2[1])
+            emit("C", [x1, y1, x2, y2, x, y])
+            last_c2 = (x2, y2)
+            cur = (x, y)
+        elif cmdU in ("Q", "T"):
+            if cmdU == "Q":
+                x1, y1, x, y = nxt(4)
+                if rel:
+                    x1 += cur[0]; y1 += cur[1]; x += cur[0]; y += cur[1]
+            else:
+                x, y = nxt(2)
+                if rel:
+                    x += cur[0]; y += cur[1]
+                if last_q is None:
+                    x1, y1 = cur
+                else:
+                    x1, y1 = (2 * cur[0] - last_q[0], 2 * cur[1] - last_q[1])
+            # promote quadratic to cubic
+            cx1 = cur[0] + 2 / 3 * (x1 - cur[0])
+            cy1 = cur[1] + 2 / 3 * (y1 - cur[1])
+            cx2 = x + 2 / 3 * (x1 - x)
+            cy2 = y + 2 / 3 * (y1 - y)
+            emit("C", [cx1, cy1, cx2, cy2, x, y])
+            last_q = (x1, y1)
+            cur = (x, y)
+        elif cmdU == "A":
+            rx, ry, rot, laf, sf, x, y = nxt(7)
+            if rel:
+                x += cur[0]
+                y += cur[1]
+            for seg in _arc_to_cubics(cur[0], cur[1], rx, ry, rot, bool(laf), bool(sf), x, y):
+                emit("C", seg)
+                cur = (seg[4], seg[5])
+        elif cmdU == "Z":
+            emit("Z", [])
+            cur = start
+        else:
+            raise ValueError(f"unsupported svg command {cmd!r}")
+    return out
+
+
+def _arc_to_cubics(x0, y0, rx, ry, rot_deg, large, sweep, x1, y1):
+    """SVG A -> list of cubic bezier segments (endpoint parameterization)."""
+    if rx == 0 or ry == 0:
+        return [[x0, y0, x1, y1, x1, y1]]
+    phi = math.radians(rot_deg % 360)
+    rx, ry = abs(rx), abs(ry)
+    cos_p, sin_p = math.cos(phi), math.sin(phi)
+    dx2, dy2 = (x0 - x1) / 2, (y0 - y1) / 2
+    x1p = cos_p * dx2 + sin_p * dy2
+    y1p = -sin_p * dx2 + cos_p * dy2
+    lam = (x1p / rx) ** 2 + (y1p / ry) ** 2
+    if lam > 1:
+        s = math.sqrt(lam)
+        rx, ry = rx * s, ry * s
+    num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p
+    den = rx * rx * y1p * y1p + ry * ry * x1p * x1p
+    co = math.sqrt(max(0.0, num / den)) if den else 0.0
+    if large == sweep:
+        co = -co
+    cxp = co * rx * y1p / ry
+    cyp = -co * ry * x1p / rx
+    cx = cos_p * cxp - sin_p * cyp + (x0 + x1) / 2
+    cy = sin_p * cxp + cos_p * cyp + (y0 + y1) / 2
+
+    def ang(ux, uy, vx, vy):
+        d = math.hypot(ux, uy) * math.hypot(vx, vy)
+        c = max(-1.0, min(1.0, (ux * vx + uy * vy) / d))
+        a = math.acos(c)
+        if ux * vy - uy * vx < 0:
+            a = -a
+        return a
+
+    th1 = ang(1.0, 0.0, (x1p - cxp) / rx, (y1p - cyp) / ry)
+    dth = ang((x1p - cxp) / rx, (y1p - cyp) / ry,
+              (-x1p - cxp) / rx, (-y1p - cyp) / ry)
+    if not sweep and dth > 0:
+        dth -= 2 * math.pi
+    elif sweep and dth < 0:
+        dth += 2 * math.pi
+    segs = []
+    nseg = max(1, math.ceil(abs(dth) / (math.pi / 2)))
+    delta = dth / nseg
+    t = th1
+    k = 4 / 3 * math.tan(delta / 4)
+    px, py = x0, y0
+    for _ in range(nseg):
+        t2 = t + delta
+        cos_t, sin_t = math.cos(t), math.sin(t)
+        cos_t2, sin_t2 = math.cos(t2), math.sin(t2)
+        e1x = cx + rx * (cos_t - k * sin_t)
+        e1y = cy + ry * (sin_t + k * cos_t)
+        e2x = cx + rx * (cos_t2 + k * sin_t2)
+        e2y = cy + ry * (sin_t2 - k * cos_t2)
+        ex = cx + rx * cos_t2
+        ey = cy + ry * sin_t2
+        if rot_deg:
+            def rot(x, y):
+                dx, dy = x - cx, y - cy
+                return (cx + cos_p * dx - sin_p * dy,
+                        cy + sin_p * dx + cos_p * dy)
+            e1x, e1y = rot(e1x, e1y)
+            e2x, e2y = rot(e2x, e2y)
+            ex, ey = rot(ex, ey)
+        segs.append([e1x, e1y, e2x, e2y, ex, ey])
+        t = t2
+    return segs
+
+
+def build_custgeom(spPr, vw, vh, path_d):
+    """Replace spPr geometry with custGeom from an SVG path."""
+    for t in ("a:prstGeom", "a:custGeom"):
+        e = spPr.find(qn(t))
+        if e is not None:
+            spPr.remove(e)
+    cust = etree.Element(qn("a:custGeom"))
+    xfrm = spPr.find(qn("a:xfrm"))
+    if xfrm is not None:
+        xfrm.addnext(cust)
+    else:
+        spPr.insert(0, cust)
+    sub(cust, "a:avLst")
+    sub(cust, "a:gdLst")
+    pathLst = sub(cust, "a:pathLst")
+    path = sub(pathLst, "a:path", {"w": _i(vw), "h": _i(vh)})
+    cur = None
+    for tag, vals in parse_svg_path(path_d, vw, vh):
+        if tag == "M":
+            sub(path, "a:moveTo", {}).append(
+                _pt("a:pt", vals[0], vals[1]))
+            cur = (vals[0], vals[1])
+        elif tag == "L":
+            ln = sub(path, "a:lnTo")
+            ln.append(_pt("a:pt", vals[0], vals[1]))
+        elif tag == "C":
+            cb = sub(path, "a:cubicBezTo")
+            for j in (0, 2, 4):
+                cb.append(_pt("a:pt", vals[j], vals[j + 1]))
+        elif tag == "Q":
+            qb = sub(path, "a:quadBezTo")
+            for j in (0, 2):
+                qb.append(_pt("a:pt", vals[j], vals[j + 1]))
+        elif tag == "Z":
+            sub(path, "a:close")
+    return cust
+
+
+def _i(v):
+    return str(int(round(float(v))))
+
+
+def _pt(tag, x, y):
+    e = etree.Element(qn(tag))
+    e.set("x", _i(x))
+    e.set("y", _i(y))
+    return e
+
+
+# ------------------------------------------------------------- render
+
+def render_shape(slide, el, theme):
+    name = el.get("shapeName", "rect")
+    x, y, w, h = el["bounds"]
+    shape = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Pt(x), Pt(y), Pt(w), Pt(h))
+    shape.shadow.inherit = False
+    if name == "custom":
+        vw, vh = el.get("viewBox", [w, h])
+        build_custgeom(shape._element.spPr, vw, vh, el.get("path", ""))
+    else:
+        apply_preset_geometry(shape, name, el.get("adjustments"))
+    spPr = shape._element.spPr
+    fill_xml(spPr, el.get("fill"), theme, alpha=1.0,
+             image_part_fn=_ipf(slide), stretch=True)
+    if el.get("fill") is None:
+        for e in spPr.findall(qn("a:noFill")):
+            spPr.remove(e)
+        insert_ordered(spPr, etree.Element(qn("a:noFill")), SPPR_ORDER)
+    ln_xml(spPr, el.get("border"), theme)
+    shadow_xml(spPr, el.get("shadow"), theme)
+    opacity = el.get("opacity", 1.0)
+    if opacity is not None and float(opacity) < 1.0:
+        _apply_alpha(spPr, float(opacity))
+    set_xfrm_flip_rot(shape, el.get("rotation") or 0, el.get("flip"))
+    return shape
+
+
+def _ipf(slide):
+    def fn(path):
+        part, rid = slide.part.get_or_add_image_part(str(path))
+        return rid
+    return fn
+
+
+def _apply_alpha(spPr, opacity):
+    """Inject a:alpha into every srgbClr in spPr (fill + line)."""
+    val = str(int(opacity * 100000))
+    for srgb in spPr.iter(qn("a:srgbClr")):
+        if srgb.find(qn("a:alpha")) is None:
+            sub(srgb, "a:alpha", {"val": val})

pptd_utils/slides_image.py

@@ -0,0 +1,128 @@
+"""Slide image export: collage with numbering + single-slide PNGs.
+
+Renders via the built .pptx: each wanted slide is isolated into a
+one-slide package and exported by LibreOffice headless (soffice).
+Pillow composes the collage with numbered badges.
+
+ponytail: one soffice run per slide (~1.5s each); switch to a single
+PDF export + PyMuPDF rasterize when decks get big.
+"""
+import math
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+from .main import build
+from .charts_raster import _font  # system TTF lookup, shared
+
+
+def _soffice_png(pptx: Path, out_dir: Path) -> Path:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        ["soffice", "--headless", "--convert-to", "png",
+         str(pptx), "--outdir", str(out_dir)],
+        check=True, capture_output=True, timeout=120)
+    png = out_dir / (pptx.stem + ".png")
+    if not png.exists():
+        raise RuntimeError(f"soffice did not produce {png}")
+    return png
+
+
+def _split(pptx: Path, index: int, dst: Path) -> Path:
+    """index 1-based -> one-slide pptx at dst."""
+    from pptx import Presentation
+    prs = Presentation(str(pptx))
+    lst = prs.slides._sldIdLst
+    keep = list(lst)[index - 1]
+    for s in list(lst):
+        if s is not keep:
+            lst.remove(s)
+    prs.save(str(dst))
+    return dst
+
+
+def render_slide_images(pptd_path, out_dir, slides=None, tmp_pptx=None):
+    """-> [(slide_no, Path)] for the requested 1-based slide numbers."""
+    pptd_path = Path(pptd_path)
+    out_dir = Path(out_dir)
+    if tmp_pptx is None:
+        tmp_pptx = Path(tempfile.mkdtemp(prefix="pptd_utils-img-")) / "deck.pptx"
+        build(pptd_path, tmp_pptx)
+    if slides is None:
+        from pptx import Presentation
+        slides = range(1, len(Presentation(str(tmp_pptx)).slides._sldIdLst) + 1)
+    work = Path(tempfile.mkdtemp(prefix="pptd_utils-split-"))
+    results = []
+    for n in slides:
+        one = _split(tmp_pptx, n, work / f"s{n}.pptx")
+        png = _soffice_png(one, work)
+        final = out_dir / f"slide_{n:02d}.png"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(png), final)
+        results.append((n, final))
+    shutil.rmtree(work, ignore_errors=True)
+    return results
+
+
+def render_slide(pptd_path, slide, out_png):
+    """Export one slide (1-based) as a PNG."""
+    n, png = render_slide_images(pptd_path, Path(out_png).parent, [slide])[0]
+    dst = Path(out_png)
+    if png != dst:
+        shutil.move(str(png), dst)
+    return dst
+
+
+def render_collage(pptd_path, out_png, tile_w=480, gap=20, numbering=True,
+                   bg="#1F2430", label="Slide", slides=None, tmp_pptx=None):
+    """Grid collage of all (or selected) slides with numbered badges."""
+    import tempfile
+    tmp = Path(tempfile.mkdtemp(prefix="pptd_utils-col-"))
+    try:
+        imgs = render_slide_images(pptd_path, tmp, slides, tmp_pptx=tmp_pptx)
+        tiles = [(n, Image.open(p).convert("RGB")) for n, p in imgs]
+        if not tiles:
+            raise ValueError("no slides rendered")
+        n = len(tiles)
+        cols = math.ceil(math.sqrt(n))
+        rows = math.ceil(n / cols)
+        tw = tile_w
+        th = round(tiles[0][1].height * tw / tiles[0][1].width)
+        badge = max(18, tw // 18)
+        footer = badge + 14 if numbering else 0
+        W = cols * tw + (cols + 1) * gap
+        H = rows * (th + footer) + (rows + 1) * gap
+        sheet = Image.new("RGB", (W, H), _rgb(bg))
+        d = ImageDraw.Draw(sheet)
+        f = _font(round(badge * 0.62))
+        for i, (no, im) in enumerate(tiles):
+            r, c = divmod(i, cols)
+            x = gap + c * (tw + gap)
+            y = gap + r * (th + footer + gap)
+            sheet.paste(im.resize((tw, th), Image.LANCZOS), (x, y))
+            d.rectangle([x, y, x + tw, y + th], outline=(255, 255, 255),
+                        width=1)
+            if numbering:
+                text = f"{label} {no}"
+                bb = d.textbbox((0, 0), text, font=f)
+                tw_t, th_t = bb[2] - bb[0], bb[3] - bb[1]
+                cx = x + (tw - tw_t) / 2 - bb[0]
+                cy = y + th + (footer - th_t) / 2 - bb[1]
+                d.ellipse([cx - badge * 0.9, cy - badge * 0.45,
+                           cx + tw_t + badge * 0.9, cy + th_t + badge * 0.45],
+                          fill=(37, 99, 235))
+                d.text((cx, cy), text, font=f, fill=(255, 255, 255))
+        out = Path(out_png)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        sheet.save(out)
+        return out
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def _rgb(hexs):
+    h = hexs.lstrip("#")
+    return tuple(int(h[i:i + 2], 16) for i in (0, 2, 4))