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

pptd_utils/style.py

@@ -0,0 +1,253 @@
+"""Colors, fills (solid/gradient/image), borders, shadows -> DrawingML XML."""
+import hashlib
+import urllib.request
+from pathlib import Path
+
+from lxml import etree
+from pptx.dml.color import RGBColor
+from pptx.oxml.ns import qn
+from pptx.util import Pt
+
+from .xmlutil import sub, insert_ordered, SPPR_ORDER, TCPR_ORDER
+
+URL_CACHE = Path.home() / ".cache" / "pptd_utils" / "urls"
+
+
+# ----------------------------------------------------------------- colors
+
+def resolve_color(c, theme=None, alpha=None):
+    """'$primary' / '#RRGGBB' / '#RRGGBBAA' -> (RGBColor, alpha 0..1)."""
+    if c is None:
+        return None, 1.0
+    c = str(c).strip()
+    if c.startswith("$"):
+        colors = (theme or {}).get("colors") or {}
+        key = c[1:]
+        if key not in colors:
+            raise KeyError(f"unknown theme color {c!r}")
+        c = str(colors[key])
+    a = 1.0 if alpha is None else alpha
+    if c.startswith("#"):
+        hexpart = c[1:]
+        if len(hexpart) == 8:
+            a *= int(hexpart[6:8], 16) / 255.0
+            hexpart = hexpart[:6]
+        if len(hexpart) != 6:
+            raise ValueError(f"bad color {c!r}")
+        return RGBColor.from_string(hexpart.upper()), max(0.0, min(1.0, a))
+    raise ValueError(f"unsupported color {c!r}")
+
+
+def color_el(parent, color, theme, alpha=1.0, tag="a:srgbClr"):
+    """Append a color element (with optional alpha) under parent; return it."""
+    rgb, a = resolve_color(color, theme, alpha)
+    el = sub(parent, tag, {"val": str(rgb)})
+    if a < 1.0:
+        sub(el, "a:alpha", {"val": str(int(a * 100000))})
+    return el
+
+
+def hex_to_rgba(color, theme, alpha=1.0):
+    """Pillow helper: '#xxx'/$ref -> (r, g, b, a_int)."""
+    rgb, a = resolve_color(color, theme, alpha)
+    return (rgb[0], rgb[1], rgb[2], int(a * 255))
+
+
+def css_px(value):
+    if value is None:
+        return None
+    return float(str(value).replace("px", "").replace("PX", "").strip() or 0)
+
+
+# ----------------------------------------------------------------- fills
+
+def fetch_url(url):
+    """Download url to cache, return local Path. jpg/jpeg/png/gif only."""
+    if not url.startswith(("http://", "https://")):
+        return Path(url)
+    ext = ".bin"
+    for e in (".jpg", ".jpeg", ".png", ".gif"):
+        if e in url.lower():
+            ext = e
+            break
+    h = hashlib.sha1(url.encode()).hexdigest()[:16]
+    dst = URL_CACHE / (h + ext)
+    if not dst.exists():
+        URL_CACHE.mkdir(parents=True, exist_ok=True)
+        tmp = dst.with_suffix(".part")
+        urllib.request.urlretrieve(url, tmp)
+        tmp.rename(dst)
+    return dst
+
+
+def image_size(src):
+    from PIL import Image
+    with Image.open(src) as im:
+        return im.size
+
+
+def cover_src_rect(src, w, h, crop=None):
+    """Compute a:srcRect attrs (l,t,r,b in 1/1000 %) for 'cover' fit of an
+    image into a w x h box, optionally after proportional crop."""
+    try:
+        iw, ih = image_size(src)
+    except Exception:
+        return None
+    if w <= 0 or h <= 0:
+        return None
+    crop = crop or {}
+    l0 = max(0.0, crop.get("left", 0) or 0)
+    t0 = max(0.0, crop.get("top", 0) or 0)
+    r0 = 1.0 - max(0.0, crop.get("right", 0) or 0)
+    b0 = 1.0 - max(0.0, crop.get("bottom", 0) or 0)
+    sw, sh = r0 - l0, b0 - t0
+    if sw <= 0 or sh <= 0:
+        return None
+    src_ar, box_ar = (sw * iw) / (sh * ih), w / h
+    if src_ar > box_ar:  # too wide -> crop sides
+        keep = box_ar / src_ar
+        cx = (l0 + r0) / 2
+        l, r, t, b = cx - keep * sw / 2, cx + keep * sw / 2, t0, b0
+    else:  # too tall -> crop top/bottom
+        keep = src_ar / box_ar
+        cy = (t0 + b0) / 2
+        t, b, l, r = cy - keep * sh / 2, cy + keep * sh / 2, l0, r0
+    out = {}
+    if l > 0.0001:
+        out["l"] = str(int(round(l * 100000)))
+    if t > 0.0001:
+        out["t"] = str(int(round(t * 100000)))
+    if 1 - r > 0.0001:
+        out["r"] = str(int(round((1 - r) * 100000)))
+    if 1 - b > 0.0001:
+        out["b"] = str(int(round((1 - b) * 100000)))
+    return out or None
+
+
+FILL_TAGS = ("a:noFill", "a:solidFill", "a:gradFill", "a:blipFill",
+             "a:pattFill", "a:grpFill")
+
+
+def _clear_fill(container):
+    for t in FILL_TAGS:
+        for e in container.findall(qn(t)):
+            container.remove(e)
+
+
+def fill_xml(container, fill, theme, alpha=1.0, order=SPPR_ORDER,
+             image_part_fn=None, stretch=True, src_rect=None):
+    """Write a Fill spec as XML under container (spPr / tcPr / bgPr / rPr...).
+
+    image_part_fn(src_path) -> rId, required for image fills.
+    stretch=True uses a:stretch; False (tile) unsupported -> stretch.
+    Returns True if a fill element was written, False if fill is None.
+    """
+    if fill is None:
+        return False
+    ftype = fill.get("type", "solid")
+    _clear_fill(container)
+    fill_alpha = alpha * float(fill.get("opacity", 1.0))
+    if ftype == "solid":
+        sf = etree.SubElement(container, qn("a:solidFill"))
+        insert_ordered(container, sf, order)
+        color_el(sf, fill.get("color", "#000000"), theme, fill_alpha)
+        return True
+    if ftype == "gradient":
+        gf = sub(container, "a:gradFill", {"rotWithShape": "1"})
+        insert_ordered(container, gf, order)
+        sub(gf, "a:gsLst")
+        gslst = gf.find(qn("a:gsLst"))
+        for stop in fill.get("stops", []):
+            gs = sub(gslst, "a:gs", {"pos": str(int(stop.get("position", 0) * 100000))})
+            color_el(gs, stop.get("color", "#000000"), theme,
+                     fill_alpha * float(stop.get("opacity", 1.0)))
+        gt = fill.get("gradientType", "linear")
+        if gt == "radial":
+            path = sub(gf, "a:path", {"path": "circle"})
+            sub(path, "a:fillToRect", {"l": "50000", "t": "50000", "r": "50000", "b": "50000"})
+        else:
+            sub(gf, "a:lin", {"ang": str(int(fill.get("angle", 0) * 60000)), "scaled": "1"})
+        return True
+    if ftype == "image":
+        if image_part_fn is None:
+            return False
+        src = fill.get("src")
+        path = fetch_url(src) if str(src).startswith("http") else Path(src)
+        rid = image_part_fn(path)
+        bf = sub(container, "a:blipFill")
+        insert_ordered(container, bf, order)
+        blip = sub(bf, "a:blip")
+        blip.set(qn("r:embed"), rid)
+        opacity = fill.get("opacity", 1.0)
+        if opacity is not None and float(opacity) < 1.0:
+            sub(blip, "a:alphaModFix", {"amt": str(int(float(opacity) * 100000))})
+        rect = src_rect
+        if rect is None and fill.get("fit", {}).get("mode", "cover") == "cover":
+            rect = cover_src_rect(path, 100, 100)
+        if rect:
+            sub(bf, "a:srcRect", rect)
+        if stretch:
+            st = sub(bf, "a:stretch")
+            sub(st, "a:fillRect")
+        return True
+    raise ValueError(f"unsupported fill type {ftype!r}")
+
+
+# ----------------------------------------------------------------- border
+
+def line_style_attrs(border):
+    return {"solid": "solid", "dash": "dash", "dot": "sysDot"}.get(
+        border.get("style", "solid"), "solid")
+
+
+def ln_xml(container, border, theme, alpha=1.0, order=SPPR_ORDER):
+    """Write a:ln from Border spec; border None -> clear line (a:ln noFill)."""
+    from pptx.enum.dml import MSO_LINE
+    dash = {"solid": None, "dash": MSO_LINE.DASH, "dot": MSO_LINE.ROUND_DOT}
+    if border is None:
+        for e in container.findall(qn("a:ln")):
+            container.remove(e)
+        ln = sub(container, "a:ln", {"w": str(int(Pt(border and border.get("width", 1) or 1)))})
+        insert_ordered(container, ln, order)
+        sub(ln, "a:noFill")
+        return ln
+    for e in container.findall(qn("a:ln")):
+        container.remove(e)
+    w = border.get("width", 1)
+    ln = sub(container, "a:ln", {"w": str(int(Pt(w)))})
+    insert_ordered(container, ln, order)
+    sf = sub(ln, "a:solidFill")
+    color_el(sf, border.get("color", "#000000"), theme, alpha)
+    if border.get("style") in ("dash", "dot"):
+        sub(ln, "a:prstDash", {"val": line_style_attrs(border)})
+    sub(ln, "a:round")
+    return ln
+
+
+# ----------------------------------------------------------------- shadow
+
+def shadow_xml(container, shadow, theme, order=SPPR_ORDER):
+    """Write a:effectLst/a:outerShdw; shadow None -> remove effectLst."""
+    if shadow is None:
+        for e in container.findall(qn("a:effectLst")):
+            container.remove(e)
+        return
+    for e in container.findall(qn("a:effectLst")):
+        container.remove(e)
+    el = sub(container, "a:effectLst")
+    insert_ordered(container, el, order)
+    shdw = sub(el, "a:outerShdw", {
+        "blurRad": str(int(Pt(shadow.get("blur", 4)))),
+        "dist": str(int(Pt(0))),
+        "dir": "2700000",
+        "rotWithShape": "0",
+    })
+    off = shadow.get("offset") or [0, 0]
+    dx, dy = float(off[0]), float(off[1])
+    import math
+    if dx or dy:
+        dist = math.hypot(dx, dy)
+        ang = math.degrees(math.atan2(dy, dx)) % 360
+        shdw.set("dist", str(int(Pt(dist))))
+        shdw.set("dir", str(int(ang * 60000)))
+    color_el(shdw, shadow.get("color", "#000000"), theme)

