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

pptd_utils/fonts.py

@@ -0,0 +1,130 @@
+"""customFonts: fetch Google Fonts CSS, download woff2, convert to ttf,
+embed into the pptx package as fntdata parts.
+
+Requires fontTools+brotli (optional). Falls back to no embedding.
+"""
+import re
+import shutil
+import urllib.request
+import zipfile
+from pathlib import Path
+
+CACHE = Path.home() / ".cache" / "pptd_utils" / "fonts"
+
+FNT_REL = ("http://schemas.openxmlformats.org/officeDocument/2006/"
+           "relationships/font")
+
+
+def fetch_custom_fonts(custom_fonts):
+    """CustomFont[] -> [(family, ttf_bytes | None)]."""
+    out = []
+    for cf in custom_fonts or []:
+        family = cf.get("family")
+        src = cf.get("src")
+        ttf = None
+        try:
+            css = _fetch(src).decode("utf-8", "ignore")
+            # take latin subset woff2 (fallback: first woff2 found)
+            urls = re.findall(r"url\((https://[^)]+\.woff2)\)", css)
+            if urls:
+                # prefer the last block (usually latin)
+                woff2 = _fetch(urls[-1])
+                ttf = _woff2_to_ttf(woff2)
+        except Exception as e:
+            print(f"pptd_utils: customFont {family!r} skipped: {e}")
+        out.append((family, ttf))
+    return out
+
+
+def _fetch(url):
+    h = str(abs(hash(url)))
+    # cache by URL content — hash() is process-random; use sha1
+    import hashlib
+    h = hashlib.sha1(url.encode()).hexdigest()[:16]
+    dst = CACHE / h
+    if not dst.exists():
+        CACHE.mkdir(parents=True, exist_ok=True)
+        tmp = dst.with_suffix(".part")
+        urllib.request.urlretrieve(url, tmp)
+        tmp.rename(dst)
+    return dst.read_bytes()
+
+
+def _woff2_to_ttf(woff2):
+    try:
+        from fontTools.ttLib import TTFont
+        import io
+        font = TTFont(io.BytesIO(woff2))
+        font.flavor = None
+        buf = io.BytesIO()
+        font.save(buf)
+        return buf.getvalue()
+    except ImportError:
+        return None
+
+
+def embed_fonts(pptx_path, fonts):
+    """Post-process a saved .pptx: add fntdata parts + presentation wiring.
+
+    fonts: [(family, ttf_bytes)] — entries with None are skipped.
+    """
+    fonts = [(f, b) for f, b in fonts if b]
+    if not fonts:
+        return 0
+    src = Path(pptx_path)
+    tmp = src.with_suffix(".pptx.tmp")
+    with zipfile.ZipFile(src) as zin, zipfile.ZipFile(
+            tmp, "w", zipfile.ZIP_DEFLATED) as zout:
+        names = zin.namelist()
+        # 1. content types
+        ct = zin.read("[Content_Types].xml").decode("utf-8")
+        if "fntdata" not in ct:
+            ct = ct.replace("</Types>",
+                            '<Default Extension="fntdata" '
+                            'ContentType="application/x-fontdata"/></Types>')
+        zout.writestr("[Content_Types].xml", ct)
+        # 2. presentation rels
+        rels_name = "ppt/_rels/presentation.xml.rels"
+        rels = zin.read(rels_name).decode("utf-8")
+        rid_max = 1
+        for m in re.finditer(r'Id="rId(\d+)"', rels):
+            rid_max = max(rid_max, int(m.group(1)) + 1)
+        new_rels = ""
+        font_parts = []
+        for i, (family, ttf) in enumerate(fonts, 1):
+            part = f"ppt/fonts/font{i}.fntdata"
+            font_parts.append((family, f"rId{rid_max}"))
+            new_rels += (f'<Relationship Id="rId{rid_max}" Type="{FNT_REL}" '
+                         f'Target="fonts/font{i}.fntdata"/>')
+            rid_max += 1
+            zout.writestr(part, ttf)
+        rels = rels.replace("</Relationships>", new_rels + "</Relationships>")
+        zout.writestr(rels_name, rels)
+        # 3. presentation.xml: embeddedFontLst after notesSz (schema order)
+        pres = zin.read("ppt/presentation.xml").decode("utf-8")
+        if "embeddedFontLst" not in pres:
+            fl = "<p:embeddedFontLst>"
+            for family, rid in font_parts:
+                fl += (f'<p:embeddedFont><p:font typeface="{_esc(family)}"/>'
+                       f'<p:regular r:id="{rid}"/></p:embeddedFont>')
+            fl += "</p:embeddedFontLst>"
+            m = re.search(r"<p:notesSz[^/]*/>", pres)
+            if m:
+                pres = pres[:m.end()] + fl + pres[m.end():]
+            else:
+                pres = pres.replace("</p:presentation>", fl + "</p:presentation>")
+            pres = pres.replace("<p:presentation ", '<p:presentation embedTrueTypeFonts="1" ', 1)
+        zout.writestr("ppt/presentation.xml", pres)
+        # 4. copy the rest
+        for name in names:
+            if name in ("[Content_Types].xml", rels_name,
+                        "ppt/presentation.xml"):
+                continue
+            zout.writestr(name, zin.read(name))
+    shutil.move(str(tmp), str(src))
+    return len(fonts)
+
+
+def _esc(s):
+    return (str(s).replace("&", "&amp;").replace("<", "&lt;")
+            .replace(">", "&gt;").replace('"', "&quot;"))

