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

pptd_utils/main.py

@@ -0,0 +1,285 @@
+"""Orchestration: load .pptd project, render pages, verify, CLI."""
+import argparse
+import subprocess
+import sys
+import zipfile
+from pathlib import Path
+
+import yaml
+from lxml import etree
+from pptx import Presentation
+from pptx.oxml.ns import qn
+from pptx.util import Pt
+
+from . import charts_native, charts_raster
+from .anim import build_timing
+from .fonts import embed_fonts, fetch_custom_fonts
+from .images import render_image
+from .icons import render_icon
+from .lines import render_line
+from .render_text import render_text
+from .shapes import render_shape
+from .style import fill_xml
+from .tables import render_table
+from .xmlutil import sub
+
+RENDERERS = ("text", "shape", "line", "image", "icon", "table", "chart")
+
+
+def _load_yaml(path):
+    return yaml.safe_load(Path(path).read_text())
+
+
+def _set_background(slide, bg, theme, root, prs):
+    if not bg:
+        bg = {"type": "solid", "color": "#FFFFFF"}
+    cSld = slide._element.find(qn("p:cSld"))
+    for e in cSld.findall(qn("p:bg")):
+        cSld.remove(e)
+    bgel = etree.Element(qn("p:bg"))
+    cSld.insert(0, bgel)
+    bgPr = sub(bgel, "p:bgPr")
+
+    def ipf(path):
+        path = Path(path)
+        if not path.is_absolute() and not path.exists():
+            cand = root / path
+            if cand.exists():
+                path = cand
+        part, rid = slide.part.get_or_add_image_part(str(path))
+        return rid
+    fill_xml(bgPr, bg, theme, image_part_fn=ipf)
+    if bg.get("type") == "image":
+        src = bg.get("src")
+        from .style import fetch_url, cover_src_rect
+        path = fetch_url(src) if str(src).startswith("http") else (
+            root / src if not Path(src).exists() else Path(src))
+        bf = bgPr.find(qn("a:blipFill"))
+        if bf is not None and bf.find(qn("a:srcRect")) is None:
+            rect = cover_src_rect(path, prs.slide_width / 12700,
+                                  prs.slide_height / 12700)
+            if rect:
+                st = bf.find(qn("a:stretch"))
+                sr = sub(bf, "a:srcRect", rect)
+                if st is not None:
+                    st.addprevious(sr)
+    sub(bgPr, "a:effectLst")
+
+
+def _add_fade(slide, speed="fast"):
+    sld = slide._element
+    for e in sld.findall(qn("p:transition")):
+        sld.remove(e)
+    tr = etree.Element(qn("p:transition"), {"spd": speed, "advClick": "1"})
+    tr.append(etree.Element(qn("p:fade")))
+    clr = sld.find(qn("p:clrMapOvr"))
+    if clr is not None:
+        clr.addnext(tr)
+    else:
+        sld.find(qn("p:cSld")).addnext(tr)
+
+
+def _render_element(slide, el, theme, root):
+    typ = el.get("elementType")
+    if typ == "text":
+        return render_text(slide, el, theme)
+    if typ == "shape":
+        return render_shape(slide, el, theme)
+    if typ == "line":
+        return render_line(slide, el, theme)
+    if typ == "image":
+        return render_image(slide, el, theme, root)
+    if typ == "icon":
+        return render_icon(slide, el, theme)
+    if typ == "table":
+        return render_table(slide, el, theme, root)
+    if typ == "chart":
+        if charts_native.can_render_native(el):
+            return charts_native.render_chart(slide, el, theme)
+        return charts_raster.render_chart(slide, el, theme, root)
+    raise ValueError(f"unsupported elementType: {typ}")
+
+
+def build(pptd_path, out_path):
+    pptd_path = Path(pptd_path)
+    out_path = Path(out_path)
+    root = pptd_path.parent
+    deck = _load_yaml(pptd_path)
+    if str(deck.get("version")) != "v2":
+        raise ValueError("only PPTD v2 supported")
+    theme = deck.get("theme") or {}
+    prs = Presentation()
+    prs.slide_width = Pt(deck["size"][0])
+    prs.slide_height = Pt(deck["size"][1])
+    if deck.get("title"):
+        prs.core_properties.title = deck["title"]
+
+    for page_rel in deck["pages"]:
+        page = _load_yaml(root / page_rel)
+        slide = prs.slides.add_slide(prs.slide_layouts[6])
+        _set_background(slide, page.get("background"), theme, root, prs)
+        shape_ids = {}
+        for el in page.get("elements", []):
+            shape = _render_element(slide, el, theme, root)
+            if shape is not None:
+                shape_ids[el.get("elementId")] = (
+                    shape.shape_id if hasattr(shape, "shape_id") else None)
+        if page.get("notes"):
+            slide.notes_slide.notes_text_frame.text = str(page["notes"])
+        _add_fade(slide)
+        if page.get("animations"):
+            build_timing(slide, page["animations"], shape_ids,
+                         prs.slide_width / 12700, prs.slide_height / 12700)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    prs.save(out_path)
+
+    n_fonts = 0
+    if deck.get("customFonts"):
+        fonts = fetch_custom_fonts(deck["customFonts"])
+        n_fonts = embed_fonts(out_path, fonts)
+    return len(deck["pages"]), n_fonts
+
+
+def verify(pptd_path, out_path):
+    """Runnable self-check: 1:1 structural round-trip."""
+    pptd_path = Path(pptd_path)
+    root = pptd_path.parent
+    deck = _load_yaml(pptd_path)
+    pages = [_load_yaml(root / p) for p in deck["pages"]]
+    prs = Presentation(out_path)
+    assert len(prs.slides) == len(pages), "slide count mismatch"
+    n_charts = n_tables = n_media = 0
+    for i, (page, slide) in enumerate(zip(pages, prs.slides), 1):
+        els = page.get("elements", [])
+        shapes = slide.shapes
+        assert len(shapes) == len(els), (
+            f"slide {i}: {len(shapes)} shapes != {len(els)} elements")
+        tr = slide._element.findall(qn("p:transition"))
+        assert tr and tr[0].find(qn("p:fade")) is not None, \
+            f"slide {i}: no fade transition"
+        if page.get("notes"):
+            assert slide.has_notes_slide and \
+                slide.notes_slide.notes_text_frame.text.strip() == \
+                str(page["notes"]).strip(), f"slide {i}: notes mismatch"
+        anims = page.get("animations")
+        timing = slide._element.findall(qn("p:timing"))
+        if anims:
+            assert timing, f"slide {i}: animations missing timing XML"
+        for el in els:
+            if el.get("elementType") == "chart":
+                n_charts += 1
+            if el.get("elementType") == "table":
+                n_tables += 1
+        n_media += sum(1 for s in shapes if s.shape_type == 13)
+    with zipfile.ZipFile(out_path) as z:
+        assert z.testzip() is None, "zip integrity failure"
+        charts = [n for n in z.namelist() if "charts/chart" in n]
+        fonts = [n for n in z.namelist() if n.endswith(".fntdata")]
+    native_charts = len(charts)
+    raster_charts = sum(
+        1 for page in pages for el in page.get("elements", [])
+        if el.get("elementType") == "chart" and
+        not charts_native.can_render_native(el))
+    assert native_charts + raster_charts == n_charts, (
+        f"chart mismatch: native {native_charts} + raster {raster_charts} "
+        f"!= declared {n_charts}")
+    if deck.get("customFonts"):
+        assert fonts, "customFonts declared but no fonts embedded"
+    print(f"verify OK: {len(pages)} slides, {n_charts} charts "
+          f"({native_charts} native, {raster_charts} raster), "
+          f"{n_tables} tables, {n_media} pictures, {len(fonts)} fonts")
+
+
+def convert(pptd_path, out_path=None):
+    src = Path(pptd_path)
+    dst = Path(out_path) if out_path else src.with_suffix(".pptx")
+    n, nf = build(src, dst)
+    verify(src, dst)
+    print(f"written: {dst} ({n} slides, {nf} fonts embedded)")
+    return dst
+
+
+def _slides(value, count):
+    if value is None or value == "all":
+        return list(range(1, count + 1))
+    try:
+        result = [int(n) for n in value.split(",")]
+    except ValueError as exc:
+        raise ValueError("slides must be 'all' or comma-separated numbers") from exc
+    if not result or any(n < 1 or n > count for n in result):
+        raise ValueError(f"slide numbers must be between 1 and {count}")
+    return result
+
+
+def _cli_export(kind, selection, src):
+    from . import slides_image
+    import tempfile
+    src = Path(src)
+    with tempfile.TemporaryDirectory(prefix="pptd-cli-") as tmp:
+        pptx = Path(tmp) / "deck.pptx"
+        convert(src, pptx)
+        prs = Presentation(pptx)
+        slides = _slides(selection, len(prs.slides))
+        if kind == "png":
+            if selection == "collage":
+                out = src.with_name(src.stem + "-collage.png")
+                slides_image.render_collage(src, out, slides=slides, tmp_pptx=pptx)
+                print(f"collage: {out}")
+            else:
+                out_dir = src.with_name(src.stem + "-png")
+                images = slides_image.render_slide_images(src, out_dir, slides=slides,
+                                                          tmp_pptx=pptx)
+                print(f"{len(images)} PNG files -> {out_dir}/")
+        else:
+            out = src.with_name(src.stem + ".pdf")
+            selected = Path(tmp) / "selected.pptx"
+            if slides != list(range(1, len(prs.slides) + 1)):
+                keep = {id(prs.slides[n - 1]._element) for n in slides}
+                for slide in list(prs.slides):
+                    if id(slide._element) not in keep:
+                        prs.slides._sldIdLst.remove(slide._element.getparent())
+                prs.save(selected)
+                pptx = selected
+            subprocess.run(["soffice", "--headless", "--convert-to", "pdf",
+                            "--outdir", str(tmp), str(pptx)],
+                           check=True, capture_output=True, timeout=120)
+            Path(tmp, f"{pptx.stem}.pdf").replace(out)
+            print(f"PDF: {out}")
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="pptd", description="PPTD v2 CLI")
+    parser.add_argument("command", choices=("check", "png", "pptx", "pdf"))
+    parser.add_argument("args", nargs="+", metavar="PATH|SLIDES",
+                        help="path; png/pdf optionally accept all, collage, or 1,2,3")
+    parsed = parser.parse_args(sys.argv[1:] if argv is None else argv)
+    values = parsed.args
+    if parsed.command in ("check", "pptx"):
+        if len(values) != 1:
+            parser.error(f"{parsed.command} syntax: pptd {parsed.command} path")
+        selection, src = "all", Path(values[0])
+    else:
+        if len(values) == 1:
+            selection, src = "all", Path(values[0])
+        elif len(values) == 2:
+            selection, src = values
+            src = Path(src)
+        else:
+            parser.error(f"{parsed.command} syntax: pptd {parsed.command} [slides] path")
+    if parsed.command == "check":
+        import tempfile
+        with tempfile.TemporaryDirectory(prefix="pptd-check-") as tmp:
+            out = Path(tmp) / "checked.pptx"
+            build(src, out)
+            verify(src, out)
+    elif parsed.command == "pptx":
+        convert(src)
+    else:
+        if parsed.command == "pdf" and selection == "collage":
+            parser.error("pdf accepts only all or comma-separated slide numbers")
+        _cli_export(parsed.command, selection, src)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pptd_utils/render_text.py