pptd_utils/tables.py

@@ -0,0 +1,241 @@
+"""Table element: merges, full style-inheritance chain, per-side borders."""
+from lxml import etree
+from pptx.oxml.ns import qn
+from pptx.util import Pt
+
+from .render_text import emit_text, TEXTSTYLE_KEYS
+from .style import fill_xml, color_el, line_style_attrs
+from .xmlutil import sub, insert_ordered, TCPR_ORDER
+
+CELL_DEFAULTS = {
+    "color": "#000000", "fontSize": 14, "fontFamily": "MiSans",
+    "bold": False, "italic": False, "lineHeight": 1,
+    "letterSpacing": 0, "marginTop": 0,
+    "fill": None, "border": None, "align": ["center", "middle"],
+}
+TEXT_KEYS = ("color", "fontSize", "fontFamily", "bold", "italic",
+             "backgroundColor", "lineHeight", "lineHeightPx",
+             "letterSpacing", "marginTop")
+LAYOUT_KEYS = ("fill", "border", "align")
+
+
+def _norm_border_spec(spec):
+    """BorderSpec -> {side: Border|None} for t/r/b/l; None = unspecified."""
+    if spec is None:
+        return None
+    if isinstance(spec, dict):
+        b = {k: spec.get(k) for k in ("style", "width", "color")}
+        return {"t": b, "r": b, "b": b, "l": b}
+    if isinstance(spec, list):
+        if len(spec) == 2:
+            tb, lr = spec
+            return {"t": tb, "b": tb, "l": lr, "r": lr}
+        if len(spec) == 4:
+            t, r, b, l = spec
+            return {"t": t, "r": r, "b": b, "l": l}
+    raise ValueError(f"bad BorderSpec {spec!r}")
+
+
+def _merge(dst, src, keys):
+    for k in keys:
+        if src and src.get(k) is not None:
+            dst[k] = src[k]
+
+
+def resolve_cell_style(r, c, nrows, ncols, cfg, cell, table_fill):
+    """Full pptd table style chain -> flat dict + per-side borders."""
+    out = dict(CELL_DEFAULTS)
+    _merge(out, cfg.get("cellStyle"), TEXT_KEYS + LAYOUT_KEYS)
+    # bodyStyles: data rows (not first/last), cycled by data-row index
+    body = cfg.get("bodyStyles")
+    if body and r not in (0, nrows - 1):
+        di = r - 1 if nrows > 2 else r
+        bs = body[di % len(body)]
+        _merge(out, bs, TEXT_KEYS + LAYOUT_KEYS)
+    # category styles
+    row_style = None
+    if r == 0 and cfg.get("firstRowStyle") is not None:
+        row_style = cfg["firstRowStyle"]
+    elif r == nrows - 1 and nrows > 1 and cfg.get("lastRowStyle") is not None:
+        row_style = cfg["lastRowStyle"]
+    col_style = None
+    if c == 0 and cfg.get("firstColumnStyle") is not None:
+        col_style = cfg["firstColumnStyle"]
+    elif c == ncols - 1 and ncols > 1 and cfg.get("lastColumnStyle") is not None:
+        col_style = cfg["lastColumnStyle"]
+    row_wins = cfg.get("rowOverColumn", True)
+    loser, winner = (col_style, row_style) if row_wins else (row_style, col_style)
+    _merge(out, loser, TEXT_KEYS + LAYOUT_KEYS)
+    _merge(out, winner, TEXT_KEYS + LAYOUT_KEYS)
+    # 5. cell.textStyle theme ref (text fields only)
+    if cell.get("textStyle"):
+        ref = cell["_theme_textstyles"].get(str(cell["textStyle"]).lstrip("$"), {})
+        _merge(out, ref, TEXT_KEYS)
+    # 4. cell inline
+    _merge(out, cell, TEXT_KEYS + LAYOUT_KEYS)
+    # table-level fill under everything
+    if out.get("fill") is None and table_fill is not None:
+        out["fill"] = table_fill
+    return out
+
+
+UNSET = object()  # distinguishes 'field absent' from 'explicit null' (clear)
+
+
+def _border_sides(r, c, nrows, ncols, cfg, cell):
+    """Resolve per-side Border|None from the chain (top-down per side).
+    Chain: cell.border > row/col category (rowOverColumn) > bodyStyles >
+    cellStyle.border. Explicit null clears all sides at that level."""
+    specs = [cell.get("border", UNSET)]
+    row_style = (cfg.get("firstRowStyle") if r == 0 else
+                 cfg.get("lastRowStyle") if r == nrows - 1 else None)
+    col_style = (cfg.get("firstColumnStyle") if c == 0 else
+                 cfg.get("lastColumnStyle") if c == ncols - 1 else None)
+    row_wins = cfg.get("rowOverColumn", True)
+    loser, winner = (col_style, row_style) if row_wins else (row_style, col_style)
+    if loser is not None:
+        specs.append(loser.get("border", UNSET))
+    if winner is not None:
+        specs.append(winner.get("border", UNSET))
+    body = cfg.get("bodyStyles")
+    if body and r not in (0, nrows - 1):
+        di = r - 1 if nrows > 2 else r
+        specs.append(body[di % len(body)].get("border", UNSET))
+    if cfg.get("cellStyle") is not None:
+        specs.append(cfg["cellStyle"].get("border", UNSET))
+
+    resolved = {}
+    for spec in specs:
+        if spec is UNSET:
+            continue
+        if spec is None:  # explicit clear-all
+            for side in ("t", "r", "b", "l"):
+                resolved.setdefault(side, None)
+            continue
+        norm = _norm_border_spec(spec)
+        for side in ("t", "r", "b", "l"):
+            if side not in resolved:
+                resolved[side] = norm.get(side)
+    default = {"style": "solid", "width": 1, "color": "#000000"}
+    for side in ("t", "r", "b", "l"):
+        if side not in resolved:
+            resolved[side] = default
+    return resolved
+
+
+def render_table(slide, el, theme, root):
+    ncols = len(el["columnWidths"])
+    rows = el["rows"]
+    grid = {}
+    occupied = set()
+    r = 0
+    max_row = 0
+    for row in rows:
+        c = 0
+        for cell in row:
+            while (r, c) in occupied:
+                c += 1
+            rs = int(cell.get("rowSpan", 1) or 1)
+            cs = int(cell.get("colSpan", 1) or 1)
+            grid[(r, c)] = cell
+            for dr in range(rs):
+                for dc in range(cs):
+                    if dr or dc:
+                        occupied.add((r + dr, c + dc))
+            max_row = max(max_row, r + rs)
+            c += cs
+        r += 1
+    nrows = max(r, max_row)
+
+    x, y, w, h = el["bounds"]
+    tbl_shape = slide.shapes.add_table(nrows, ncols, Pt(x), Pt(y), Pt(w), Pt(h))
+    table = tbl_shape.table
+    # explicit grid geometry from ratios
+    for i, ratio in enumerate(el["columnWidths"]):
+        table.columns[i].width = Pt(w * ratio)
+    for i, ratio in enumerate(el["rowHeights"][:nrows]):
+        table.rows[i].height = Pt(h * ratio)
+    if len(el["rowHeights"]) < nrows:  # rows beyond provided ratios: equal split
+        rest = nrows - len(el["rowHeights"])
+        per = h / max(1, nrows)
+        for i in range(len(el["rowHeights"]), nrows):
+            table.rows[i].height = Pt(per)
+    # strip default banded style
+    tbl = table._tbl
+    tblPr = tbl.find(qn("a:tblPr"))
+    if tblPr is not None:
+        for a in ("firstRow", "lastRow", "firstCol", "lastCol", "bandRow", "bandCol"):
+            tblPr.set(a, "0")
+        for sid in tblPr.findall(qn("a:tableStyleId")):
+            tblPr.remove(sid)
+
+    # resolve TableStyleConfig
+    style = el.get("style")
+    cfg = {}
+    if style:
+        if isinstance(style, str):
+            cfg = (theme.get("tableStyles") or {}).get(style.lstrip("$"), {})
+        else:
+            cfg = style
+    table_fill = el.get("fill")
+
+    # apply merges first
+    for (rr, cc), cell in grid.items():
+        rs = int(cell.get("rowSpan", 1) or 1)
+        cs = int(cell.get("colSpan", 1) or 1)
+        if rs > 1 or cs > 1:
+            origin = table.cell(rr, cc)
+            end = table.cell(rr + rs - 1, cc + cs - 1)
+            origin.merge(end)
+
+    for (rr, cc), cell in sorted(grid.items()):
+        table_cell = table.cell(rr, cc)
+        cell_env = dict(cell)
+        cell_env["_theme_textstyles"] = theme.get("textStyles") or {}
+        flat = resolve_cell_style(rr, cc, nrows, ncols, cfg, cell_env, table_fill)
+        sides = _border_sides(rr, cc, nrows, ncols, cfg, cell)
+        tcPr = table_cell._tc.get_or_add_tcPr()
+        # fill
+        fill_xml(tcPr, flat.get("fill"), theme, order=TCPR_ORDER,
+                 image_part_fn=_ipf(slide))
+        # borders: lnL lnR lnT lnB
+        for side, tag in (("l", "a:lnL"), ("r", "a:lnR"), ("t", "a:lnT"), ("b", "a:lnB")):
+            for e in tcPr.findall(qn(tag)):
+                tcPr.remove(e)
+            b = sides.get(side)
+            if not b:
+                continue
+            ln = etree.Element(qn(tag))
+            ln.set("w", str(int(Pt(b.get("width", 1)))))
+            ln.set("cap", "flat")
+            ln.set("cmpd", "sng")
+            ln.set("algn", "ctr")
+            sf = sub(ln, "a:solidFill")
+            color_el(sf, b.get("color", "#000000"), theme)
+            if b.get("style") in ("dash", "dot"):
+                sub(ln, "a:prstDash", {"val": line_style_attrs(b)})
+            insert_ordered(tcPr, ln, TCPR_ORDER)
+        # text
+        align = flat.get("align") or ["center", "middle"]
+        tf = table_cell.text_frame
+        tf.word_wrap = True
+        from pptx.enum.text import MSO_ANCHOR
+        tf.vertical_anchor = {"top": MSO_ANCHOR.TOP, "middle": MSO_ANCHOR.MIDDLE,
+                              "bottom": MSO_ANCHOR.BOTTOM}.get(align[1], MSO_ANCHOR.MIDDLE)
+        fs = flat.get("fontSize")
+        if fs is None:
+            rh = h * el["rowHeights"][rr] if rr < len(el["rowHeights"]) else h / nrows
+            fs = max(10, min(18, rh * 0.45))
+        content = {k: v for k, v in flat.items() if k in TEXT_KEYS}
+        content["text"] = cell.get("text", "")
+        content.setdefault("fontSize", fs)
+        content["align"] = align
+        emit_text(tf, content, theme, default_align=align)
+    return tbl_shape
+
+
+def _ipf(slide):
+    def fn(path):
+        part, rid = slide.part.get_or_add_image_part(str(path))
+        return rid
+    return fn