pptd_utils/icons.py

@@ -0,0 +1,135 @@
+"""Icon element: Font Awesome 6/7 free (fas/far/fab) rasterized via Pillow.
+
+Supports solid + gradient fills, outline (border), drop shadow, opacity.
+"""
+import json
+import math
+import urllib.request
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFilter, ImageFont
+from pptx.util import Pt
+
+from .style import resolve_color, hex_to_rgba
+from .xmlutil import set_xfrm_flip_rot
+
+CACHE = Path.home() / ".cache" / "pptd_utils" / "fa"
+FA_URLS = {
+    "fas": ("fa-solid-900.ttf", "https://cdn.jsdelivr.net/npm/@fortawesome/fontawesome-free@6.7.2/webfonts/fa-solid-900.ttf"),
+    "far": ("fa-regular-400.ttf", "https://cdn.jsdelivr.net/npm/@fortawesome/fontawesome-free@6.7.2/webfonts/fa-regular-400.ttf"),
+    "fab": ("fa-brands-400.ttf", "https://cdn.jsdelivr.net/npm/@fortawesome/fontawesome-free@6.7.2/webfonts/fa-brands-400.ttf"),
+}
+FA_META_URL = ("https://raw.githubusercontent.com/FortAwesome/"
+               "Font-Awesome/6.x/metadata/icons.json")
+
+_META = None
+
+
+def fa_meta():
+    global _META
+    if _META is None:
+        CACHE.mkdir(parents=True, exist_ok=True)
+        meta_path = CACHE / "icons.json"
+        if not meta_path.exists():
+            urllib.request.urlretrieve(FA_META_URL, meta_path)
+        _META = json.loads(meta_path.read_text())
+    return _META
+
+
+def fa_ttf(style):
+    fname, url = FA_URLS[style]
+    path = CACHE / fname
+    if not path.exists():
+        CACHE.mkdir(parents=True, exist_ok=True)
+        urllib.request.urlretrieve(url, path)
+    return path
+
+
+def _gradient_image(size, stops, angle, theme):
+    """RGB gradient image (size) from stops [(pos, (r,g,b))]."""
+    c0 = hex_to_rgba(stops[0]["color"], theme)[:3] if len(stops) > 1 else (0, 0, 0)
+    c1 = hex_to_rgba(stops[-1]["color"], theme)[:3] if len(stops) > 1 else (255, 255, 255)
+    t = Image.linear_gradient("L").rotate(90 - (angle % 360), expand=True)
+    t = t.resize(size)
+    r = t.point(lambda v: int(c0[0] + (c1[0] - c0[0]) * v / 255))
+    g = t.point(lambda v: int(c0[1] + (c1[1] - c0[1]) * v / 255))
+    b = t.point(lambda v: int(c0[2] + (c1[2] - c0[2]) * v / 255))
+    return Image.merge("RGB", (r, g, b))
+
+
+def render_icon(slide, el, theme):
+    style, name = str(el["iconName"]).split(":", 1)
+    if style not in FA_URLS:
+        raise ValueError(f"icon style {style!r} unsupported (fas/far/fab)")
+    meta = fa_meta()
+    m = meta.get(name)
+    if not m or "unicode" not in m:
+        raise ValueError(f"unknown FA icon {name!r}")
+    x, y, w, h = el["bounds"]
+    w, h = int(round(w)), int(round(h))
+    fill = el.get("fill") or {"type": "solid", "color": "#000000"}
+    ftype = fill.get("type", "solid")
+    opacity = float(el.get("opacity", 1.0))
+    glyph = chr(int(m["unicode"], 16))
+    border = el.get("border")
+    shadow = el.get("shadow")
+
+    rgb, _ = resolve_color(fill.get("color", "#000000"), theme, opacity)
+    parts = [style, name, str(rgb), f"{opacity:.3f}", f"{w}x{h}"]
+    if ftype == "gradient":
+        parts.append("g%s" % ",".join(s["color"] for s in fill.get("stops", [])) + f"@{fill.get('angle', 0)}")
+    if border:
+        bc, _ = resolve_color(border.get("color", "#000000"), theme)
+        parts.append(f"b{bc}_{border.get('width', 1)}")
+    if shadow:
+        sc, _ = resolve_color(shadow.get("color", "#000000"), theme)
+        off = shadow.get("offset") or [0, 0]
+        parts.append(f"s{sc}_{shadow.get('blur', 0)}_{off[0]},{off[1]}")
+    png = CACHE / ("icon_" + "_".join(str(p).replace("/", ".") for p in parts) + ".png")
+
+    if not png.exists():
+        S = 3
+        W, H = w * S, h * S
+        img = Image.new("RGBA", (W, H), (0, 0, 0, 0))
+        font = ImageFont.truetype(str(fa_ttf(style)), int(max(w, h) * S * 0.82))
+        anchor = (W // 2, H // 2)
+        stroke_w = int(border.get("width", 1) * S) if border else 0
+        if shadow:
+            sc_rgb, _ = resolve_color(shadow.get("color", "#000000"), theme)
+            soff = shadow.get("offset") or [0, 0]
+            lay = Image.new("RGBA", (W, H), (0, 0, 0, 0))
+            ImageDraw.Draw(lay).text(
+                (anchor[0] + int(soff[0] * S), anchor[1] + int(soff[1] * S)),
+                glyph, font=font,
+                fill=(*sc_rgb, int(255 * opacity)),
+                stroke_width=stroke_w,
+                stroke_fill=(*sc_rgb, int(255 * opacity)))
+            lay = lay.filter(ImageFilter.GaussianBlur(max(1, int(shadow.get("blur", 4) * S / 2))))
+            img.alpha_composite(lay)
+        mask = Image.new("L", (W, H), 0)
+        ImageDraw.Draw(mask).text(anchor, glyph, font=font, fill=255,
+                                  stroke_width=stroke_w, stroke_fill=255)
+        if ftype == "gradient":
+            col = _gradient_image((W, H), fill.get("stops", []), float(fill.get("angle", 0)), theme).convert("RGBA")
+        else:
+            col = Image.new("RGBA", (W, H), (*rgb, int(255 * opacity)))
+        alpha_mask = mask if opacity >= 1 else mask.point(lambda v: int(v * opacity))
+        body = Image.new("RGBA", (W, H), (0, 0, 0, 0))
+        body.paste(col, (0, 0), alpha_mask)
+        img.alpha_composite(body)
+        if border:
+            bc, _ = resolve_color(border.get("color", "#000000"), theme, opacity)
+            inner = Image.new("L", (W, H), 0)
+            ImageDraw.Draw(inner).text(anchor, glyph, font=font, fill=255)
+            ring = Image.new("L", (W, H), 0)
+            ring.paste(mask, (0, 0))
+            ring.paste(0, (0, 0), inner)
+            ring_col = Image.new("RGBA", (W, H), (*bc, 255))
+            outl = Image.new("RGBA", (W, H), (0, 0, 0, 0))
+            outl.paste(ring_col, (0, 0), ring if opacity >= 1 else ring.point(lambda v: int(v * opacity)))
+            img.alpha_composite(outl)
+        img.resize((w, h), Image.LANCZOS).save(png)
+
+    pic = slide.shapes.add_picture(str(png), Pt(x), Pt(y), Pt(w), Pt(h))
+    set_xfrm_flip_rot(pic, el.get("rotation") or 0, el.get("flip"))
+    return pic

pptd_utils/images.py

@@ -0,0 +1,105 @@
+"""Image element: fit (cover/contain/fill), crop (incl. negative outset),
+cropShape clipping, border, shadow, opacity, rotation/flip."""
+import hashlib
+from pathlib import Path
+
+from PIL import Image as PILImage
+from pptx.enum.shapes import MSO_SHAPE
+from pptx.oxml.ns import qn
+from pptx.util import Pt
+
+from .shapes import apply_preset_geometry, build_custgeom, _apply_alpha
+from .style import fetch_url, cover_src_rect, ln_xml, shadow_xml
+from .xmlutil import sub, set_xfrm_flip_rot, insert_ordered, SPPR_ORDER
+
+PREP_CACHE = Path.home() / ".cache" / "pptd_utils" / "prepped"
+
+
+def _prep_negative_crop(src, crop):
+    """Negative crop values -> expand canvas with transparency; returns path."""
+    l = crop.get("left", 0) or 0
+    t = crop.get("top", 0) or 0
+    r = crop.get("right", 0) or 0
+    b = crop.get("bottom", 0) or 0
+    if min(l, t, r, b) >= 0:
+        return src
+    key = hashlib.sha1(f"{src}|{l},{t},{r},{b}".encode()).hexdigest()[:16]
+    dst = PREP_CACHE / f"{key}.png"
+    if not dst.exists():
+        PREP_CACHE.mkdir(parents=True, exist_ok=True)
+        with PILImage.open(src) as im:
+            im = im.convert("RGBA")
+            w, h = im.size
+            pad = (max(0, -l) * w, max(0, -t) * h, max(0, -r) * w, max(0, -b) * h)
+            canvas = PILImage.new("RGBA", (w + int(pad[0] + pad[2]), h + int(pad[1] + pad[3])), (0, 0, 0, 0))
+            canvas.paste(im, (int(pad[0]), int(pad[1])))
+            canvas.save(dst)
+    return dst
+
+
+def render_image(slide, el, theme, root):
+    src = el["src"]
+    path = fetch_url(src) if str(src).startswith(("http://", "https://")) else (root / src)
+    x, y, w, h = el["bounds"]
+    crop = el.get("crop") or {}
+    if isinstance(crop, (list, tuple)):
+        crop = dict(zip(("left", "top", "right", "bottom"), crop))
+    path = _prep_negative_crop(path, crop)
+    pos_crop = {k: max(0.0, v) for k, v in crop.items() if (v or 0) > 0} if crop else {}
+
+    fite = el.get("fit") or {}
+    fit = fite.get("mode", "cover") if isinstance(fite, dict) else str(fite)
+    px, py, pw, ph = x, y, w, h
+    src_rect = None
+    if fit == "cover":
+        src_rect = cover_src_rect(path, w, h, pos_crop or None)
+    elif fit == "contain":
+        try:
+            with PILImage.open(path) as im:
+                iw, ih = im.size
+        except Exception:
+            iw = ih = 1
+        if iw and ih and w and h:
+            if iw / ih > w / h:
+                pw = w
+                ph = w * ih / iw
+            else:
+                ph = h
+                pw = h * iw / ih
+            px = x + (w - pw) / 2
+            py = y + (h - ph) / 2
+
+    pic = slide.shapes.add_picture(str(path), Pt(px), Pt(py), Pt(pw), Pt(ph))
+    blipFill = pic._element.blipFill
+    if src_rect:
+        st = blipFill.find(qn("a:stretch"))
+        sr = sub(blipFill, "a:srcRect", src_rect)
+        if st is not None:
+            st.addprevious(sr)
+    opacity = el.get("opacity", 1.0)
+    if opacity is not None and float(opacity) < 1.0:
+        blip = blipFill.find(qn("a:blip"))
+        sub(blip, "a:alphaModFix", {"amt": str(int(float(opacity) * 100000))})
+
+    spPr = pic._element.spPr
+    cs = el.get("cropShape")
+    if isinstance(cs, str):
+        cs = {"shapeName": cs}
+    if cs:
+        name = cs.get("shapeName")
+        if name == "custom":
+            build_custgeom(spPr, cs.get("viewBox", [pw, ph]), cs.get("path", ""))
+        else:
+            geom = spPr.find(qn("a:prstGeom"))
+            if geom is None:
+                geom = insert_ordered(spPr, sub(spPr, "a:prstGeom", {"prst": "rect"}), SPPR_ORDER)
+            else:
+                geom.set("prst", name or "rect")
+                avLst = geom.find(qn("a:avLst"))
+                for gd in list(avLst):
+                    avLst.remove(gd)
+            apply_preset_geometry(pic, name, cs.get("adjustments"))
+    ln_xml(spPr, el.get("border"), theme)
+    shadow_xml(spPr, el.get("shadow"), theme)
+    set_xfrm_flip_rot(pic, el.get("rotation") or 0, el.get("flip"))
+    return pic

pptd_utils/lines.py

@@ -0,0 +1,180 @@
+"""Line element: bezier/rounded/sharp polylines via custGeom + arrowheads."""
+import math
+
+from pptx.enum.shapes import MSO_SHAPE, MSO_CONNECTOR
+from pptx.oxml.ns import qn
+from pptx.util import Pt
+from lxml import etree
+
+from .shapes import build_custgeom, _ipf
+from .style import ln_xml, shadow_xml
+from .xmlutil import sub, set_xfrm_flip_rot
+
+ARROW_MAP = {"arrow": "triangle", "stealth": "stealth",
+             "diamond": "diamond", "oval": "oval"}
+
+
+def _pts(points):
+    toks = str(points).replace(",", " ").split()
+    out = []
+    for i in range(0, len(toks) - 1, 2):
+        out.append((float(toks[i]), float(toks[i + 1])))
+    return out
+
+
+def _path_cmds(pts, curve):
+    """Build (tag, vals) list in viewBox coords from point list."""
+    n = len(pts)
+    cmds = [("M", [pts[0][0], pts[0][1]])]
+    if curve is None or curve == "sharp" or n == 2:
+        for p in pts[1:]:
+            cmds.append(("L", [p[0], p[1]]))
+        return cmds
+    if curve == "smooth":
+        i = 1
+        while i < n:
+            if n - i >= 3:
+                cmds.append(("C", [pts[i][0], pts[i][1], pts[i + 1][0],
+                                   pts[i + 1][1], pts[i + 2][0], pts[i + 2][1]]))
+                i += 3
+            elif n - i == 2:
+                # quadratic through one control
+                x0, y0 = pts[i - 1]
+                x1, y1 = pts[i]
+                x2, y2 = pts[i + 1]
+                cx1 = x0 + 2 / 3 * (x1 - x0)
+                cy1 = y0 + 2 / 3 * (y1 - y0)
+                cx2 = x2 + 2 / 3 * (x1 - x2)
+                cy2 = y2 + 2 / 3 * (y1 - y2)
+                cmds.append(("C", [cx1, cy1, cx2, cy2, x2, y2]))
+                i += 2
+            else:
+                cmds.append(("L", [pts[i][0], pts[i][1]]))
+                i += 1
+        return cmds
+    # round: polyline with corner fillets
+    r = None
+    for i in range(1, n - 1):
+        e1 = math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1])
+        e2 = math.hypot(pts[i + 1][0] - pts[i][0], pts[i + 1][1] - pts[i][1])
+        cand = min(e1, e2) / 3.0
+        r = cand if r is None else min(r, cand)
+    r = min(r or 0, 12.0)
+    if r < 0.01:
+        for p in pts[1:]:
+            cmds.append(("L", [p[0], p[1]]))
+        return cmds
+    cur = pts[0]
+    for i in range(1, n - 1):
+        p, nx = pts[i], pts[i + 1]
+        d1 = (p[0] - cur[0], p[1] - cur[1])
+        l1 = math.hypot(*d1) or 1.0
+        d2 = (nx[0] - p[0], nx[1] - p[1])
+        l2 = math.hypot(*d2) or 1.0
+        r1 = min(r, l1 / 2)
+        r2 = min(r, l2 / 2)
+        c1 = (p[0] - d1[0] / l1 * r1, p[1] - d1[1] / l1 * r1)
+        c2 = (p[0] + d2[0] / l2 * r2, p[1] + d2[1] / l2 * r2)
+        cmds.append(("L", [c1[0], c1[1]]))
+        cmds.append(("Q", [p[0], p[1], c2[0], c2[1]]))
+        cur = c2
+    last = pts[-1]
+    cmds.append(("L", [last[0], last[1]]))
+    return cmds
+
+
+def _emit_path(path_el, cmds):
+    for tag, vals in cmds:
+        if tag == "M":
+            mt = sub(path_el, "a:moveTo")
+            pt = sub(mt, "a:pt", {"x": _i(vals[0]), "y": _i(vals[1])})
+        elif tag == "L":
+            lt = sub(path_el, "a:lnTo")
+            sub(lt, "a:pt", {"x": _i(vals[0]), "y": _i(vals[1])})
+        elif tag == "C":
+            cb = sub(path_el, "a:cubicBezTo")
+            for j in (0, 2, 4):
+                sub(cb, "a:pt", {"x": _i(vals[j]), "y": _i(vals[j + 1])})
+        elif tag == "Q":
+            qb = sub(path_el, "a:quadBezTo")
+            for j in (0, 2):
+                sub(qb, "a:pt", {"x": _i(vals[j]), "y": _i(vals[j + 1])})
+
+
+def _i(v):
+    return str(int(round(float(v))))
+
+
+def render_line(slide, el, theme):
+    pts = _pts(el.get("points", ""))
+    if len(pts) < 2:
+        raise ValueError("line needs >= 2 points")
+    x, y, w, h = el["bounds"]
+    vw, vh = el.get("viewBox", [w, h])
+
+    # Use a native connector for ordinary 2-point lines. PowerPoint can drop
+    # custom-geometry line shapes even though cowork/browser renderers display them.
+    if len(pts) == 2:
+        sx, sy = pts[0]
+        ex, ey = pts[1]
+        x1, y1 = x + sx / vw * w, y + sy / vh * h
+        x2, y2 = x + ex / vw * w, y + ey / vh * h
+        shape = slide.shapes.add_connector(
+            MSO_CONNECTOR.STRAIGHT, Pt(x1), Pt(y1), Pt(x2), Pt(y2))
+        shape.shadow.inherit = False
+        spPr = shape._element.spPr
+        border = dict(el.get("border") or {})
+        border.setdefault("width", 2)
+        border.setdefault("color", "#000000")
+        ln = ln_xml(spPr, border, theme)
+        arrows = el.get("arrow") or [None, None]
+        if arrows[0]:
+            sub(ln, "a:headEnd", {"type": ARROW_MAP.get(arrows[0], "triangle"),
+                                  "w": "med", "len": "med"})
+        if arrows[1]:
+            sub(ln, "a:tailEnd", {"type": ARROW_MAP.get(arrows[1], "triangle"),
+                                  "w": "med", "len": "med"})
+        set_xfrm_flip_rot(shape, el.get("rotation") or 0, el.get("flip"))
+        return shape
+
+    shape = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Pt(x), Pt(y), Pt(w), Pt(h))
+    shape.shadow.inherit = False
+    spPr = shape._element.spPr
+    # geometry
+    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"))
+    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)})
+    _emit_path(path, _path_cmds(pts, el.get("curve", "round")))
+    # no fill, line style
+    for e in spPr.findall(qn("a:noFill")):
+        spPr.remove(e)
+    from .xmlutil import SPPR_ORDER, insert_ordered
+    insert_ordered(spPr, etree.Element(qn("a:noFill")), SPPR_ORDER)
+    border = el.get("border") or {}
+    border = dict(border)
+    border.setdefault("width", 2)
+    border.setdefault("color", "#000000")
+    ln = ln_xml(spPr, border, theme)
+    arrows = el.get("arrow") or [None, None]
+    if arrows[0]:
+        sub(ln, "a:headEnd", {"type": ARROW_MAP.get(arrows[0], "triangle"),
+                              "w": "med", "len": "med"})
+    if arrows[1]:
+        sub(ln, "a:tailEnd", {"type": ARROW_MAP.get(arrows[1], "triangle"),
+                               "w": "med", "len": "med"})
+    opacity = el.get("opacity", 1.0)
+    if opacity is not None and float(opacity) < 1.0:
+        val = str(int(float(opacity) * 100000))
+        for srgb in spPr.iter(qn("a:srgbClr")):
+            if srgb.find(qn("a:alpha")) is None:
+                sub(srgb, "a:alpha", {"val": val})
+    shadow_xml(spPr, el.get("shadow"), theme)
+    set_xfrm_flip_rot(shape, el.get("rotation") or 0, el.get("flip"))
+    return shape