@@ -0,0 +1,241 @@
+"""Text element + shared run emission (used by text boxes and table cells)."""
+from lxml import etree
+from pptx.dml.color import RGBColor
+from pptx.enum.text import MSO_ANCHOR, PP_ALIGN
+from pptx.oxml.ns import qn
+from pptx.util import Pt
+
+from .rich import parse_rich, LIST_TYPES
+from .style import resolve_color, color_el, css_px
+from .xmlutil import sub, insert_ordered, RPR_ORDER, set_xfrm_flip_rot
+
+H_ALIGN = {"left": PP_ALIGN.LEFT, "center": PP_ALIGN.CENTER,
+           "right": PP_ALIGN.RIGHT, "justify": PP_ALIGN.JUSTIFY,
+           "distributed": PP_ALIGN.DISTRIBUTE}
+V_ALIGN = {"top": MSO_ANCHOR.TOP, "middle": MSO_ANCHOR.MIDDLE,
+           "bottom": MSO_ANCHOR.BOTTOM}
+
+TEXT_DEFAULTS = {"color": "#000000", "fontSize": 18, "fontFamily": "MiSans",
+                 "bold": False, "italic": False, "lineHeight": 1,
+                 "letterSpacing": 0, "marginTop": 0}
+
+TEXTSTYLE_KEYS = ("color", "fontSize", "fontFamily", "bold", "italic",
+                  "backgroundColor", "lineHeight", "lineHeightPx",
+                  "letterSpacing", "marginTop")
+
+
+def resolve_base_style(c, theme, extra=None):
+    """Style priority chain for TextContent-like dicts -> flat style dict."""
+    base = dict(TEXT_DEFAULTS)
+    if c.get("style"):
+        ref = theme.get("textStyles", {}).get(str(c["style"]).lstrip("$"), {})
+        for k in TEXTSTYLE_KEYS:
+            if ref.get(k) is not None:
+                base[k] = ref[k]
+    for k in TEXTSTYLE_KEYS:
+        if c.get(k) is not None:
+            base[k] = c[k]
+    for k, v in (extra or {}).items():
+        if v is not None:
+            base[k] = v
+    return base
+
+
+def _font_family_names(ff):
+    """FontFamily -> (latin, ea)."""
+    if isinstance(ff, dict):
+        return ff.get("latin"), ff.get("ea")
+    return ff, ff
+
+
+def emit_runs(p, para, base, theme, opacity=1.0):
+    """Emit parsed runs of one paragraph into a pptx paragraph p."""
+    for run in para.runs:
+        if run.text == "\n":
+            p.add_line_break()
+            continue
+        if run.math is not None:
+            omml = latex_to_omml(run.math)
+            if omml is not None:
+                p._p.append(omml)
+                continue
+        if not run.text:
+            continue
+        r = p.add_run()
+        r.text = run.text
+        span = run.span
+        f = r.font
+        size = css_px(span.get("font-size")) or base.get("fontSize", 18)
+        f.size = Pt(size)
+        latin, ea = _font_family_names(
+            span.get("font-family") or base.get("fontFamily", "MiSans"))
+        f.name = str(latin or "MiSans")
+        rPr = r._r.get_or_add_rPr()
+        if ea:
+            ea_el = rPr.find(qn("a:ea"))
+            if ea_el is None:
+                ea_el = insert_ordered(rPr, etree.Element(qn("a:ea")), RPR_ORDER)
+            ea_el.set("typeface", str(ea))
+        f.bold = bool(base.get("bold")) or run.bold
+        f.italic = bool(base.get("italic")) or run.italic
+        if run.underline:
+            f.underline = True
+        if run.strike:
+            rPr.set("strike", "sngStrike")
+        if run.sup:
+            rPr.set("baseline", "30000")
+        if run.sub:
+            rPr.set("baseline", "-25000")
+        ls = base.get("letterSpacing")
+        if ls:
+            rPr.set("spc", str(int(float(ls) * 100)))
+        # color (+alpha)
+        color = span.get("color") or base.get("color", "#000000")
+        if run.link and not span.get("color"):
+            color = "#0563C1"
+            f.underline = True
+        rgb, alpha = resolve_color(color, theme, opacity)
+        f.color.rgb = rgb
+        if alpha < 1.0:
+            srgb = rPr.find(qn("a:solidFill") + "/" + qn("a:srgbClr"))
+            if srgb is None:
+                srgb = rPr.find(qn("a:solidFill")).find(qn("a:srgbClr"))
+            if srgb is not None:
+                sub(srgb, "a:alpha", {"val": str(int(alpha * 100000))})
+        if run.link:
+            r.hyperlink.address = run.link
+        bg = span.get("background-color")
+        if bg:
+            hl = etree.Element(qn("a:highlight"))
+            color_el(hl, bg, theme)
+            insert_ordered(rPr, hl, RPR_ORDER)
+
+
+def _apply_para_style(p, para, base, theme, def_align):
+    pPr = p._p.get_or_add_pPr()
+    p.alignment = H_ALIGN.get(para.align or def_align, PP_ALIGN.LEFT)
+    lh_px = para.lh_px if para.lh_px is not None else (
+        css_px(base.get("lineHeightPx")) if base.get("lineHeightPx") else None)
+    if lh_px:
+        p.line_spacing = Pt(lh_px)
+    else:
+        lh = para.lh if para.lh is not None else base.get("lineHeight", 1)
+        if lh and float(lh) != 1.0:
+            p.line_spacing = float(lh)
+    mt = para.mt if para.mt is not None else base.get("marginTop", 0)
+    if mt:
+        p.space_before = Pt(float(mt))
+    ml = para.ml
+    if ml:
+        pPr.set("marL", str(int(Pt(float(ml)))))
+    if para.mr:
+        pPr.set("marR", str(int(Pt(float(para.mr)))))
+    if para.ls:
+        # li-level letter-spacing: applied via runs below (base override)
+        base["letterSpacing"] = para.ls
+    # bullets
+    if para.bullet or para.ordered:
+        lsty = para.list_style or "disc"
+        if para.ordered and lsty == "disc":
+            lsty = "decimal"
+        if lsty in (None, "none"):
+            insert_ordered(pPr, etree.SubElement(pPr, qn("a:buNone")), _PPR_BUL)
+        elif lsty in LIST_TYPES and isinstance(LIST_TYPES[lsty], str) and LIST_TYPES[lsty][0].isalpha():
+            bul = etree.SubElement(pPr, qn("a:buAutoNum"), {"type": LIST_TYPES[lsty]})
+            insert_ordered(pPr, bul, _PPR_BUL)
+            _add_bu_font(pPr)
+        else:
+            char = LIST_TYPES.get(lsty, "\u2022") if lsty in LIST_TYPES else lsty
+            bul = etree.SubElement(pPr, qn("a:buChar"), {"char": str(char)})
+            insert_ordered(pPr, bul, _PPR_BUL)
+            _add_bu_font(pPr)
+        if pPr.get("marL") is None:
+            pPr.set("marL", "228600")
+        pPr.set("indent", "-228600")
+
+
+_PPR_BUL = [qn(t) for t in ("a:buClrTx", "a:buClr", "a:buSzTx", "a:buSzPct",
+                            "a:buSzPts", "a:buFontTx", "a:buFont", "a:buNone",
+                            "a:buAutoNum", "a:buChar", "a:buBlip", "a:tabLst",
+                            "a:defRPr", "a:extLst")]
+
+
+def _add_bu_font(pPr):
+    bf = etree.SubElement(pPr, qn("a:buFont"), {"typeface": "Arial"})
+    insert_ordered(pPr, bf, _PPR_BUL)
+
+
+def emit_text(tf, content, theme, default_align=("left", "top"), opacity=1.0,
+              extra_style=None, vertical=None, wrap=None):
+    """Emit TextContent into a pptx text_frame tf."""
+    base = resolve_base_style(content, theme, extra_style)
+    align = content.get("align") or list(default_align)
+    tf.word_wrap = content.get("wrap", True) if wrap is None else wrap
+    for m in ("margin_left", "margin_right", "margin_top", "margin_bottom"):
+        setattr(tf, m, 0)
+    tf.vertical_anchor = V_ALIGN.get(align[1], MSO_ANCHOR.TOP)
+    if vertical or content.get("textDirection") == "vertical":
+        tf._txBody.find(qn("a:bodyPr")).set("vert", "eaVert")
+    paras = parse_rich(content.get("text", ""))
+    for i, para in enumerate(paras):
+        p = tf.paragraphs[0] if i == 0 else tf.add_paragraph()
+        _apply_para_style(p, para, base, theme, align[0])
+        emit_runs(p, para, base, theme, opacity)
+    return base
+
+
+def render_text(slide, el, theme):
+    c = el["content"]
+    x, y, w, h = el["bounds"]
+    tb = slide.shapes.add_textbox(Pt(x), Pt(y), Pt(w), Pt(h))
+    tf = tb.text_frame
+    tf.auto_size = None
+    base = emit_text(tf, c, theme, opacity=el.get("opacity", 1.0))
+    rotation = el.get("rotation") or 0
+    flip = el.get("flip")
+    if rotation or flip:
+        set_xfrm_flip_rot(tb, rotation, flip)
+    # text gradient
+    grad = c.get("gradient")
+    if grad:
+        _text_gradient(tf, grad, theme)
+    shadow = c.get("shadow")
+    if shadow:
+        _text_shadow(tf, shadow, theme)
+    return tb
+
+
+def _text_gradient(tf, grad, theme):
+    from .xmlutil import RPR_ORDER as ORDER
+    from .style import fill_xml
+    for para in tf.paragraphs:
+        for run in para.runs:
+            rPr = run._r.get_or_add_rPr()
+            fill_xml(rPr, grad, theme, order=ORDER)
+
+
+def _text_shadow(tf, shadow, theme):
+    from .style import shadow_xml
+    for para in tf.paragraphs:
+        for run in para.runs:
+            rPr = run._r.get_or_add_rPr()
+            shadow_xml(rPr, shadow, theme, order=RPR_ORDER)
+
+
+def latex_to_omml(latex):
+    """Optional: LaTeX -> m:oMath element via latex2mathml + mathml2omml."""
+    try:
+        import latex2mathml.converter as l2m
+        import mathml2omml
+    except ImportError:
+        return None
+    try:
+        mathml = l2m.convert(latex)
+        omml = mathml2omml.convert(mathml)
+        if isinstance(omml, bytes):
+            omml = omml.decode()
+        ns = {"m": "http://schemas.openxmlformats.org/officeDocument/2006/math"}
+        root = etree.fromstring("<root xmlns:m='%s'>%s</root>" % (ns["m"], omml))
+        return root.find("m:oMath", ns)
+    except Exception:
+        return None