pptd_utils/xmlutil.py

@@ -0,0 +1,109 @@
+"""Low-level XML helpers: element creation in schema order, namespaces."""
+from lxml import etree
+from pptx.oxml.ns import qn as _qn
+
+NSMAP = {
+    "a": "http://schemas.openxmlformats.org/drawingml/2006/main",
+    "p": "http://schemas.openxmlformats.org/presentationml/2006/main",
+    "r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    "c": "http://schemas.openxmlformats.org/drawingml/2006/chart",
+    "m": "http://schemas.openxmlformats.org/officeDocument/2006/math",
+    "mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
+}
+
+
+def qn(tag):
+    return _qn(tag)
+
+
+def E(tag, attrs=None, text=None):
+    """Create element 'a:gradFill' style. attrs values: str|number."""
+    e = etree.SubElement  # placeholder
+    root = etree.Element(qn(tag), nsmap=None)
+    if attrs:
+        for k, v in attrs.items():
+            if v is not None:
+                root.set(k, str(v))
+    if text is not None:
+        root.text = str(text)
+    return root
+
+
+def sub(parent, tag, attrs=None, text=None):
+    e = etree.SubElement(parent, qn(tag), nsmap=None)
+    if attrs:
+        for k, v in attrs.items():
+            if v is not None:
+                e.set(k, str(v))
+    if text is not None:
+        e.text = str(text)
+    return e
+
+
+def insert_ordered(parent, child, order):
+    """Insert child into parent before the first existing element whose tag
+    comes after child's tag in `order` (list of qn-style tags)."""
+    try:
+        idx = order.index(child.tag)
+    except ValueError:
+        parent.append(child)
+        return child
+    for existing in parent:
+        try:
+            eidx = order.index(existing.tag)
+        except ValueError:
+            continue
+        if eidx > idx:
+            existing.addprevious(child)
+            return child
+    parent.append(child)
+    return child
+
+
+# Schema child orders (subset used by this package)
+RPR_ORDER = [qn(t) for t in (
+    "a:ln", "a:noFill", "a:solidFill", "a:gradFill", "a:blipFill", "a:pattFill",
+    "a:grpFill", "a:effectLst", "a:effectDag", "a:highlight", "a:uLnTx", "a:uLn",
+    "a:uFillTx", "a:uFill", "a:latin", "a:ea", "a:cs", "a:sym", "a:hlinkClick",
+    "a:hlinkMouseOver", "a:rtl", "a:extLst")]
+
+PPR_ORDER = [qn(t) for t in (
+    "a:lnSpc", "a:spcBef", "a:spcAft", "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")]
+
+TCPR_ORDER = [qn(t) for t in (
+    "a:lnL", "a:lnR", "a:lnT", "a:lnB", "a:lnTlToBr", "a:lnBlToTr", "a:cell3D",
+    "a:noFill", "a:solidFill", "a:gradFill", "a:blipFill", "a:pattFill",
+    "a:grpFill", "a:headers", "a:extLst")]
+
+SPPR_ORDER = [qn(t) for t in (
+    "a:xfrm", "a:custGeom", "a:prstGeom", "a:noFill", "a:solidFill",
+    "a:gradFill", "a:blipFill", "a:pattFill", "a:grpFill", "a:ln",
+    "a:effectLst", "a:effectDag", "a:scene3d", "a:sp3d", "a:extLst")]
+
+
+def parse_xml(xml_str):
+    """Parse an XML fragment with our namespaces bound (a/p/c/r/m)."""
+    wrapper = ('<root xmlns:a="%(a)s" xmlns:p="%(p)s" xmlns:r="%(r)s" '
+               'xmlns:c="%(c)s" xmlns:m="%(m)s">%%s</root>') % NSMAP
+    root = etree.fromstring(wrapper % xml_str)
+    children = list(root)
+    for ch in children:
+        root.remove(ch)
+    return children
+
+
+def set_xfrm_flip_rot(shape, rotation=0, flip=None):
+    """Apply rotation (deg cw) and flip [h,v] to an autoshape/picture."""
+    spPr = shape._element.spPr
+    xfrm = spPr.find(qn("a:xfrm"))
+    if xfrm is None:
+        return
+    if rotation:
+        xfrm.set("rot", str(int(round(rotation * 60000)) % 21600000))
+    if flip:
+        if flip[0]:
+            xfrm.set("flipH", "1")
+        if flip[1]:
+            xfrm.set("flipV", "1")